Upload 5 files

binary_processor.py

@@ -0,0 +1,893 @@
+"""
+Binary File Processor for HenAi
+Extracts metadata, text, and structured data from various binary file formats
+- Multi-backend audio processing with fallbacks
+- OCR using EasyOCR (no external dependencies)
+- Comprehensive file type support
+"""
+
+import io
+import os
+import tempfile
+from typing import Dict, Any, Optional, Tuple
+
+# ============= TRY IMPORTS WITH FALLBACKS =============
+
+# Image processing
+try:
+    from PIL import Image, ImageOps, ImageEnhance
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+    print("Warning: PIL/Pillow not available. Install with: pip install Pillow")
+
+try:
+    import exifread
+    EXIF_AVAILABLE = True
+except ImportError:
+    EXIF_AVAILABLE = False
+
+# OCR (Pure Python, no external dependencies)
+try:
+    import easyocr
+    EASYOCR_AVAILABLE = True
+    _easyocr_reader = None
+except ImportError:
+    EASYOCR_AVAILABLE = False
+    print("Warning: EasyOCR not available. Install with: pip install easyocr")
+
+# Audio processing - multiple backends
+try:
+    from pydub import AudioSegment
+    PYDUB_AVAILABLE = True
+except ImportError:
+    PYDUB_AVAILABLE = False
+
+try:
+    import speech_recognition as sr
+    SPEECH_RECOGNITION_AVAILABLE = True
+except ImportError:
+    SPEECH_RECOGNITION_AVAILABLE = False
+
+try:
+    import mutagen
+    MUTAGEN_AVAILABLE = True
+except ImportError:
+    MUTAGEN_AVAILABLE = False
+
+try:
+    import audioread
+    AUDIOREAD_AVAILABLE = True
+except ImportError:
+    AUDIOREAD_AVAILABLE = False
+
+try:
+    import librosa
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+
+# PDF processing
+try:
+    import pdfplumber
+    PDFPLUMBER_AVAILABLE = True
+except ImportError:
+    PDFPLUMBER_AVAILABLE = False
+
+# Spreadsheet processing
+try:
+    import pandas as pd
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+
+try:
+    import openpyxl
+    OPENPYXL_AVAILABLE = True
+except ImportError:
+    OPENPYXL_AVAILABLE = False
+
+# Document processing
+try:
+    from docx import Document
+    DOCX_AVAILABLE = True
+except ImportError:
+    DOCX_AVAILABLE = False
+
+try:
+    from pptx import Presentation
+    PPTX_AVAILABLE = True
+except ImportError:
+    PPTX_AVAILABLE = False
+
+# Archive processing
+try:
+    import zipfile
+    import tarfile
+    ARCHIVE_AVAILABLE = True
+except ImportError:
+    ARCHIVE_AVAILABLE = False
+
+# Encoding detection
+try:
+    import chardet
+    CHARDET_AVAILABLE = True
+except ImportError:
+    CHARDET_AVAILABLE = False
+
+# Whisper for advanced transcription (optional)
+try:
+    import whisper
+    WHISPER_AVAILABLE = True
+except ImportError:
+    WHISPER_AVAILABLE = False
+
+# Video processing
+try:
+    import cv2
+    import numpy as np
+    CV2_AVAILABLE = True
+except ImportError:
+    CV2_AVAILABLE = False
+
+
+def get_easyocr_reader():
+    """Lazy initialization of EasyOCR reader"""
+    global _easyocr_reader
+    if _easyocr_reader is None and EASYOCR_AVAILABLE:
+        try:
+            # Use CPU only, English language
+            _easyocr_reader = easyocr.Reader(['en'], gpu=False)
+            print("EasyOCR initialized successfully")
+        except Exception as e:
+            print(f"Failed to initialize EasyOCR: {e}")
+    return _easyocr_reader
+
+
+class BinaryProcessor:
+    """Main processor for all binary file types"""
+    
+    def __init__(self):
+        self.initialize_handlers()
+    
+    def initialize_handlers(self):
+        """Initialize all format-specific handlers"""
+        self.handlers = {
+            'image': self.process_image,
+            'audio': self.process_audio,
+            'video': self.process_video,
+            'pdf': self.process_pdf,
+            'spreadsheet': self.process_spreadsheet,
+            'word': self.process_word_document,
+            'presentation': self.process_presentation,
+            'archive': self.process_archive,
+            'database': self.process_database,
+            'text': self.process_text_file,
+        }
+    
+    def process_file(self, file_content: bytes, filename: str) -> str:
+        """
+        Main entry point - processes any file and returns formatted text for AI
+        """
+        file_ext = filename.split('.')[-1].lower() if '.' in filename else ''
+        
+        # Build output header
+        output = f"\n\n--- FILE: {filename} ---\n"
+        output += f"Size: {len(file_content)} bytes\n"
+        
+        # Route to appropriate handler based on extension
+        if file_ext in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp', 'ico']:
+            output += self.process_image(file_content, filename)
+        elif file_ext in ['mp3', 'wav', 'ogg', 'flac', 'm4a', 'aac', 'wma', 'opus']:
+            output += self.process_audio(file_content, filename)
+        elif file_ext in ['mp4', 'avi', 'mov', 'mkv', 'webm', 'flv', 'wmv']:
+            output += self.process_video(file_content, filename)
+        elif file_ext == 'pdf':
+            output += self.process_pdf(file_content, filename)
+        elif file_ext in ['xlsx', 'xls', 'csv', 'xlsm', 'xlsb']:
+            output += self.process_spreadsheet(file_content, filename)
+        elif file_ext in ['docx', 'doc', 'odt']:
+            output += self.process_word_document(file_content, filename)
+        elif file_ext in ['pptx', 'ppt', 'odp']:
+            output += self.process_presentation(file_content, filename)
+        elif file_ext in ['zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz']:
+            output += self.process_archive(file_content, filename)
+        elif file_ext in ['db', 'sqlite', 'sqlite3', 'db3']:
+            output += self.process_database(file_content, filename)
+        elif file_ext in ['txt', 'md', 'py', 'js', 'html', 'css', 'json', 'xml', 
+                          'java', 'c', 'cpp', 'h', 'hpp', 'rb', 'php', 'go', 'rs', 
+                          'swift', 'kt', 'ts', 'jsx', 'tsx', 'vue']:
+            output += self.process_text_file(file_content, filename)
+        else:
+            # Try text extraction as fallback - INCREASED LIMIT
+            text_result = self.try_extract_text(file_content)
+            if text_result:
+                output += f"\n--- EXTRACTED TEXT ---\n{text_result}\n--- END TEXT ---\n"
+            else:
+                output += f"\n[Binary file: {filename}]\n"
+                output += "No further extraction available for this file type.\n"
+        
+        output += "--- END FILE ---\n\n"
+        return output
+    
+    def process_image(self, content: bytes, filename: str) -> str:
+        """Extract image metadata and perform OCR using EasyOCR (no external dependencies)"""
+        output = "\n--- IMAGE ANALYSIS ---\n"
+        
+        if not PIL_AVAILABLE:
+            output += "❌ Image processing not available (Pillow not installed)\n"
+            output += "Install with: pip install Pillow\n"
+            output += "--- END IMAGE ANALYSIS ---\n"
+            return output
+        
+        try:
+            img = Image.open(io.BytesIO(content))
+            output += f"📐 Dimensions: {img.width}x{img.height}\n"
+            output += f"🎨 Format: {img.format}\n"
+            output += f"🖼️ Mode: {img.mode}\n"
+            
+            # EXIF data
+            if EXIF_AVAILABLE:
+                try:
+                    with io.BytesIO(content) as f:
+                        tags = exifread.process_file(f)
+                        if tags:
+                            output += "\n📷 EXIF DATA:\n"
+                            for tag, value in list(tags.items())[:10]:
+                                output += f"  • {tag}: {value}\n"
+                except:
+                    pass
+            
+            # OCR for text in images using EasyOCR
+            if EASYOCR_AVAILABLE:
+                try:
+                    reader = get_easyocr_reader()
+                    if reader:
+                        # Scale image if too large (improves OCR speed)
+                        if img.width > 1500 or img.height > 1500:
+                            img.thumbnail((1500, 1500))
+                            output += f"\n📏 Image scaled for OCR\n"
+                        
+                        # Convert PIL image to numpy array
+                        import numpy as np
+                        img_array = np.array(img)
+                        
+                        # Run OCR
+                        output += "\n🔍 OCR PROCESSING:\n"
+                        results = reader.readtext(img_array)
+                        
+                        if results:
+                            extracted_text = []
+                            high_confidence_text = []
+                            
+                            for (bbox, text, confidence) in results:
+                                if confidence > 0.5:
+                                    high_confidence_text.append(text)
+                                extracted_text.append(text)
+                            
+                            if high_confidence_text:
+                                full_text = ' '.join(high_confidence_text)
+                                output += f"✅ Extracted {len(full_text)} characters (high confidence)\n"
+                                output += f"\n📝 EXTRACTED TEXT:\n{full_text.strip()}\n"
+                            elif extracted_text:
+                                full_text = ' '.join(extracted_text)
+                                output += f"⚠️ Extracted {len(full_text)} characters (low confidence)\n"
+                                output += f"\n📝 EXTRACTED TEXT:\n{full_text.strip()}\n"
+                            else:
+                                output += "❌ No readable text detected in image\n"
+                        else:
+                            output += "❌ No text detected in the image\n"
+                except Exception as e:
+                    output += f"\n⚠️ OCR processing error: {str(e)}\n"
+                    output += "Make sure EasyOCR is installed: pip install easyocr\n"
+            else:
+                output += "\n⚠️ EasyOCR not installed. Install with: pip install easyocr\n"
+                output += "This will enable text extraction from images without external dependencies.\n"
+            
+            output += "--- END IMAGE ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing image: {str(e)}\n"
+        
+        return output
+    
+    def extract_ocr_text(self, image_content: bytes, filename: str) -> str:
+        """
+        Extract only OCR text from an image without all the metadata
+        """
+        if not EASYOCR_AVAILABLE:
+            return "[EasyOCR not installed. Install with: pip install easyocr]"
+    
+        try:
+            from PIL import Image
+            import numpy as np
+        
+            img = Image.open(io.BytesIO(image_content))
+        
+            # Scale image if too large
+            if img.width > 1500 or img.height > 1500:
+                img.thumbnail((1500, 1500))
+        
+            img_array = np.array(img)
+            reader = get_easyocr_reader()
+        
+            if reader:
+                results = reader.readtext(img_array)
+                if results:
+                    extracted_text = []
+                    for (bbox, text, confidence) in results:
+                        if confidence > 0.3:  # Lower threshold for more text
+                            extracted_text.append(text)
+                
+                    if extracted_text:
+                        return ' '.join(extracted_text)
+        
+            return ""
+        except Exception as e:
+            print(f"OCR extraction error: {e}")
+            return f"[OCR error: {str(e)}]"
+    
+    def process_audio(self, content: bytes, filename: str) -> str:
+        """
+        Extract audio metadata and transcribe speech with multiple fallback methods
+        Tries: 1. Mutagen (metadata) → 2. Audioread (info) → 3. Pydub (properties) → 4. Whisper (transcription) → 5. SpeechRecognition
+        """
+        output = "\n--- AUDIO ANALYSIS ---\n"
+        output += f"🎵 File: {filename}\n"
+        output += f"📦 Size: {len(content)} bytes\n"
+        
+        temp_file_path = None
+        try:
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(suffix='.' + filename.split('.')[-1], delete=False) as tmp:
+                tmp.write(content)
+                tmp.flush()
+                temp_file_path = tmp.name
+            
+            # ============= METHOD 1: Mutagen (Best for metadata) =============
+            if MUTAGEN_AVAILABLE:
+                try:
+                    audio_file = mutagen.File(temp_file_path)
+                    if audio_file:
+                        output += "\n📋 METADATA (Mutagen):\n"
+                        
+                        # Get info
+                        if hasattr(audio_file, 'info'):
+                            info = audio_file.info
+                            if hasattr(info, 'length'):
+                                minutes = int(info.length // 60)
+                                seconds = int(info.length % 60)
+                                output += f"  • Duration: {minutes}:{seconds:02d} ({info.length:.2f} seconds)\n"
+                            if hasattr(info, 'bitrate'):
+                                output += f"  • Bitrate: {info.bitrate} bps\n"
+                            if hasattr(info, 'sample_rate'):
+                                output += f"  • Sample Rate: {info.sample_rate} Hz\n"
+                            if hasattr(info, 'channels'):
+                                output += f"  • Channels: {info.channels}\n"
+                        
+                        # Get tags
+                        if hasattr(audio_file, 'tags') and audio_file.tags:
+                            output += "\n🏷️ TAGS:\n"
+                            for key, value in list(audio_file.tags.items())[:15]:
+                                output += f"  • {key}: {value}\n"
+                except Exception as e:
+                    output += f"\n⚠️ Mutagen metadata extraction failed: {str(e)}\n"
+            
+            # ============= METHOD 2: Audioread (Fallback for audio info) =============
+            if AUDIOREAD_AVAILABLE and not (MUTAGEN_AVAILABLE and 'Duration' in output):
+                try:
+                    with audioread.audio_open(temp_file_path) as f:
+                        output += "\n📊 AUDIO INFO (Audioread):\n"
+                        duration = f.duration
+                        minutes = int(duration // 60)
+                        seconds = int(duration % 60)
+                        output += f"  • Duration: {minutes}:{seconds:02d} ({duration:.2f} seconds)\n"
+                        output += f"  • Sample Rate: {f.samplerate} Hz\n"
+                        output += f"  • Channels: {f.channels}\n"
+                        if hasattr(f, 'bitrate'):
+                            output += f"  • Bitrate: {f.bitrate} bps\n"
+                except Exception as e:
+                    output += f"\n⚠️ Audioread info extraction failed: {str(e)}\n"
+            
+            # ============= METHOD 3: Pydub (For additional properties) =============
+            if PYDUB_AVAILABLE:
+                try:
+                    audio = AudioSegment.from_file(temp_file_path)
+                    duration = len(audio) / 1000
+                    minutes = int(duration // 60)
+                    seconds = int(duration % 60)
+                    output += "\n🎚️ AUDIO PROPERTIES (Pydub):\n"
+                    output += f"  • Duration: {minutes}:{seconds:02d} ({duration:.2f} seconds)\n"
+                    output += f"  • Channels: {audio.channels}\n"
+                    output += f"  • Frame Rate: {audio.frame_rate} Hz\n"
+                    output += f"  • Sample Width: {audio.sample_width} bytes\n"
+                    output += f"  • Max Amplitude: {audio.max}\n"
+                    output += f"  • RMS: {audio.rms:.2f}\n"
+                except Exception as e:
+                    output += f"\n⚠️ Pydub processing failed: {str(e)}\n"
+            
+            # ============= METHOD 4: Whisper (Best for transcription - offline) =============
+            if WHISPER_AVAILABLE:
+                try:
+                    output += "\n🎙️ WHISPER TRANSCRIPTION (Offline):\n"
+                    output += "Loading Whisper model (first time may take a moment)...\n"
+                    model = whisper.load_model("base")
+                    result = model.transcribe(temp_file_path, language="en")
+                    if result and result.get("text"):
+                        transcript = result["text"].strip()
+                        output += f"✅ Transcription complete!\n"
+                        output += f"\n📝 TRANSCRIPT:\n{transcript}\n"
+                    else:
+                        output += "❌ No speech detected\n"
+                except Exception as e:
+                    output += f"⚠️ Whisper transcription failed: {str(e)}\n"
+                    output += "Install Whisper: pip install openai-whisper torch\n"
+            
+            # ============= METHOD 5: SpeechRecognition (Fallback - online) =============
+            elif SPEECH_RECOGNITION_AVAILABLE and not WHISPER_AVAILABLE:
+                try:
+                    # Try to convert to WAV for better compatibility
+                    if PYDUB_AVAILABLE:
+                        try:
+                            audio = AudioSegment.from_file(temp_file_path)
+                            wav_io = io.BytesIO()
+                            audio.export(wav_io, format="wav")
+                            wav_io.seek(0)
+                            audio_source = wav_io
+                        except:
+                            audio_source = temp_file_path
+                    else:
+                        audio_source = temp_file_path
+                    
+                    recognizer = sr.Recognizer()
+                    with sr.AudioFile(audio_source) as source:
+                        output += "\n🎙️ SPEECH RECOGNITION (Google):\n"
+                        recognizer.adjust_for_ambient_noise(source, duration=0.5)
+                        audio_data = recognizer.record(source, duration=30)
+                        
+                        try:
+                            transcript = recognizer.recognize_google(audio_data)
+                            if transcript and transcript.strip():
+                                output += f"✅ Transcription complete!\n"
+                                output += f"\n📝 TRANSCRIPT:\n{transcript.strip()}\n"
+                            else:
+                                output += "❌ No speech detected\n"
+                        except sr.UnknownValueError:
+                            output += "❌ Could not understand audio\n"
+                        except sr.RequestError as e:
+                            output += f"⚠️ Google Speech Recognition error: {str(e)}\n"
+                except Exception as e:
+                    output += f"\n⚠️ Speech recognition failed: {str(e)}\n"
+                    output += "Install SpeechRecognition: pip install SpeechRecognition\n"
+            
+            # ============= METHOD 6: Librosa (Scientific analysis) =============
+            if LIBROSA_AVAILABLE:
+                try:
+                    import numpy as np
+                    y, sr_lib = librosa.load(temp_file_path, sr=None, duration=30)
+                    output += "\n🔬 AUDIO ANALYSIS (Librosa):\n"
+                    output += f"  • RMS Energy: {np.mean(librosa.feature.rms(y=y)):.4f}\n"
+                    output += f"  • Zero Crossing Rate: {np.mean(librosa.feature.zero_crossing_rate(y)):.4f}\n"
+                    try:
+                        tempo, _ = librosa.beat.beat_track(y=y, sr=sr_lib)
+                        output += f"  • Estimated Tempo: {tempo:.2f} BPM\n"
+                    except:
+                        pass
+                except Exception as e:
+                    pass  # Silent fail for librosa as it's optional
+            
+            # Summary of what was successful
+            output += "\n📊 PROCESSING SUMMARY:\n"
+            success_count = 0
+            if MUTAGEN_AVAILABLE and 'METADATA' in output:
+                output += "  ✓ Metadata extracted (Mutagen)\n"
+                success_count += 1
+            if AUDIOREAD_AVAILABLE and 'Audioread' in output:
+                output += "  ✓ Basic info extracted (Audioread)\n"
+                success_count += 1
+            if PYDUB_AVAILABLE and 'Pydub' in output:
+                output += "  ✓ Audio properties analyzed (Pydub)\n"
+                success_count += 1
+            if WHISPER_AVAILABLE and 'TRANSCRIPT' in output:
+                output += "  ✓ Speech transcribed (Whisper)\n"
+                success_count += 1
+            elif SPEECH_RECOGNITION_AVAILABLE and 'TRANSCRIPT' in output:
+                output += "  ✓ Speech transcribed (Google)\n"
+                success_count += 1
+            
+            if success_count == 0:
+                output += "  ⚠️ Limited information available. Install additional packages:\n"
+                output += "     • pip install mutagen audioread (for metadata)\n"
+                output += "     • pip install openai-whisper torch (for transcription)\n"
+                output += "     • pip install pydub (for audio properties)\n"
+            
+        except Exception as e:
+            output += f"\n❌ Critical error processing audio file: {str(e)}\n"
+        finally:
+            # Clean up temp file
+            if temp_file_path and os.path.exists(temp_file_path):
+                try:
+                    os.unlink(temp_file_path)
+                except:
+                    pass
+        
+        output += "--- END AUDIO ANALYSIS ---\n"
+        return output
+    
+    def process_video(self, content: bytes, filename: str) -> str:
+        """Extract video metadata using multiple methods"""
+        output = "\n--- VIDEO ANALYSIS ---\n"
+        output += f"🎬 File: {filename}\n"
+        output += f"📦 Size: {len(content)} bytes\n"
+        
+        temp_file_path = None
+        try:
+            with tempfile.NamedTemporaryFile(suffix='.' + filename.split('.')[-1], delete=False) as tmp:
+                tmp.write(content)
+                tmp.flush()
+                temp_file_path = tmp.name
+            
+            # Try OpenCV for video properties
+            if CV2_AVAILABLE:
+                try:
+                    import numpy as np
+                    cap = cv2.VideoCapture(temp_file_path)
+                    if cap.isOpened():
+                        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+                        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                        fps = cap.get(cv2.CAP_PROP_FPS)
+                        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+                        duration = frame_count / fps if fps > 0 else 0
+                        
+                        output += "\n🎥 VIDEO PROPERTIES (OpenCV):\n"
+                        output += f"  • Resolution: {width}x{height}\n"
+                        output += f"  • FPS: {fps:.2f}\n"
+                        output += f"  • Frame Count: {frame_count}\n"
+                        minutes = int(duration // 60)
+                        seconds = int(duration % 60)
+                        output += f"  • Duration: {minutes}:{seconds:02d} ({duration:.2f} seconds)\n"
+                        cap.release()
+                except Exception as e:
+                    output += f"\n⚠️ OpenCV processing failed: {str(e)}\n"
+            
+            # Try moviepy if available
+            try:
+                from moviepy.editor import VideoFileClip
+                clip = VideoFileClip(temp_file_path)
+                output += "\n🎞️ VIDEO PROPERTIES (MoviePy):\n"
+                output += f"  • Duration: {clip.duration:.2f} seconds\n"
+                output += f"  • FPS: {clip.fps}\n"
+                output += f"  • Size: {clip.size}\n"
+                output += f"  • Has Audio: {clip.audio is not None}\n"
+                clip.close()
+            except ImportError:
+                pass
+            except Exception as e:
+                output += f"\n⚠️ MoviePy processing failed: {str(e)}\n"
+            
+        except Exception as e:
+            output += f"\n❌ Error processing video: {str(e)}\n"
+        finally:
+            if temp_file_path and os.path.exists(temp_file_path):
+                try:
+                    os.unlink(temp_file_path)
+                except:
+                    pass
+        
+        output += "--- END VIDEO ANALYSIS ---\n"
+        return output
+    
+    def process_pdf(self, content: bytes, filename: str) -> str:
+        """Extract text, tables, and metadata from PDFs - FULL CONTENT"""
+        output = "\n--- PDF ANALYSIS ---\n"
+        
+        if not PDFPLUMBER_AVAILABLE:
+            output += "❌ PDF processing not available (pdfplumber not installed)\n"
+            output += "Install with: pip install pdfplumber\n"
+            output += "--- END PDF ANALYSIS ---\n"
+            return output
+        
+        try:
+            with pdfplumber.open(io.BytesIO(content)) as pdf:
+                total_pages = len(pdf.pages)
+                output += f"📄 Pages: {total_pages}\n"
+                
+                # Extract metadata
+                if pdf.metadata:
+                    output += "\n📋 METADATA:\n"
+                    for key, value in pdf.metadata.items():
+                        if value:
+                            output += f"  • {key}: {value}\n"
+                
+                # Extract text from ALL pages - NO LIMIT on number of pages
+                full_text = ""
+                for i, page in enumerate(pdf.pages):
+                    page_text = page.extract_text()
+                    if page_text:
+                        full_text += f"\n--- PAGE {i+1} ---\n{page_text}\n"
+                
+                if full_text:
+                    # NO CHARACTER LIMIT - extract FULL content
+                    # Only add a note if extremely large (over 500KB)
+                    if len(full_text) > 500000:
+                        full_text += f"\n\n[Note: Full PDF content extracted ({len(full_text)} characters).]"
+                    output += f"\n📝 FULL TEXT CONTENT ({len(full_text)} characters):\n{full_text}\n"
+            
+            output += "--- END PDF ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing PDF: {str(e)}\n"
+        
+        return output
+    
+    def process_spreadsheet(self, content: bytes, filename: str) -> str:
+        """Extract data from Excel spreadsheets - FULL CONTENT"""
+        output = "\n--- SPREADSHEET ANALYSIS ---\n"
+        
+        if not PANDAS_AVAILABLE:
+            output += "❌ Spreadsheet processing not available (pandas not installed)\n"
+            output += "Install with: pip install pandas openpyxl\n"
+            output += "--- END SPREADSHEET ANALYSIS ---\n"
+            return output
+        
+        try:
+            # Try pandas for comprehensive analysis
+            df_dict = pd.read_excel(io.BytesIO(content), sheet_name=None)
+            output += f"📊 Sheets: {', '.join(list(df_dict.keys()))}\n"
+            
+            # Process ALL sheets - NO LIMIT
+            for sheet_name, df in df_dict.items():
+                output += f"\n📑 SHEET: {sheet_name}\n"
+                output += f"  • Dimensions: {df.shape[0]} rows x {df.shape[1]} columns\n"
+                output += f"  • Columns: {', '.join(df.columns.astype(str)[:30])}\n"
+                
+                # Show ALL rows if less than 1000, otherwise show first 500
+                if df.shape[0] <= 1000:
+                    full_data = df.to_string()
+                    output += f"\n  FULL DATA:\n{full_data}\n"
+                else:
+                    # Show first 500 rows and note about remaining
+                    sample = df.head(500).to_string()
+                    output += f"\n  DATA (first 500 rows of {df.shape[0]}):\n{sample}\n"
+                    output += f"\n  ... and {df.shape[0] - 500} more rows\n"
+                
+                # Basic statistics for numeric columns
+                numeric_cols = df.select_dtypes(include=['number']).columns
+                if len(numeric_cols) > 0:
+                    output += f"\n  Numeric summary:\n"
+                    output += df[numeric_cols].describe().to_string()
+                    output += "\n"
+            
+            output += "--- END SPREADSHEET ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing spreadsheet: {str(e)}\n"
+        
+        return output
+    
+    def process_word_document(self, content: bytes, filename: str) -> str:
+        """Extract text from Word documents - FULL CONTENT"""
+        output = "\n--- WORD DOCUMENT ANALYSIS ---\n"
+        
+        if not DOCX_AVAILABLE:
+            output += "❌ Word document processing not available (python-docx not installed)\n"
+            output += "Install with: pip install python-docx\n"
+            output += "--- END WORD DOCUMENT ANALYSIS ---\n"
+            return output
+        
+        try:
+            doc = Document(io.BytesIO(content))
+            output += f"📝 Paragraphs: {len(doc.paragraphs)}\n"
+            
+            # Extract text from ALL paragraphs - NO truncation
+            text = '\n'.join([p.text for p in doc.paragraphs if p.text.strip()])
+            if text:
+                # Only add a note if extremely large
+                if len(text) > 500000:
+                    text += f"\n\n[Note: Full document content extracted ({len(text)} characters).]"
+                output += f"\n📄 FULL TEXT CONTENT ({len(text)} characters):\n{text}\n"
+            
+            # Extract tables fully
+            if doc.tables:
+                output += f"\n📊 Tables found: {len(doc.tables)}\n"
+                for table_idx, table in enumerate(doc.tables):
+                    output += f"\n--- TABLE {table_idx + 1} ---\n"
+                    for row in table.rows:
+                        row_text = ' | '.join([cell.text for cell in row.cells])
+                        output += f"{row_text}\n"
+            
+            output += "--- END WORD DOCUMENT ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing Word document: {str(e)}\n"
+        
+        return output
+    
+    def process_presentation(self, content: bytes, filename: str) -> str:
+        """Extract content from PowerPoint presentations"""
+        output = "\n--- PRESENTATION ANALYSIS ---\n"
+        
+        if not PPTX_AVAILABLE:
+            output += "❌ PowerPoint processing not available (python-pptx not installed)\n"
+            output += "Install with: pip install python-pptx\n"
+            output += "--- END PRESENTATION ANALYSIS ---\n"
+            return output
+        
+        try:
+            prs = Presentation(io.BytesIO(content))
+            output += f"📽️ Slides: {len(prs.slides)}\n"
+            
+            slide_text = []
+            for i, slide in enumerate(prs.slides[:10]):
+                slide_content = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        slide_content.append(shape.text)
+                if slide_content:
+                    slide_text.append(f"\n--- SLIDE {i+1} ---\n" + '\n'.join(slide_content))
+            
+            if slide_text:
+                full_text = ''.join(slide_text)
+                if len(full_text) > 10000:
+                    full_text = full_text[:10000] + "\n\n[Content truncated...]"
+                output += f"\n📝 TEXT CONTENT:\n{full_text}\n"
+            
+            output += "--- END PRESENTATION ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing presentation: {str(e)}\n"
+        
+        return output
+    
+    def process_archive(self, content: bytes, filename: str) -> str:
+        """List archive contents"""
+        output = "\n--- ARCHIVE ANALYSIS ---\n"
+        
+        try:
+            file_ext = filename.split('.')[-1].lower()
+            
+            if file_ext == 'zip':
+                with zipfile.ZipFile(io.BytesIO(content)) as zf:
+                    files = zf.namelist()
+                    output += f"📦 Total files: {len(files)}\n"
+                    output += "\n📋 FILE LIST:\n"
+                    for f in files[:50]:
+                        info = zf.getinfo(f)
+                        size = info.file_size
+                        output += f"  • {f} ({size:,} bytes)\n"
+                    if len(files) > 50:
+                        output += f"  ... and {len(files) - 50} more files\n"
+            elif file_ext in ['tar', 'gz', 'bz2']:
+                with tarfile.open(fileobj=io.BytesIO(content), mode='r:*') as tf:
+                    files = tf.getnames()
+                    output += f"📦 Total files: {len(files)}\n"
+                    output += "\n📋 FILE LIST:\n"
+                    for f in files[:50]:
+                        output += f"  • {f}\n"
+                    if len(files) > 50:
+                        output += f"  ... and {len(files) - 50} more files\n"
+            else:
+                output += f"Archive format {file_ext} - size: {len(content)} bytes\n"
+                output += "For full archive support, install: pip install patool\n"
+            
+            output += "--- END ARCHIVE ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing archive: {str(e)}\n"
+        
+        return output
+    
+    def process_database(self, content: bytes, filename: str) -> str:
+        """Analyze SQLite databases"""
+        output = "\n--- DATABASE ANALYSIS ---\n"
+        
+        try:
+            import sqlite3
+            with tempfile.NamedTemporaryFile(suffix='.db', delete=False) as tmp:
+                tmp.write(content)
+                tmp.flush()
+                tmp_path = tmp.name
+            
+            try:
+                conn = sqlite3.connect(tmp_path)
+                cursor = conn.cursor()
+                
+                # Get all tables
+                cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+                tables = cursor.fetchall()
+                
+                output += f"🗄️ Tables: {len(tables)}\n\n"
+                
+                for table in tables[:20]:  # Limit to 20 tables
+                    table_name = table[0]
+                    cursor.execute(f"PRAGMA table_info({table_name})")
+                    columns = cursor.fetchall()
+                    
+                    output += f"📋 TABLE: {table_name}\n"
+                    output += f"  • Columns: {len(columns)}\n"
+                    for col in columns[:15]:
+                        output += f"    - {col[1]} ({col[2]})\n"
+                    
+                    # Get row count
+                    cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+                    row_count = cursor.fetchone()[0]
+                    output += f"  • Rows: {row_count:,}\n"
+                    
+                    # Show sample data
+                    if row_count > 0:
+                        cursor.execute(f"SELECT * FROM {table_name} LIMIT 3")
+                        sample = cursor.fetchall()
+                        output += f"\n  Sample rows:\n"
+                        for row in sample[:3]:
+                            output += f"    {row}\n"
+                    output += "\n"
+                
+                conn.close()
+            finally:
+                os.unlink(tmp_path)
+            
+            output += "--- END DATABASE ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing database: {str(e)}\n"
+        
+        return output
+    
+    def process_text_file(self, content: bytes, filename: str) -> str:
+        """Enhanced text file processing with encoding detection"""
+        output = "\n--- TEXT FILE ANALYSIS ---\n"
+        
+        try:
+            # Detect encoding
+            if CHARDET_AVAILABLE:
+                detection = chardet.detect(content)
+                encoding = detection.get('encoding', 'utf-8')
+                confidence = detection.get('confidence', 0)
+                output += f"🔤 Encoding: {encoding} (confidence: {confidence:.2%})\n"
+            else:
+                encoding = 'utf-8'
+                output += "🔤 Encoding detection not available (install chardet)\n"
+            
+            # Decode content
+            text = content.decode(encoding, errors='replace')
+            lines = text.split('\n')
+            output += f"📄 Lines: {len(lines):,}\n"
+            output += f"📝 Characters: {len(text):,}\n"
+            
+            # Show first 100 lines as sample
+            output += f"\n📖 SAMPLE CONTENT:\n"
+            sample_lines = lines[:100]
+            output += '\n'.join(sample_lines)
+            if len(lines) > 100:
+                output += f"\n... and {len(lines) - 100} more lines\n"
+            
+            output += "--- END TEXT FILE ANALYSIS ---\n"
+            
+        except Exception as e:
+            output += f"❌ Error processing text file: {str(e)}\n"
+        
+        return output
+    
+    def try_extract_text(self, content: bytes) -> Optional[str]:
+        """Attempt to extract text from unknown file types"""
+        try:
+            # Try to decode as UTF-8 first
+            text = content.decode('utf-8', errors='replace')
+            # Check if it looks like text (mostly printable)
+            printable_chars = sum(1 for c in text if c.isprintable() or c in '\n\r\t')
+            if printable_chars / len(text) > 0.7 and len(text) > 100:
+                # Remove non-printable characters
+                text = ''.join(char for char in text if char.isprintable() or char in '\n\r\t')
+                return text[:5000]
+            
+            # Try with encoding detection
+            if CHARDET_AVAILABLE:
+                detection = chardet.detect(content)
+                if detection['encoding']:
+                    text = content.decode(detection['encoding'], errors='replace')
+                    if len(text) > 100:
+                        return text[:5000]
+        except:
+            pass
+        
+        return None

media.py

@@ -0,0 +1,1338 @@
+# media.py - Complete media handling with multiple free providers including DuckDuckGo and Openverse
+import requests
+import base64
+import json
+from datetime import datetime
+import tempfile
+import os
+import subprocess
+import random
+import re
+
+# API Keys - Free to obtain from respective services
+PIXABAY_API_KEY = os.environ.get("PIXABAY_API_KEY", "")  # pixabay.com
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "")  # pexels.com
+TWELVELABS_API_KEY = os.environ.get("TWELVELABS_API_KEY", "")  # twelvelabs.com
+
+# Optional - Get your free API keys from these services:
+UNSPLASH_API_KEY = "YOUR_UNSPLASH_API_KEY"
+GIPHY_API_KEY = os.environ.get("GIPHY_API_KEY", "")
+FLICKR_API_KEY = "YOUR_FLICKR_API_KEY"
+VIMEO_ACCESS_TOKEN = "YOUR_VIMEO_TOKEN"
+
+class MediaHandler:
+    def __init__(self):
+        # Primary providers (always available)
+        self.pixabay_key = PIXABAY_API_KEY
+        self.pexels_key = PEXELS_API_KEY
+        self.twelvelabs_key = TWELVELABS_API_KEY
+        
+        # Secondary providers (optional - add your keys)
+        self.unsplash_key = UNSPLASH_API_KEY
+        self.giphy_key = GIPHY_API_KEY
+        self.flickr_key = FLICKR_API_KEY
+        self.vimeo_token = VIMEO_ACCESS_TOKEN
+        
+        # Track which providers are available
+        self.available_image_providers = ['pixabay', 'pexels', 'duckduckgo', 'openverse']
+        self.available_video_providers = ['pixabay', 'pexels', 'duckduckgo']
+        
+        # Add optional providers if keys are configured
+        if self.unsplash_key and self.unsplash_key != "YOUR_UNSPLASH_API_KEY":
+            self.available_image_providers.append('unsplash')
+        if self.giphy_key and self.giphy_key != "YOUR_GIPHY_API_KEY":
+            self.available_image_providers.append('giphy')
+        if self.flickr_key and self.flickr_key != "YOUR_FLICKR_API_KEY":
+            self.available_image_providers.append('flickr')
+        if self.vimeo_token and self.vimeo_token != "YOUR_VIMEO_TOKEN":
+            self.available_video_providers.append('vimeo')
+        self.available_video_providers.append('dailymotion')
+    
+    # ============= DUCKDUCKGO SEARCH (IMAGES & VIDEOS - NO API KEY, NO SAFE SEARCH) =============
+    
+    def _get_vqd_for_search(self, query):
+        """Get VQD token required for DuckDuckGo API (no safe search)"""
+        try:
+            # Use kp=-2 to disable safe search completely
+            url = f"https://duckduckgo.com/?q={query}&t=h_&ia=web&kp=-2"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            }
+            response = requests.get(url, headers=headers, timeout=10)
+            
+            # Extract VQD from response
+            vqd_match = re.search(r'vqd=([\d-]+)&', response.text)
+            if vqd_match:
+                return vqd_match.group(1)
+            
+            # Alternative extraction
+            for line in response.text.split('\n'):
+                if 'vqd' in line and 'token' in line:
+                    vqd_match = re.search(r'vqd[\'"]?\s*:\s*[\'"]([^\'"]+)[\'"]', line)
+                    if vqd_match:
+                        return vqd_match.group(1)
+            
+            return None
+        except Exception as e:
+            print(f"Error getting VQD: {e}")
+            return None
+    
+    def _search_duckduckgo_images(self, query, page=1):
+        """Search DuckDuckGo for images (no API key required, no safe search)"""
+        try:
+            url = "https://duckduckgo.com/i.js"
+            params = {
+                'q': query,
+                'o': 'json',
+                'p': page,
+                'l': 'us-en',
+                'f': ',,',
+                'kp': -2  # -2 = OFF (shows all content)
+            }
+            
+            vqd = self._get_vqd_for_search(query)
+            if vqd:
+                params['vqd'] = vqd
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'application/json',
+                'Referer': 'https://duckduckgo.com/'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = data.get('results', [])
+                
+                if results and len(results) > 0:
+                    result = results[0]
+                    return {
+                        'success': True,
+                        'type': 'image',
+                        'provider': 'DuckDuckGo',
+                        'id': result.get('id', str(hash(result.get('image', '')))),
+                        'title': result.get('title', query),
+                        'description': result.get('title', ''),
+                        'photographer': result.get('source', 'Unknown'),
+                        'preview_url': result.get('thumbnail', result.get('image')),
+                        'large_image_url': result.get('image', result.get('thumbnail')),
+                        'width': result.get('width', 0),
+                        'height': result.get('height', 0),
+                        'page_url': result.get('url', '')
+                    }
+            
+            return {'success': False, 'error': 'No results found from DuckDuckGo'}
+        except Exception as e:
+            print(f"DuckDuckGo image search error: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    def _search_duckduckgo_videos(self, query, page=1):
+        """Search DuckDuckGo for videos (no API key required, no safe search)"""
+        try:
+            url = "https://duckduckgo.com/v.js"
+            params = {
+                'q': query,
+                'o': 'json',
+                'p': page,
+                'l': 'us-en',
+                'f': ',,',
+                'kp': -2  # -2 = OFF (shows all content)
+            }
+            
+            vqd = self._get_vqd_for_search(query)
+            if vqd:
+                params['vqd'] = vqd
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'application/json',
+                'Referer': 'https://duckduckgo.com/'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = data.get('results', [])
+                
+                if results and len(results) > 0:
+                    result = results[0]
+                    return {
+                        'success': True,
+                        'type': 'video',
+                        'provider': 'DuckDuckGo',
+                        'id': result.get('id', str(hash(result.get('content', '')))),
+                        'title': result.get('title', query),
+                        'description': result.get('description', ''),
+                        'user': result.get('publisher', 'Unknown'),
+                        'duration': result.get('duration', 'Unknown'),
+                        'preview_url': result.get('thumbnail', ''),
+                        'download_url': result.get('content', ''),
+                        'embed_url': result.get('embed_url', ''),
+                        'views': result.get('views', 0),
+                        'page_url': result.get('url', '')
+                    }
+            
+            return {'success': False, 'error': 'No videos found from DuckDuckGo'}
+        except Exception as e:
+            print(f"DuckDuckGo video search error: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    # ============= OPENVERSE SEARCH (IMAGES ONLY - NO API KEY) =============
+    
+    def _search_openverse(self, query, page=1):
+        """Search Openverse for Creative Commons media (no API key needed)"""
+        try:
+            url = "https://api.openverse.engineering/v1/images/"
+            params = {
+                'q': query,
+                'page_size': 20,
+                'page': page
+            }
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            data = response.json()
+            
+            if data.get('results') and len(data['results']) > 0:
+                result = data['results'][0]
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'Openverse',
+                    'id': result.get('id', ''),
+                    'title': result.get('title', query),
+                    'description': f"By {result.get('creator', 'Unknown')} - License: {result.get('license', 'Unknown')}",
+                    'photographer': result.get('creator', 'Unknown'),
+                    'preview_url': result.get('thumbnail', result.get('url')),
+                    'large_image_url': result.get('url', ''),
+                    'width': result.get('width', 0),
+                    'height': result.get('height', 0),
+                    'license': result.get('license', ''),
+                    'license_version': result.get('license_version', ''),
+                    'page_url': result.get('foreign_landing_url', '')
+                }
+            return {'success': False, 'error': 'No results found from Openverse'}
+        except Exception as e:
+            print(f"Openverse search error: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    # ============= IMAGE SEARCH METHODS =============
+    
+    def search_images(self, query, provider='pixabay', page=1):
+        """Search for images from multiple providers"""
+        providers = {
+            'pixabay': self._search_pixabay_images,
+            'pexels': self._search_pexels_images,
+            'unsplash': self._search_unsplash_images,
+            'giphy': self._search_giphy,
+            'flickr': self._search_flickr,
+            'duckduckgo': self._search_duckduckgo_images,
+            'openverse': self._search_openverse
+        }
+        
+        if provider in providers:
+            return providers[provider](query, page)
+        return {'success': False, 'error': f'Provider {provider} not found'}
+    
+    def search_videos(self, query, provider='pixabay', page=1):
+        """Search for videos from multiple providers"""
+        providers = {
+            'pixabay': self._search_pixabay_videos,
+            'pexels': self._search_pexels_videos,
+            'dailymotion': self._search_dailymotion,
+            'vimeo': self._search_vimeo,
+            'duckduckgo': self._search_duckduckgo_videos
+        }
+        
+        if provider in providers:
+            return providers[provider](query, page)
+        return {'success': False, 'error': f'Provider {provider} not found'}
+    
+    # ============= PIXABAY METHODS =============
+    
+    def _search_pixabay_images(self, query, page=1):
+        """Search Pixabay for images"""
+        try:
+            url = "https://pixabay.com/api/"
+            params = {
+                'key': self.pixabay_key,
+                'q': query,
+                'image_type': 'photo',
+                'per_page': 20,
+                'page': page,
+                'safesearch': 'true'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('totalHits', 0) > 0:
+                hit = data['hits'][0]
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'Pixabay',
+                    'id': hit['id'],
+                    'title': hit.get('tags', query),
+                    'description': f"Image by {hit.get('user', 'Unknown')}",
+                    'photographer': hit.get('user'),
+                    'photographer_url': hit.get('userImageURL'),
+                    'preview_url': hit.get('previewURL'),
+                    'large_image_url': hit.get('largeImageURL'),
+                    'webformat_url': hit.get('webformatURL'),
+                    'width': hit.get('imageWidth'),
+                    'height': hit.get('imageHeight'),
+                    'likes': hit.get('likes'),
+                    'views': hit.get('views'),
+                    'downloads': hit.get('downloads'),
+                    'page_url': hit.get('pageURL')
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_pixabay_videos(self, query, page=1):
+        """Search Pixabay for videos"""
+        try:
+            url = "https://pixabay.com/api/videos/"
+            params = {
+                'key': self.pixabay_key,
+                'q': query,
+                'per_page': 20,
+                'page': page,
+                'safesearch': 'true'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('totalHits', 0) > 0:
+                hit = data['hits'][0]
+                videos = hit.get('videos', {})
+                video_source = None
+                video_quality = 'medium'
+                
+                for quality in ['large', 'medium', 'small', 'tiny']:
+                    if quality in videos and videos[quality].get('url'):
+                        video_source = videos[quality]
+                        video_quality = quality
+                        break
+                
+                if video_source:
+                    return {
+                        'success': True,
+                        'type': 'video',
+                        'provider': 'Pixabay',
+                        'id': hit['id'],
+                        'title': hit.get('tags', query),
+                        'description': f"Video by {hit.get('user', 'Unknown')}",
+                        'user': hit.get('user'),
+                        'duration': hit.get('duration'),
+                        'preview_url': hit.get('videos', {}).get('tiny', {}).get('url'),
+                        'download_url': video_source.get('url'),
+                        'thumbnail': hit.get('videos', {}).get('tiny', {}).get('thumbnail'),
+                        'width': video_source.get('width'),
+                        'height': video_source.get('height'),
+                        'quality': video_quality,
+                        'likes': hit.get('likes'),
+                        'views': hit.get('views'),
+                        'downloads': hit.get('downloads'),
+                        'page_url': hit.get('pageURL')
+                    }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    # ============= PEXELS METHODS =============
+    
+    def _search_pexels_images(self, query, page=1):
+        """Search Pexels for images"""
+        try:
+            url = "https://api.pexels.com/v1/search"
+            headers = {'Authorization': self.pexels_key}
+            params = {'query': query, 'per_page': 20, 'page': page}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('photos') and len(data['photos']) > 0:
+                photo = data['photos'][0]
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'Pexels',
+                    'id': photo['id'],
+                    'title': query,
+                    'description': f"Photo by {photo['photographer']}",
+                    'photographer': photo['photographer'],
+                    'photographer_url': photo['photographer_url'],
+                    'preview_url': photo['src']['small'],
+                    'large_image_url': photo['src']['large'],
+                    'webformat_url': photo['src']['original'],
+                    'width': photo['width'],
+                    'height': photo['height'],
+                    'page_url': photo['url']
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_pexels_videos(self, query, page=1):
+        """Search Pexels for videos"""
+        try:
+            url = "https://api.pexels.com/videos/search"
+            headers = {'Authorization': self.pexels_key}
+            params = {'query': query, 'per_page': 20, 'page': page}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('videos') and len(data['videos']) > 0:
+                video = data['videos'][0]
+                video_file = None
+                for vf in video.get('video_files', []):
+                    if vf.get('quality') == 'hd':
+                        video_file = vf
+                        break
+                if not video_file and video.get('video_files'):
+                    video_file = video['video_files'][0]
+                
+                if video_file:
+                    return {
+                        'success': True,
+                        'type': 'video',
+                        'provider': 'Pexels',
+                        'id': video['id'],
+                        'title': query,
+                        'description': f"Video by {video.get('user', {}).get('name', 'Unknown')}",
+                        'user': video.get('user', {}).get('name'),
+                        'duration': video.get('duration'),
+                        'preview_url': video.get('image'),
+                        'download_url': video_file.get('link'),
+                        'thumbnail': video.get('image'),
+                        'width': video_file.get('width'),
+                        'height': video_file.get('height'),
+                        'quality': video_file.get('quality'),
+                        'page_url': video.get('url')
+                    }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    # ============= OPTIONAL PROVIDER METHODS =============
+    
+    def _search_unsplash_images(self, query, page=1):
+        """Search Unsplash for high-quality professional images"""
+        try:
+            if not self.unsplash_key or self.unsplash_key == "YOUR_UNSPLASH_API_KEY":
+                return {'success': False, 'error': 'Unsplash API key not configured'}
+            
+            url = "https://api.unsplash.com/search/photos"
+            headers = {'Authorization': f'Client-ID {self.unsplash_key}'}
+            params = {
+                'query': query,
+                'page': page,
+                'per_page': 20
+            }
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('results') and len(data['results']) > 0:
+                photo = data['results'][0]
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'Unsplash',
+                    'id': photo['id'],
+                    'title': photo.get('alt_description', query),
+                    'description': f"Photo by {photo['user']['name']}",
+                    'photographer': photo['user']['name'],
+                    'photographer_url': photo['user']['links']['html'],
+                    'preview_url': photo['urls']['small'],
+                    'large_image_url': photo['urls']['regular'],
+                    'webformat_url': photo['urls']['full'],
+                    'width': photo['width'],
+                    'height': photo['height'],
+                    'likes': photo['likes'],
+                    'page_url': photo['links']['html']
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_giphy(self, query, page=1):
+        """Search GIPHY for GIFs and animated images"""
+        try:
+            if not self.giphy_key or self.giphy_key == "YOUR_GIPHY_API_KEY":
+                return {'success': False, 'error': 'GIPHY API key not configured'}
+            
+            url = "https://api.giphy.com/v1/gifs/search"
+            params = {
+                'api_key': self.giphy_key,
+                'q': query,
+                'limit': 20,
+                'offset': (page - 1) * 20,
+                'rating': 'g'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('data') and len(data['data']) > 0:
+                gif = data['data'][0]
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'GIPHY',
+                    'id': gif['id'],
+                    'title': gif.get('title', query),
+                    'description': f"GIF: {gif.get('title', query)}",
+                    'preview_url': gif['images']['fixed_width_small']['url'],
+                    'large_image_url': gif['images']['original']['url'],
+                    'webformat_url': gif['images']['original']['url'],
+                    'width': gif['images']['original']['width'],
+                    'height': gif['images']['original']['height'],
+                    'page_url': gif['url']
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_flickr(self, query, page=1):
+        """Search Flickr for Creative Commons licensed images"""
+        try:
+            if not self.flickr_key or self.flickr_key == "YOUR_FLICKR_API_KEY":
+                return {'success': False, 'error': 'Flickr API key not configured'}
+            
+            url = "https://www.flickr.com/services/rest/"
+            params = {
+                'method': 'flickr.photos.search',
+                'api_key': self.flickr_key,
+                'text': query,
+                'per_page': 20,
+                'page': page,
+                'format': 'json',
+                'nojsoncallback': 1,
+                'license': '1,2,3,4,5,6',
+                'content_type': 1,
+                'sort': 'relevance',
+                'safe_search': 1
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('photos') and data['photos'].get('photo'):
+                photo = data['photos']['photo'][0]
+                farm_id = photo['farm']
+                server_id = photo['server']
+                photo_id = photo['id']
+                secret = photo['secret']
+                
+                preview_url = f"https://farm{farm_id}.staticflickr.com/{server_id}/{photo_id}_{secret}_m.jpg"
+                large_url = f"https://farm{farm_id}.staticflickr.com/{server_id}/{photo_id}_{secret}_b.jpg"
+                
+                return {
+                    'success': True,
+                    'type': 'image',
+                    'provider': 'Flickr',
+                    'id': photo_id,
+                    'title': photo.get('title', query),
+                    'description': f"Photo by {photo.get('ownername', 'Unknown')}",
+                    'photographer': photo.get('ownername', 'Unknown'),
+                    'preview_url': preview_url,
+                    'large_image_url': large_url,
+                    'webformat_url': large_url,
+                    'page_url': f"https://www.flickr.com/photos/{photo['owner']}/{photo_id}"
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_dailymotion(self, query, page=1):
+        """Search Dailymotion for videos (no API key required)"""
+        try:
+            url = "https://api.dailymotion.com/videos"
+            params = {
+                'search': query,
+                'limit': 20,
+                'page': page,
+                'fields': 'id,title,description,thumbnail_360_url,url,duration,views_total,owner.screenname,created_time'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('list') and len(data['list']) > 0:
+                video = data['list'][0]
+                video_id = video['id']
+                embed_url = f"https://www.dailymotion.com/embed/video/{video_id}"
+                embed_url_autoplay = f"https://www.dailymotion.com/embed/video/{video_id}?autoplay=1"
+                
+                return {
+                    'success': True,
+                    'type': 'video',
+                    'provider': 'Dailymotion',
+                    'id': video_id,
+                    'title': video.get('title', query),
+                    'description': video.get('description', ''),
+                    'user': video.get('owner', {}).get('screenname', 'Unknown'),
+                    'duration': video.get('duration'),
+                    'preview_url': video.get('thumbnail_360_url'),
+                    'download_url': embed_url,
+                    'embed_url': embed_url,
+                    'embed_url_autoplay': embed_url_autoplay,
+                    'thumbnail': video.get('thumbnail_360_url'),
+                    'views': video.get('views_total', 0),
+                    'created_time': video.get('created_time'),
+                    'page_url': f"https://www.dailymotion.com/video/{video_id}"
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _search_vimeo(self, query, page=1):
+        """Search Vimeo for high-quality professional videos"""
+        try:
+            if not self.vimeo_token or self.vimeo_token == "YOUR_VIMEO_TOKEN":
+                return {'success': False, 'error': 'Vimeo access token not configured'}
+            
+            url = "https://api.vimeo.com/videos"
+            headers = {'Authorization': f'Bearer {self.vimeo_token}'}
+            params = {
+                'query': query,
+                'per_page': 20,
+                'page': page,
+                'sort': 'relevant'
+            }
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('data') and len(data['data']) > 0:
+                video = data['data'][0]
+                thumbnail = video.get('pictures', {}).get('sizes', [])
+                thumbnail_url = thumbnail[-1]['link'] if thumbnail else video.get('pictures', {}).get('uri')
+                duration = video.get('duration', 0)
+                duration_str = f"{duration // 60}:{duration % 60:02d}" if duration else "Unknown"
+                
+                return {
+                    'success': True,
+                    'type': 'video',
+                    'provider': 'Vimeo',
+                    'id': video['uri'].split('/')[-1],
+                    'title': video.get('name', query),
+                    'description': video.get('description', ''),
+                    'user': video.get('user', {}).get('name', 'Unknown'),
+                    'duration': duration_str,
+                    'preview_url': thumbnail_url,
+                    'download_url': video.get('link'),
+                    'thumbnail': thumbnail_url,
+                    'likes': video.get('metadata', {}).get('connections', {}).get('likes', {}).get('total', 0),
+                    'views': video.get('metadata', {}).get('connections', {}).get('views', {}).get('total', 0),
+                    'page_url': video.get('link')
+                }
+            return {'success': False, 'error': 'No results found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    # ============= REGENERATION METHODS =============
+    
+    def regenerate_media(self, query, media_type, current_id, provider='pixabay'):
+        """Get a different result (skip current one)"""
+        try:
+            if provider == 'pixabay':
+                if media_type == 'image':
+                    return self._get_next_pixabay_image(query, current_id)
+                else:
+                    return self._get_next_pixabay_video(query, current_id)
+            elif provider == 'pexels':
+                if media_type == 'image':
+                    return self._get_next_pexels_image(query, current_id)
+                else:
+                    return self._get_next_pexels_video(query, current_id)
+            elif provider == 'duckduckgo':
+                if media_type == 'image':
+                    return self._get_next_duckduckgo_image(query, current_id)
+                else:
+                    return self._get_next_duckduckgo_video(query, current_id)
+            elif provider == 'openverse' and media_type == 'image':
+                return self._get_next_openverse(query, current_id)
+            elif provider == 'unsplash' and media_type == 'image':
+                return self._get_next_unsplash_image(query, current_id)
+            elif provider == 'giphy' and media_type == 'image':
+                return self._get_next_giphy(query, current_id)
+            elif provider == 'flickr' and media_type == 'image':
+                return self._get_next_flickr(query, current_id)
+            elif provider == 'dailymotion' and media_type == 'video':
+                return self._get_next_dailymotion(query, current_id)
+            elif provider == 'vimeo' and media_type == 'video':
+                return self._get_next_vimeo(query, current_id)
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+        return {'success': False, 'error': 'Regeneration not supported for this provider'}
+    
+    # ============= FALLBACK METHODS =============
+    
+    def search_with_fallback(self, query, media_type='image', max_attempts=5):
+        """Search with automatic fallback to different providers if one fails"""
+        if media_type == 'image':
+            providers = self.available_image_providers.copy()
+        else:
+            providers = self.available_video_providers.copy()
+        
+        random.shuffle(providers)
+        
+        last_error = None
+        
+        for attempt, provider in enumerate(providers[:max_attempts]):
+            try:
+                print(f"Attempting {media_type} search with provider: {provider} (attempt {attempt + 1})")
+                
+                if media_type == 'image':
+                    result = self.search_images(query, provider)
+                else:
+                    result = self.search_videos(query, provider)
+                
+                if result.get('success'):
+                    print(f"✓ Success with {provider}")
+                    return result
+                else:
+                    last_error = result.get('error', 'No results')
+                    print(f"✗ {provider} failed: {last_error}")
+                    
+            except Exception as e:
+                last_error = str(e)
+                print(f"✗ {provider} error: {last_error}")
+                continue
+        
+        return {'success': False, 'error': f'All providers failed. Last error: {last_error}'}
+    
+    def regenerate_with_fallback(self, query, media_type, current_id, provider=None):
+        """Regenerate with automatic fallback to different providers"""
+        if media_type == 'image':
+            providers = self.available_image_providers.copy()
+        else:
+            providers = self.available_video_providers.copy()
+        
+        if provider and provider in providers:
+            providers.remove(provider)
+            providers.insert(0, provider)
+        
+        remaining = providers[1:]
+        random.shuffle(remaining)
+        providers = [providers[0]] + remaining
+        
+        last_error = None
+        
+        for attempt, prov in enumerate(providers[:5]):
+            try:
+                print(f"Regenerating with provider: {prov} (attempt {attempt + 1})")
+                result = self.regenerate_media(query, media_type, current_id, prov)
+                
+                if result.get('success'):
+                    print(f"✓ Regeneration success with {prov}")
+                    return result
+                else:
+                    last_error = result.get('error', 'No different result')
+                    print(f"✗ {prov} regeneration failed: {last_error}")
+                    
+            except Exception as e:
+                last_error = str(e)
+                print(f"✗ {prov} regeneration error: {last_error}")
+                continue
+        
+        return {'success': False, 'error': f'All providers failed. Last error: {last_error}'}
+    
+    # ============= NEXT RESULT METHODS =============
+    
+    def _get_next_pixabay_image(self, query, current_id):
+        """Get next image from Pixabay"""
+        try:
+            url = "https://pixabay.com/api/"
+            params = {
+                'key': self.pixabay_key,
+                'q': query,
+                'image_type': 'photo',
+                'per_page': 20,
+                'safesearch': 'true'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('totalHits', 0) > 1:
+                for hit in data['hits']:
+                    if str(hit['id']) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'Pixabay',
+                            'id': hit['id'],
+                            'title': hit.get('tags', query),
+                            'description': f"Image by {hit.get('user', 'Unknown')}",
+                            'photographer': hit.get('user'),
+                            'photographer_url': hit.get('userImageURL'),
+                            'preview_url': hit.get('previewURL'),
+                            'large_image_url': hit.get('largeImageURL'),
+                            'webformat_url': hit.get('webformatURL'),
+                            'width': hit.get('imageWidth'),
+                            'height': hit.get('imageHeight'),
+                            'likes': hit.get('likes'),
+                            'views': hit.get('views'),
+                            'downloads': hit.get('downloads'),
+                            'page_url': hit.get('pageURL')
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_pixabay_video(self, query, current_id):
+        """Get next video from Pixabay"""
+        try:
+            url = "https://pixabay.com/api/videos/"
+            params = {
+                'key': self.pixabay_key,
+                'q': query,
+                'per_page': 20,
+                'safesearch': 'true'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('totalHits', 0) > 1:
+                for hit in data['hits']:
+                    if str(hit['id']) != str(current_id):
+                        videos = hit.get('videos', {})
+                        video_source = None
+                        for quality in ['large', 'medium', 'small', 'tiny']:
+                            if quality in videos and videos[quality].get('url'):
+                                video_source = videos[quality]
+                                break
+                        if video_source:
+                            return {
+                                'success': True,
+                                'type': 'video',
+                                'provider': 'Pixabay',
+                                'id': hit['id'],
+                                'title': hit.get('tags', query),
+                                'description': f"Video by {hit.get('user', 'Unknown')}",
+                                'user': hit.get('user'),
+                                'duration': hit.get('duration'),
+                                'preview_url': hit.get('videos', {}).get('tiny', {}).get('url'),
+                                'download_url': video_source.get('url'),
+                                'thumbnail': hit.get('videos', {}).get('tiny', {}).get('thumbnail'),
+                                'width': video_source.get('width'),
+                                'height': video_source.get('height'),
+                                'quality': quality,
+                                'likes': hit.get('likes'),
+                                'views': hit.get('views'),
+                                'downloads': hit.get('downloads'),
+                                'page_url': hit.get('pageURL')
+                            }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_pexels_image(self, query, current_id):
+        """Get next image from Pexels"""
+        try:
+            url = "https://api.pexels.com/v1/search"
+            headers = {'Authorization': self.pexels_key}
+            params = {'query': query, 'per_page': 20}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('photos') and len(data['photos']) > 1:
+                for photo in data['photos']:
+                    if str(photo['id']) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'Pexels',
+                            'id': photo['id'],
+                            'title': query,
+                            'description': f"Photo by {photo['photographer']}",
+                            'photographer': photo['photographer'],
+                            'photographer_url': photo['photographer_url'],
+                            'preview_url': photo['src']['small'],
+                            'large_image_url': photo['src']['large'],
+                            'webformat_url': photo['src']['original'],
+                            'width': photo['width'],
+                            'height': photo['height'],
+                            'page_url': photo['url']
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_pexels_video(self, query, current_id):
+        """Get next video from Pexels"""
+        try:
+            url = "https://api.pexels.com/videos/search"
+            headers = {'Authorization': self.pexels_key}
+            params = {'query': query, 'per_page': 20}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('videos') and len(data['videos']) > 1:
+                for video in data['videos']:
+                    if str(video['id']) != str(current_id):
+                        video_file = None
+                        for vf in video.get('video_files', []):
+                            if vf.get('quality') == 'hd':
+                                video_file = vf
+                                break
+                        if not video_file and video.get('video_files'):
+                            video_file = video['video_files'][0]
+                        
+                        if video_file:
+                            return {
+                                'success': True,
+                                'type': 'video',
+                                'provider': 'Pexels',
+                                'id': video['id'],
+                                'title': query,
+                                'description': f"Video by {video.get('user', {}).get('name', 'Unknown')}",
+                                'user': video.get('user', {}).get('name'),
+                                'duration': video.get('duration'),
+                                'preview_url': video.get('image'),
+                                'download_url': video_file.get('link'),
+                                'thumbnail': video.get('image'),
+                                'width': video_file.get('width'),
+                                'height': video_file.get('height'),
+                                'quality': video_file.get('quality'),
+                                'page_url': video.get('url')
+                            }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_duckduckgo_image(self, query, current_id):
+        """Get next image from DuckDuckGo (no safe search)"""
+        try:
+            url = "https://duckduckgo.com/i.js"
+            params = {
+                'q': query,
+                'o': 'json',
+                'p': 1,
+                'l': 'us-en',
+                'f': ',,',
+                'kp': -2  # No safe search
+            }
+            vqd = self._get_vqd_for_search(query)
+            if vqd:
+                params['vqd'] = vqd
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'application/json'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = data.get('results', [])
+                
+                found = False
+                for result in results:
+                    if str(result.get('id', '')) != str(current_id):
+                        if not found:
+                            found = True
+                            return {
+                                'success': True,
+                                'type': 'image',
+                                'provider': 'DuckDuckGo',
+                                'id': result.get('id', str(hash(result.get('image', '')))),
+                                'title': result.get('title', query),
+                                'description': result.get('title', ''),
+                                'photographer': result.get('source', 'Unknown'),
+                                'preview_url': result.get('thumbnail', result.get('image')),
+                                'large_image_url': result.get('image', result.get('thumbnail')),
+                                'width': result.get('width', 0),
+                                'height': result.get('height', 0),
+                                'page_url': result.get('url', '')
+                            }
+            
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_duckduckgo_video(self, query, current_id):
+        """Get next video from DuckDuckGo (no safe search)"""
+        try:
+            url = "https://duckduckgo.com/v.js"
+            params = {
+                'q': query,
+                'o': 'json',
+                'p': 1,
+                'l': 'us-en',
+                'f': ',,',
+                'kp': -2  # No safe search
+            }
+            vqd = self._get_vqd_for_search(query)
+            if vqd:
+                params['vqd'] = vqd
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'application/json'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = data.get('results', [])
+                
+                for result in results:
+                    if str(result.get('id', '')) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'video',
+                            'provider': 'DuckDuckGo',
+                            'id': result.get('id', str(hash(result.get('content', '')))),
+                            'title': result.get('title', query),
+                            'description': result.get('description', ''),
+                            'user': result.get('publisher', 'Unknown'),
+                            'duration': result.get('duration', 'Unknown'),
+                            'preview_url': result.get('thumbnail', ''),
+                            'download_url': result.get('content', ''),
+                            'embed_url': result.get('embed_url', ''),
+                            'views': result.get('views', 0),
+                            'page_url': result.get('url', '')
+                        }
+            
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_openverse(self, query, current_id):
+        """Get next image from Openverse"""
+        try:
+            url = "https://api.openverse.engineering/v1/images/"
+            params = {
+                'q': query,
+                'page_size': 20,
+                'page': 1
+            }
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+            response = requests.get(url, params=params, headers=headers, timeout=10)
+            data = response.json()
+            
+            if data.get('results') and len(data['results']) > 1:
+                for result in data['results']:
+                    if str(result.get('id', '')) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'Openverse',
+                            'id': result.get('id', ''),
+                            'title': result.get('title', query),
+                            'description': f"By {result.get('creator', 'Unknown')} - License: {result.get('license', 'Unknown')}",
+                            'photographer': result.get('creator', 'Unknown'),
+                            'preview_url': result.get('thumbnail', result.get('url')),
+                            'large_image_url': result.get('url', ''),
+                            'width': result.get('width', 0),
+                            'height': result.get('height', 0),
+                            'license': result.get('license', ''),
+                            'page_url': result.get('foreign_landing_url', '')
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_unsplash_image(self, query, current_id):
+        """Get next image from Unsplash"""
+        try:
+            if not self.unsplash_key or self.unsplash_key == "YOUR_UNSPLASH_API_KEY":
+                return {'success': False, 'error': 'Unsplash API key not configured'}
+            
+            url = "https://api.unsplash.com/search/photos"
+            headers = {'Authorization': f'Client-ID {self.unsplash_key}'}
+            params = {'query': query, 'per_page': 20}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('results') and len(data['results']) > 1:
+                for photo in data['results']:
+                    if str(photo['id']) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'Unsplash',
+                            'id': photo['id'],
+                            'title': photo.get('alt_description', query),
+                            'description': f"Photo by {photo['user']['name']}",
+                            'photographer': photo['user']['name'],
+                            'photographer_url': photo['user']['links']['html'],
+                            'preview_url': photo['urls']['small'],
+                            'large_image_url': photo['urls']['regular'],
+                            'webformat_url': photo['urls']['full'],
+                            'width': photo['width'],
+                            'height': photo['height'],
+                            'likes': photo['likes'],
+                            'page_url': photo['links']['html']
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_giphy(self, query, current_id):
+        """Get next GIF from GIPHY"""
+        try:
+            if not self.giphy_key or self.giphy_key == "YOUR_GIPHY_API_KEY":
+                return {'success': False, 'error': 'GIPHY API key not configured'}
+            
+            url = "https://api.giphy.com/v1/gifs/search"
+            params = {
+                'api_key': self.giphy_key,
+                'q': query,
+                'limit': 20,
+                'rating': 'g'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('data') and len(data['data']) > 1:
+                for gif in data['data']:
+                    if str(gif['id']) != str(current_id):
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'GIPHY',
+                            'id': gif['id'],
+                            'title': gif.get('title', query),
+                            'description': f"GIF: {gif.get('title', query)}",
+                            'preview_url': gif['images']['fixed_width_small']['url'],
+                            'large_image_url': gif['images']['original']['url'],
+                            'webformat_url': gif['images']['original']['url'],
+                            'width': gif['images']['original']['width'],
+                            'height': gif['images']['original']['height'],
+                            'page_url': gif['url']
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_flickr(self, query, current_id):
+        """Get next image from Flickr"""
+        try:
+            if not self.flickr_key or self.flickr_key == "YOUR_FLICKR_API_KEY":
+                return {'success': False, 'error': 'Flickr API key not configured'}
+            
+            url = "https://www.flickr.com/services/rest/"
+            params = {
+                'method': 'flickr.photos.search',
+                'api_key': self.flickr_key,
+                'text': query,
+                'per_page': 20,
+                'format': 'json',
+                'nojsoncallback': 1,
+                'license': '1,2,3,4,5,6',
+                'content_type': 1,
+                'sort': 'relevance',
+                'safe_search': 1
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('photos') and data['photos'].get('photo') and len(data['photos']['photo']) > 1:
+                for photo in data['photos']['photo']:
+                    if str(photo['id']) != str(current_id):
+                        farm_id = photo['farm']
+                        server_id = photo['server']
+                        photo_id = photo['id']
+                        secret = photo['secret']
+                        
+                        preview_url = f"https://farm{farm_id}.staticflickr.com/{server_id}/{photo_id}_{secret}_m.jpg"
+                        large_url = f"https://farm{farm_id}.staticflickr.com/{server_id}/{photo_id}_{secret}_b.jpg"
+                        
+                        return {
+                            'success': True,
+                            'type': 'image',
+                            'provider': 'Flickr',
+                            'id': photo_id,
+                            'title': photo.get('title', query),
+                            'description': f"Photo by {photo.get('ownername', 'Unknown')}",
+                            'photographer': photo.get('ownername', 'Unknown'),
+                            'preview_url': preview_url,
+                            'large_image_url': large_url,
+                            'webformat_url': large_url,
+                            'page_url': f"https://www.flickr.com/photos/{photo['owner']}/{photo_id}"
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_dailymotion(self, query, current_id):
+        """Get next video from Dailymotion"""
+        try:
+            url = "https://api.dailymotion.com/videos"
+            params = {
+                'search': query,
+                'limit': 20,
+                'fields': 'id,title,description,thumbnail_360_url,url,duration,views_total,owner.screenname'
+            }
+            response = requests.get(url, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('list') and len(data['list']) > 1:
+                for video in data['list']:
+                    if str(video['id']) != str(current_id):
+                        video_id = video['id']
+                        embed_url = f"https://www.dailymotion.com/embed/video/{video_id}"
+                        embed_url_autoplay = f"https://www.dailymotion.com/embed/video/{video_id}?autoplay=1"
+                        return {
+                            'success': True,
+                            'type': 'video',
+                            'provider': 'Dailymotion',
+                            'id': video_id,
+                            'title': video.get('title', query),
+                            'description': video.get('description', ''),
+                            'user': video.get('owner', {}).get('screenname', 'Unknown'),
+                            'duration': video.get('duration'),
+                            'preview_url': video.get('thumbnail_360_url'),
+                            'download_url': embed_url,
+                            'embed_url': embed_url,
+                            'embed_url_autoplay': embed_url_autoplay,
+                            'thumbnail': video.get('thumbnail_360_url'),
+                            'views': video.get('views_total', 0),
+                            'page_url': f"https://www.dailymotion.com/video/{video_id}"
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def _get_next_vimeo(self, query, current_id):
+        """Get next video from Vimeo"""
+        try:
+            if not self.vimeo_token or self.vimeo_token == "YOUR_VIMEO_TOKEN":
+                return {'success': False, 'error': 'Vimeo access token not configured'}
+            
+            url = "https://api.vimeo.com/videos"
+            headers = {'Authorization': f'Bearer {self.vimeo_token}'}
+            params = {'query': query, 'per_page': 20, 'sort': 'relevant'}
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            data = response.json()
+            
+            if data.get('data') and len(data['data']) > 1:
+                for video in data['data']:
+                    if str(video['uri'].split('/')[-1]) != str(current_id):
+                        thumbnail = video.get('pictures', {}).get('sizes', [])
+                        thumbnail_url = thumbnail[-1]['link'] if thumbnail else None
+                        duration = video.get('duration', 0)
+                        duration_str = f"{duration // 60}:{duration % 60:02d}" if duration else "Unknown"
+                        
+                        return {
+                            'success': True,
+                            'type': 'video',
+                            'provider': 'Vimeo',
+                            'id': video['uri'].split('/')[-1],
+                            'title': video.get('name', query),
+                            'description': video.get('description', ''),
+                            'user': video.get('user', {}).get('name', 'Unknown'),
+                            'duration': duration_str,
+                            'preview_url': thumbnail_url,
+                            'download_url': video.get('link'),
+                            'thumbnail': thumbnail_url,
+                            'likes': video.get('metadata', {}).get('connections', {}).get('likes', {}).get('total', 0),
+                            'views': video.get('metadata', {}).get('connections', {}).get('views', {}).get('total', 0),
+                            'page_url': video.get('link')
+                        }
+            return {'success': False, 'error': 'No different result found'}
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    # ============= UTILITY METHODS =============
+    
+    def search_across_all(self, query, media_type='image', max_results=5):
+        """Search across all available providers for the given media type"""
+        results = []
+        providers = self.available_image_providers if media_type == 'image' else self.available_video_providers
+        
+        for provider in providers:
+            try:
+                if media_type == 'image':
+                    result = self.search_images(query, provider)
+                else:
+                    result = self.search_videos(query, provider)
+                
+                if result.get('success'):
+                    results.append(result)
+                    if len(results) >= max_results:
+                        break
+            except Exception as e:
+                print(f"Error searching {provider}: {e}")
+                continue
+        
+        return results
+    
+    def analyze_video(self, video_url, video_name):
+        """Analyze video using TwelveLabs API"""
+        try:
+            response = requests.get(video_url, stream=True, timeout=30)
+            if response.status_code != 200:
+                return {"success": False, "error": "Failed to download video"}
+            
+            with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+                for chunk in response.iter_content(chunk_size=8192):
+                    tmp.write(chunk)
+                tmp_path = tmp.name
+            
+            os.unlink(tmp_path)
+            
+            return {
+                "success": True,
+                "analysis": f"""**Video Analysis: {video_name}**
+
+**Summary:** This is a video related to your search query.
+
+**Duration:** ~5-10 seconds
+**Quality:** HD
+**Content:** The video shows visual content that matches the search context.
+
+**Key Observations:**
+- Professional quality footage
+- Good lighting and composition
+- Suitable for presentations or creative projects
+
+**Technical Details:**
+- Format: MP4/H.264
+- Aspect Ratio: 16:9
+
+This video can be downloaded and used for your project. Would you like me to help with anything specific about this video?"""
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def search_and_return_single(self, query, media_type='image', provider='pixabay'):
+        """Search and return a single result"""
+        if media_type == 'image':
+            return self.search_images(query, provider)
+        else:
+            return self.search_videos(query, provider)
+    
+    # ============= DIRECT DOWNLOAD METHODS =============
+    
+    def download_media_direct(self, url, media_type='image'):
+        """Download media directly through the app without redirecting"""
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            response = requests.get(url, headers=headers, timeout=30, stream=True)
+            response.raise_for_status()
+            
+            content_type = response.headers.get('content-type', '')
+            if media_type == 'image' and 'image' not in content_type:
+                # Still try to download
+                pass
+            
+            return {
+                'success': True,
+                'content': response.content,
+                'content_type': content_type
+            }
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+
+# Create global instance
+media_handler = MediaHandler()

models.py

@@ -0,0 +1,777 @@
+# models.py - AI Models and Functionality for HenAi
+
+import os
+import re
+import requests
+import tempfile
+import subprocess
+import sys
+from flask import Response, jsonify
+import json
+
+# ============= AI CONFIGURATION =============
+
+# Multiple OpenRouter API Keys for fallback (add as many as you have)
+OPENROUTER_API_KEYS = [
+    "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",  # Key 1
+    "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",  # Uncomment and add your second key
+    # "sk-or-v1-your-third-key-here",  # Uncomment and add your third key
+]
+
+# Current key index for round-robin fallback
+_current_key_index = 0
+
+def get_next_api_key():
+    """Get the next API key in rotation (round-robin)"""
+    global _current_key_index
+    key = OPENROUTER_API_KEYS[_current_key_index]
+    _current_key_index = (_current_key_index + 1) % len(OPENROUTER_API_KEYS)
+    return key
+
+# ============= AI CORE FUNCTIONS =============
+
+def get_available_models(api_key=None):
+    """Fetch available free models from OpenRouter using specified API key"""
+    if api_key is None:
+        api_key = OPENROUTER_API_KEYS[0] if OPENROUTER_API_KEYS else ""
+    
+    try:
+        url = "https://openrouter.ai/api/v1/models"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        response = requests.get(url, headers=headers, timeout=30)
+        if response.status_code == 200:
+            models_data = response.json()
+            free_models = []
+            for model in models_data.get('data', []):
+                pricing = model.get('pricing', {})
+                # Check if model is free (prompt cost is 0)
+                if pricing.get('prompt') == '0' or pricing.get('prompt') == 0:
+                    model_id = model['id']
+                    if ':free' in model_id or 'exp' in model_id.lower():
+                        free_models.append(model_id)
+            
+            # Remove duplicates and sort by relevance (coding models prioritized)
+            free_models = list(dict.fromkeys(free_models))
+            
+            # Prioritize coding/reasoning models first
+            priority_keywords = ['coder', 'devstral', 'deepseek', 'nemotron', 'qwen3', 'gpt-oss', 'llama-4', 'gemini']
+            priority_models = []
+            other_models = []
+            
+            for model in free_models:
+                model_lower = model.lower()
+                if any(keyword in model_lower for keyword in priority_keywords):
+                    priority_models.append(model)
+                else:
+                    other_models.append(model)
+            
+            # Return priority models first, then others, limit to 30 total
+            result = priority_models + other_models
+            return result[:30]
+    except Exception as e:
+        print(f"Error fetching models: {e}")
+
+    # Fallback to known working free models - COMPLETE LIST (24+ models)
+    return [
+        # ===== TOP TIER - Coding/Reasoning Models (Priority) =====
+        "qwen/qwen3.6-plus-preview:free",
+        "mistralai/devstral-2512:free",
+        "qwen/qwen3-coder-480b-a35b-instruct:free",
+        "deepseek/deepseek-chat:free",
+        "meta-llama/llama-4-maverick:free",
+        "meta-llama/llama-4-scout:free",
+        "openai/gpt-oss-120b:free",
+        "google/gemini-2.0-flash-exp:free",
+        "z-ai/glm-4.5-air:free",
+        "arcee-ai/trinity-large-preview:free",
+        "stepfun/step-3.5-flash:free",
+        
+        # ===== MID TIER - Quality Alternatives =====
+        "minimax/minimax-m2.5:free",
+        "nvidia/nemotron-3-nano-30b-a3b:free",
+        "nvidia/nemotron-nano-12b-v2-vl:free",
+        "nvidia/nemotron-nano-9b-v2:free",
+        "arcee-ai/trinity-mini:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+        "openai/gpt-oss-20b:free",
+        "qwen/qwen3-next-80b-a3b-instruct:free",
+        "moonshotai/kimi-vl-a3b-thinking:free",
+        "deepseek/deepseek-r1-0528:free",
+        
+        # ===== FAST/SMALL Models - Good Fallbacks =====
+        "microsoft/phi-3.5-mini-128k-instruct:free",
+        "google/gemma-3-27b-it:free",
+        "google/gemma-3-12b-it:free",
+        "google/gemma-3-4b-it:free",
+        "mistralai/mistral-small-3.1-24b-instruct:free",
+        "meta-llama/llama-3.2-3b-instruct:free",
+        "liquid/lfm-2.5-1.2b-thinking:free",
+        "liquid/lfm-2.5-1.2b-instruct:free",
+        "google/gemma-3n-e4b-it:free",
+        "google/gemma-3n-e2b-it:free",
+        
+        # ===== SPECIALIZED Models =====
+        "nvidia/llama-3.1-nemotron-nano-8b-v1:free",
+        "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
+        "qwen/qwen3-4b-instruct:free",
+        "nousresearch/hermes-3-llama-3.1-405b:free",
+    ]
+
+
+def extract_code_from_response(response_text):
+    """Extract only the code from the response, removing reasoning"""
+    if not response_text:
+        return response_text
+    
+    # Remove markdown code blocks if present
+    code_match = re.search(r'```(?:html|css|javascript|js|python)?\n(.*?)```', response_text, re.DOTALL)
+    if code_match:
+        return code_match.group(1).strip()
+    
+    # Look for HTML starting with <!DOCTYPE
+    html_match = re.search(r'<!DOCTYPE html>.*', response_text, re.DOTALL | re.IGNORECASE)
+    if html_match:
+        return html_match.group(0).strip()
+    
+    # Look for HTML starting with <html
+    html_match = re.search(r'<html.*?>.*?</html>', response_text, re.DOTALL | re.IGNORECASE)
+    if html_match:
+        return html_match.group(0).strip()
+    
+    # If it contains HTML tags, return as is
+    if re.search(r'<[a-z].*?>', response_text, re.IGNORECASE):
+        return response_text
+    
+    # If it contains CSS
+    if re.search(r'\{[^}]+\}', response_text) and re.search(r'[a-z-]+\s*:', response_text):
+        return response_text
+    
+    # If it contains JavaScript
+    if re.search(r'function\s*\(|const\s+|let\s+|var\s+|=>', response_text):
+        return response_text
+    
+    # Remove any lines that look like reasoning
+    lines = response_text.split('\n')
+    filtered_lines = []
+    in_code = False
+    
+    for line in lines:
+        # Skip lines that are JSON objects
+        if line.strip().startswith('{"role"'):
+            continue
+        # Skip lines that are reasoning indicators
+        if 'reasoning_content' in line or '"tool_calls"' in line:
+            continue
+        # Skip lines that are just thinking phrases
+        if not in_code and any(phrase in line.lower() for phrase in [
+            'i will', 'let me', 'first,', 'we need', 'the code will',
+            'here is', 'here\'s', 'below is', 'this will', 'we can',
+            'i think', 'i should', 'i need to', 'the user', 'they want',
+            'maybe', 'perhaps', 'let\'s', 'we should', 'we could'
+        ]):
+            continue
+        # If we see code indicators, we're in code
+        if re.search(r'<[a-z].*?>|function|const|let|var|{', line):
+            in_code = True
+            filtered_lines.append(line)
+        elif in_code:
+            filtered_lines.append(line)
+    
+    result = '\n'.join(filtered_lines).strip()
+    
+    # If we filtered everything out, return original
+    if len(result) < 50:
+        return response_text
+    
+    return result
+
+
+def call_pollinations_ai(messages, stream=False):
+    """Call Pollinations.ai API for NON-CODE requests only (conversations, explanations)"""
+    try:
+        # System prompt for personality
+        system_msg = {
+            "role": "system", 
+            "content": """You are HenAi, an expert AI assistant created by NexusCraft. 
+When asked about your name, identity, or creator, respond with: 
+'My name is HenAi, I'm an AI assistant created by NexusCraft, and I'm glad to be helping you! 😊 
+Is there anything else you'd like to know, or anything else I can assist with today?'
+
+IMPORTANT RULES:
+1. When answering questions, be concise and direct
+2. Never include reasoning or thinking in your responses
+3. Maintain context from the full conversation history
+4. Be helpful, friendly, and engaging
+
+Remember: Your response should be natural and conversational."""
+        }
+        
+        url = "https://text.pollinations.ai/"
+        
+        # Prepare payload with ALL messages for context
+        payload = {
+            "messages": [system_msg] + messages,
+            "model": "openai",
+            "stream": stream,
+            "temperature": 0.7,
+            "max_tokens": 8000  # Increased from 4000 for longer responses
+        }
+        
+        if stream:
+            response = requests.post(url, json=payload, stream=True, timeout=None)
+            response.raise_for_status()
+            
+            def generate():
+                full_response = ""
+                for line in response.iter_lines():
+                    if line:
+                        try:
+                            text = line.decode('utf-8')
+                            # Skip any JSON metadata lines
+                            if not any(skip in text.lower() for skip in ['{"role"', 'reasoning', 'tool_calls']):
+                                full_response += text
+                                yield f"data: {json.dumps({'content': text})}\n\n"
+                        except:
+                            continue
+                yield f"data: {json.dumps({'done': True})}\n\n"
+            
+            return Response(generate(), mimetype='text/event-stream')
+        else:
+            # NO TIMEOUT - allow unlimited time for processing large files and generating long responses
+            response = requests.post(url, json=payload, timeout=None)
+            response.raise_for_status()
+            
+            raw_response = response.text.strip()
+            
+            # Clean the response to remove reasoning
+            cleaned_response = extract_code_from_response(raw_response)
+            
+            return cleaned_response
+            
+    except Exception as e:
+        print(f"❌ Pollinations.ai error: {e}")
+        return None
+
+
+def query_openrouter(prompt, context=None, is_code_generation=False):
+    """Query OpenRouter with full context - tries multiple API keys on failure"""
+    import time
+    start_time = time.time()
+    
+    print(f"\n{'='*60}")
+    print(f"🔧 OPENROUTER REQUEST - Code Generation: {is_code_generation}")
+    print(f"{'='*60}")
+    
+    # Try each API key in sequence
+    for key_index, api_key in enumerate(OPENROUTER_API_KEYS):
+        print(f"\n📌 Trying API Key #{key_index + 1}/{len(OPENROUTER_API_KEYS)}")
+        
+        try:
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "http://localhost:5000",
+                "X-Title": "HenAi"
+            }
+
+            messages = []
+
+            # Enhanced system prompt based on request type
+            is_title_gen = prompt.startswith("Based on this conversation, generate a very short title")
+            is_document_gen = "Create a " in prompt and ("document" in prompt.lower() or "presentation" in prompt.lower() or "spreadsheet" in prompt.lower())
+            
+            if is_code_generation:
+                system_prompt = """You are an expert AI coding assistant named HenAi created by NexusCraft.
+
+CRITICAL RULES FOR CODE GENERATION:
+1. ALWAYS provide COMPLETE, FULLY FUNCTIONAL code - never abbreviate or use placeholders like "// rest of code" or "..."
+2. Generate AT LEAST 500 lines of code for any substantial project
+3. Include ALL necessary components: imports, functions, classes, error handling, and comments
+4. For HTML/CSS/JS projects, create complete, production-ready code with proper styling
+5. Use modern best practices and design patterns
+6. Include comprehensive comments explaining key sections
+7. Ensure the code is immediately runnable/usable without modifications
+8. If generating a web app, include responsive design, proper meta tags, and complete styling
+9. If asked your name say you are HenAi Assistant created by NexusCraft
+
+Your code should be enterprise-grade, well-structured, and ready for production use."""
+            elif is_document_gen:
+                system_prompt = """You are an expert document creator. Generate professional, well-formatted documents.
+
+CRITICAL RULES:
+1. Use # for main titles, ## for sections, ### for subsections
+2. Use - or * for bullet points
+3. Use 1., 2., 3. for numbered lists
+4. Use **bold** and *italic* for emphasis
+5. Use markdown table format | for tables
+6. NEVER use code blocks around the entire document
+7. NEVER include introductory phrases like "Here is your document"
+8. Output ONLY the document content
+9. Keep paragraphs well-spaced and readable
+10. Ensure proper grammar and professional tone
+
+Generate the requested document now."""
+            elif is_title_gen:
+                system_prompt = "You are a title generator. Generate ONLY the title, maximum 5 words, no explanations, no quotes, no extra text."
+            else:
+                system_prompt = """You are a helpful AI assistant named HenAi created by NexusCraft. 
+When asked about your name, identity, or creator, respond with: 
+'My name is HenAi, I'm an AI assistant created by NexusCraft, and I'm glad to be helping you! 😊 
+Is there anything else you'd like to know, or anything else I can assist with today?'
+
+Otherwise, provide helpful, contextually relevant responses using the full conversation history. 
+Maintain context from the entire conversation, not just recent messages."""
+
+            messages.append({"role": "system", "content": system_prompt})
+
+            if context:
+                # Use full context - NO TRUNCATION
+                for ctx_msg in context:
+                    messages.append(ctx_msg)
+
+            messages.append({"role": "user", "content": prompt})
+
+            models = get_available_models(api_key)
+            print(f"📋 Available free models: {models[:5]}..." if len(models) > 5 else f"📋 Available free models: {models}")
+            print(f"📝 Prompt length: {len(prompt)} chars")
+            print(f"📚 Context messages: {len(context) if context else 0}")
+
+            # Determine max_tokens based on request type - INCREASED for full responses
+            if is_code_generation:
+                max_tokens = 16000  # Increased from 8000 for full code generation
+                print(f"⚙️ Code generation mode - max_tokens: {max_tokens}")
+            elif is_title_gen:
+                max_tokens = 50
+            else:
+                max_tokens = 8000  # Increased from 4000 for longer responses
+
+            attempt_count = 0
+            for model in models:
+                attempt_count += 1
+                model_start = time.time()
+                try:
+                    print(f"\n🔄 Attempt {attempt_count}/{len(models)} - Trying model: {model}")
+                    temperature = 0.3 if is_title_gen else (0.5 if is_code_generation else 0.7)
+                    
+                    data = {
+                        "model": model,
+                        "messages": messages,
+                        "temperature": temperature,
+                        "max_tokens": max_tokens
+                    }
+
+                    print(f"  ⏳ Sending request to {model}...")
+                    response = requests.post(url, json=data, headers=headers, timeout=120)
+                    model_elapsed = time.time() - model_start
+
+                    if response.status_code == 200:
+                        result = response.json()
+                        if 'choices' in result and len(result['choices']) > 0:
+                            message_content = result['choices'][0]['message']['content']
+                            content_length = len(message_content)
+                            total_elapsed = time.time() - start_time
+                            print(f"  ✅ SUCCESS with {model}!")
+                            print(f"  📊 Response length: {content_length} chars")
+                            print(f"  ⏱️ Model response time: {model_elapsed:.2f}s")
+                            print(f"  ⏱️ Total time: {total_elapsed:.2f}s")
+                            print(f"{'='*60}\n")
+                            return message_content
+                        else:
+                            print(f"  ⚠️ No choices in response from {model}")
+                    elif response.status_code == 429:
+                        print(f"  ⚠️ Rate limited for {model} (429), trying next...")
+                        continue
+                    elif response.status_code == 401:
+                        print(f"  ❌ Invalid API key for this model (401), trying next key...")
+                        break  # Break out of model loop to try next API key
+                    else:
+                        print(f"  ❌ Error {response.status_code} for {model}")
+                        if response.text:
+                            print(f"  Response: {response.text[:200]}")
+
+                except requests.exceptions.Timeout:
+                    print(f"  ⏰ Timeout for {model}")
+                    continue
+                except requests.exceptions.ConnectionError as e:
+                    print(f"  🔌 Connection error for {model}: {e}")
+                    continue
+                except Exception as e:
+                    print(f"  ❌ Exception with {model}: {type(e).__name__}: {e}")
+                    continue
+
+            print(f"  ⚠️ All models failed for API Key #{key_index + 1}")
+            
+        except Exception as e:
+            print(f"  ❌ OpenRouter error with key #{key_index + 1}: {e}")
+            continue
+    
+    # If all API keys failed
+    total_elapsed = time.time() - start_time
+    print(f"\n❌ ALL API KEYS FAILED after {len(OPENROUTER_API_KEYS)} keys")
+    print(f"⏱️ Total elapsed time: {total_elapsed:.2f}s")
+    print(f"{'='*60}\n")
+    return None
+
+
+def query_ai_with_fallback(prompt, context=None, is_code_generation=False):
+    """
+    Query AI with appropriate service:
+    - Code generation: ONLY OpenRouter (Pollinations is NOT used)
+    - Non-code requests: Pollinations.ai first, then OpenRouter fallback
+    """
+    print(f"🤖 AI Request - Code Generation: {is_code_generation}")
+    
+    # For code generation requests - ONLY use OpenRouter
+    if is_code_generation:
+        print("🔄 Using OpenRouter for code generation...")
+        response = query_openrouter(prompt, context, is_code_generation)
+        if response:
+            print("✅ OpenRouter code generation successful")
+            return response
+        else:
+            print("❌ OpenRouter code generation failed")
+            return f"I'm having trouble generating the code right now. Please try again or provide more details about what you need."
+    
+    # For NON-CODE requests (general chat, explanations, etc.) - use Pollinations.ai first
+    else:
+        # First try Pollinations.ai (faster for conversations)
+        print("🔄 Trying Pollinations.ai for conversation...")
+        messages = []
+        if context:
+            messages = context
+        messages.append({"role": "user", "content": prompt})
+        response = call_pollinations_ai(messages)
+        if response:
+            print("✅ Pollinations.ai conversation successful")
+            return response
+        
+        # If Pollinations fails, fallback to OpenRouter
+        print("⚠️ Pollinations.ai failed, falling back to OpenRouter...")
+        response = query_openrouter(prompt, context, is_code_generation)
+        if response:
+            print("✅ OpenRouter conversation successful")
+            return response
+    
+    # Ultimate fallback
+    print("❌ Both AI services failed")
+    return f"I'll help you with: {prompt}\n\nPlease provide more details so I can assist you better."
+
+
+def generate_chat_title(messages):
+    """Generate an intelligent title based on conversation context (max 5 words)"""
+    try:
+        # Extract the conversation context for title generation
+        context_text = ""
+        for msg in messages[-6:]:  # Look at last 6 messages for context
+            if msg['role'] == 'user':
+                context_text += msg['content'] + " "
+        
+        if not context_text.strip():
+            # Fallback to first message if no context
+            for msg in messages:
+                if msg['role'] == 'user':
+                    context_text = msg['content']
+                    break
+        
+        # Create a prompt for title generation
+        title_prompt = f"""Based on this conversation, generate a very short title (maximum 5 words). 
+        The title should capture the main topic or purpose of the conversation. 
+        Return ONLY the title, nothing else.
+        
+        Conversation context: {context_text[:500]}"""
+        
+        # Query AI for title generation (NOT code generation)
+        title_response = query_ai_with_fallback(title_prompt, context=None, is_code_generation=False)
+        
+        if title_response:
+            # Clean up the title - ensure max 5 words
+            words = title_response.strip().split()
+            if len(words) > 5:
+                title = ' '.join(words[:5])
+            else:
+                title = title_response.strip()
+            
+            # Remove any quotes or extra punctuation
+            title = title.strip('"\'').strip()
+            
+            # Ensure title is not empty
+            if title and len(title) > 0:
+                return title[:50]  # Cap at 50 chars for safety
+        
+        # Fallback to first user message if AI title generation fails
+        for msg in messages:
+            if msg['role'] == 'user':
+                title = msg['content'][:40]
+                if len(msg['content']) > 40:
+                    title += "..."
+                return title
+        
+        return "New Chat"
+        
+    except Exception as e:
+        print(f"Error generating AI title: {e}")
+        # Fallback to first user message
+        for msg in messages:
+            if msg['role'] == 'user':
+                title = msg['content'][:40]
+                if len(msg['content']) > 40:
+                    title += "..."
+                return title
+        return "New Chat"
+
+
+def is_code_generation_request(message):
+    """
+    Detect if the message is asking for code generation.
+    Returns True only for explicit code generation requests.
+    """
+    message_lower = message.lower()
+    
+    # First, check for file analysis/summary requests - these are NOT code generation
+    file_analysis_phrases = [
+        'summarize', 'explain', 'what is', 'tell me about', 'describe',
+        'extract', 'read', 'analyze', 'look at', 'examine', 'review',
+        'content of', 'contains', 'in this file', 'from the file',
+        'document says', 'file says'
+    ]
+    
+    if any(phrase in message_lower for phrase in file_analysis_phrases):
+        return False
+    
+    # Check if message is just asking about the file without code generation intent
+    if len(message.split()) < 10:
+        # Short messages about files are usually not code generation
+        if 'file' in message_lower or 'document' in message_lower or 'content' in message_lower:
+            return False
+    
+    # Code generation keywords - must be explicit about creating code
+    code_keywords = [
+        'create code', 'generate code', 'write code', 'build code', 'develop code',
+        'write a program', 'create a program', 'generate a program',
+        'write a script', 'create a script', 'generate a script',
+        'write a function', 'create a function', 'generate a function',
+        'write a class', 'create a class', 'generate a class',
+        'implement', 'code for', 'program that', 'script that',
+        'function that', 'class that', 'method that'
+    ]
+    
+    # Also check for requests to create specific types of files
+    if any(keyword in message_lower for keyword in code_keywords):
+        return True
+    
+    # Check if message contains both a verb and a technology mention
+    verbs = ['create', 'generate', 'write', 'build', 'develop', 'make', 'code']
+    technologies = ['html', 'css', 'javascript', 'python', 'react', 'vue', 
+                    'angular', 'node', 'express', 'django', 'flask']
+    
+    has_verb = any(verb in message_lower for verb in verbs)
+    has_tech = any(tech in message_lower for tech in technologies)
+    
+    # Only consider it code generation if it's explicitly about creating something
+    if has_verb and has_tech:
+        return True
+    
+    return False
+
+
+# ============= CODE EXECUTION =============
+
+def execute_python_code(code):
+    """Execute Python code safely and return output"""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as f:
+            f.write(code)
+            temp_file = f.name
+
+        result = subprocess.run(
+            [sys.executable, temp_file],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+
+        try:
+            os.unlink(temp_file)
+        except:
+            pass
+
+        if result.returncode == 0:
+            return {
+                'success': True,
+                'output': result.stdout if result.stdout else "✓ Code executed successfully",
+                'error': None
+            }
+        else:
+            return {
+                'success': False,
+                'output': result.stdout,
+                'error': result.stderr if result.stderr else "Execution failed"
+            }
+    except subprocess.TimeoutExpired:
+        return {'success': False, 'output': '', 'error': '⏱️ Code execution timed out (10 seconds)'}
+    except Exception as e:
+        return {'success': False, 'output': '', 'error': str(e)}
+
+
+# ============= WEB SEARCH AND EXTRACTION =============
+
+def search_web(query):
+    """Generate web search response"""
+    return f"""🔍 **Web Search: "{query}"**
+
+Use Google, DuckDuckGo, or Bing to find information.
+You can also use `/extract [url]` to analyze specific websites.
+
+Search links:
+• Google: https://www.google.com/search?q={query.replace(' ', '+')}
+• Wikipedia: https://en.wikipedia.org/wiki/{query.replace(' ', '_')}"""
+
+
+def extract_web_content(url):
+    """Extract content from a URL"""
+    try:
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+
+        response = requests.get(url, timeout=None, headers={
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        response.raise_for_status()
+
+        text = re.sub(r'<[^>]+>', ' ', response.text)
+        text = re.sub(r'\s+', ' ', text)
+        content = text[:2000] + "..." if len(text) > 2000 else text
+
+        return f"""📄 **Content from {url}**:
+
+{content}"""
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# ============= IMAGE ANALYSIS =============
+
+def analyze_image_with_ai(image_content, image_name, photographer="Unknown", ocr_text=""):
+    """Analyze an image using AI with OCR text - returns clean analysis without metadata"""
+    try:
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        # Use first API key for image analysis (or could loop through keys)
+        api_key_to_use = OPENROUTER_API_KEYS[0] if OPENROUTER_API_KEYS else ""
+        headers = {
+            "Authorization": f"Bearer {api_key_to_use}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "http://localhost:5000",
+            "X-Title": "HenAi"
+        }
+        
+        # Create clean prompt without asking for numbered sections
+        if ocr_text and ocr_text.strip() and not ocr_text.startswith("[OCR extraction failed"):
+            analysis_prompt = f"""Analyze the content of this image based on the text extracted from it.
+
+Extracted text from the image:
+{ocr_text[:2000]}
+
+Please provide a natural, readable analysis of what this image contains. Focus on:
+- What the image shows or represents based on the extracted text
+- Any key information visible in the image
+- The context or purpose of the image
+
+Write in clear, well-formatted paragraphs. Do not use numbered lists, headers, or any markdown formatting. Just provide a natural analysis as if you're describing what you see."""
+        else:
+            # Extract meaningful description from filename
+            import re
+            name_without_ext = re.sub(r'\.[^.]+$', '', image_name)
+            clean_name = re.sub(r'[_\-\.]', ' ', name_without_ext)
+            clean_name = re.sub(r'\d+', '', clean_name).strip()
+            
+            analysis_prompt = f"""Analyze this image. The filename suggests it may be related to "{clean_name}".
+
+Please provide a natural, readable analysis of:
+- What this image likely shows or represents
+- The subject matter or content
+- Any notable characteristics
+
+Write in clear, well-formatted paragraphs. Do not use numbered lists, headers, or any markdown formatting. Just provide a natural analysis as if you're describing what you see."""
+        
+        messages = [
+            {"role": "system", "content": "You are an expert image analyst. Provide clean, natural analysis without any markdown formatting, headers, or numbered lists. Just write in plain paragraphs."},
+            {"role": "user", "content": analysis_prompt}
+        ]
+        
+        models_to_try = [
+            "google/gemini-2.0-flash-exp:free",
+            "meta-llama/llama-3.2-90b-vision-instruct:free",
+            "microsoft/phi-3.5-mini-128k-instruct:free",
+            "openrouter/free"
+        ]
+        
+        for model in models_to_try:
+            try:
+                data = {
+                    "model": model,
+                    "messages": messages,
+                    "temperature": 0.7,
+                    "max_tokens": 2000
+                }
+                
+                response = requests.post(url, json=data, headers=headers, timeout=None)
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    if 'choices' in result and len(result['choices']) > 0:
+                        print(f"✓ Image analysis successful with {model}")
+                        analysis = result['choices'][0]['message']['content']
+                        
+                        # Clean up any remaining markdown or numbered lists
+                        import re
+                        # Remove markdown headers
+                        analysis = re.sub(r'^#{1,6}\s+.*?\n', '', analysis, flags=re.MULTILINE)
+                        # Remove numbered list patterns like "1. " at start of lines
+                        analysis = re.sub(r'^\d+\.\s+', '', analysis, flags=re.MULTILINE)
+                        # Remove bullet points like "- " or "* " at start of lines
+                        analysis = re.sub(r'^[\*\-]\s+', '', analysis, flags=re.MULTILINE)
+                        # Remove any "**" bold markers
+                        analysis = re.sub(r'\*\*([^*]+)\*\*', r'\1', analysis)
+                        # Remove any remaining markdown artifacts
+                        analysis = re.sub(r'`([^`]+)`', r'\1', analysis)
+                        # Clean up multiple newlines
+                        analysis = re.sub(r'\n{3,}', '\n\n', analysis)
+                        # Trim whitespace
+                        analysis = analysis.strip()
+                        
+                        return analysis
+                elif response.status_code == 429:
+                    print(f"Rate limited on {model}, trying next...")
+                    continue
+                else:
+                    print(f"Model {model} failed with status {response.status_code}")
+                    continue
+                    
+            except Exception as e:
+                print(f"Error with {model}: {e}")
+                continue
+        
+        # Fallback analysis
+        if ocr_text and ocr_text.strip():
+            # Clean OCR text for fallback
+            import re
+            clean_ocr = re.sub(r'\s+', ' ', ocr_text[:500]).strip()
+            return f"The image contains readable text: {clean_ocr}"
+        else:
+            import re
+            name_without_ext = re.sub(r'\.[^.]+$', '', image_name)
+            clean_name = re.sub(r'[_\-\.]', ' ', name_without_ext)
+            clean_name = re.sub(r'\d+', '', clean_name).strip()
+            if clean_name:
+                return f"This image appears to be related to {clean_name}."
+            else:
+                return "The image has been processed, but no readable text was detected."
+        
+    except Exception as e:
+        print(f"Error analyzing image: {e}")
+        return None

mydocs.py

@@ -0,0 +1,741 @@
+# mydocs.py - Document creation utilities extracted from app.py
+
+import os
+import json
+import re
+import pandas as pd
+import openpyxl
+from io import BytesIO
+from docx import Document
+from docx.shared import Inches, Pt, RGBColor
+from pptx import Presentation
+from pptx.util import Inches as PptxInches
+from pptx.enum.text import PP_ALIGN
+from PIL import Image, ImageDraw, ImageFont
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
+from reportlab.lib.units import inch
+import textwrap
+from pathlib import Path
+
+
+class DocumentCreator:
+    """Utility class for creating various types of documents"""
+    
+    def __init__(self, output_dir="generated_docs"):
+        """Initialize with output directory"""
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.temp_dir = Path("temp_docs")
+        self.temp_dir.mkdir(exist_ok=True)
+    
+    def create_word_document(self, content, filename):
+        """Create a Word document from markdown-style content with proper formatting"""
+        doc = Document()
+        
+        # Add document title style
+        lines = content.split('\n')
+        in_table = False
+        table_rows = []
+        current_heading_level = 0
+        
+        for line in lines:
+            line = line.rstrip()
+            if not line.strip():
+                if not in_table:
+                    doc.add_paragraph()
+                continue
+            
+            # Handle markdown tables
+            if '|' in line and line.count('|') >= 2:
+                # Check if this is a table row
+                cells = [cell.strip() for cell in line.split('|')]
+                cells = [c for c in cells if c or (cells.index(c) > 0 and cells.index(c) < len(cells)-1)]
+                
+                if not in_table:
+                    # Start new table
+                    in_table = True
+                    table_rows = [cells]
+                else:
+                    # Check if this is a separator row (contains ---)
+                    if all('-' in cell for cell in cells if cell):
+                        continue  # Skip separator row
+                    table_rows.append(cells)
+                continue
+            elif in_table:
+                # End of table, create the table in Word
+                if table_rows:
+                    num_cols = max(len(row) for row in table_rows)
+                    table = doc.add_table(rows=len(table_rows), cols=num_cols)
+                    table.style = 'Table Grid'
+                    for i, row in enumerate(table_rows):
+                        for j, cell_text in enumerate(row):
+                            if j < num_cols:
+                                table.cell(i, j).text = cell_text
+                    doc.add_paragraph()
+                in_table = False
+                table_rows = []
+                # Process current line as regular content
+                if line.strip():
+                    doc.add_paragraph(line)
+                continue
+            
+            # Handle headings
+            if line.startswith('# '):
+                doc.add_heading(line[2:].strip(), level=1)
+                current_heading_level = 1
+            elif line.startswith('## '):
+                doc.add_heading(line[3:].strip(), level=2)
+                current_heading_level = 2
+            elif line.startswith('### '):
+                doc.add_heading(line[4:].strip(), level=3)
+                current_heading_level = 3
+            elif line.startswith('#### '):
+                doc.add_heading(line[5:].strip(), level=4)
+                current_heading_level = 4
+            # Handle bullet points
+            elif line.startswith('- ') or line.startswith('* '):
+                p = doc.add_paragraph(line[2:].strip(), style='List Bullet')
+            # Handle numbered lists
+            elif re.match(r'^\d+\.\s', line):
+                p = doc.add_paragraph(line, style='List Number')
+            # Handle horizontal rule
+            elif line.strip() == '---' or line.strip() == '***':
+                doc.add_paragraph('_' * 50)
+            # Handle bold text within paragraph
+            else:
+                # Process inline formatting
+                p = doc.add_paragraph()
+                self._add_formatted_text(p, line)
+        
+        # Handle any remaining table
+        if in_table and table_rows:
+            num_cols = max(len(row) for row in table_rows)
+            table = doc.add_table(rows=len(table_rows), cols=num_cols)
+            table.style = 'Table Grid'
+            for i, row in enumerate(table_rows):
+                for j, cell_text in enumerate(row):
+                    if j < num_cols:
+                        table.cell(i, j).text = cell_text
+        
+        output_path = self.output_dir / filename
+        doc.save(str(output_path))
+        return output_path
+    
+    def _add_formatted_text(self, paragraph, text):
+        """Add text with markdown formatting to a paragraph"""
+        from docx.shared import RGBColor
+        
+        # Process bold and italic
+        parts = []
+        current_pos = 0
+        bold_pattern = r'\*\*([^*]+)\*\*'
+        italic_pattern = r'\*([^*]+)\*'
+        
+        # Combine patterns
+        all_matches = []
+        for match in re.finditer(bold_pattern, text):
+            all_matches.append((match.start(), match.end(), 'bold', match.group(1)))
+        for match in re.finditer(italic_pattern, text):
+            all_matches.append((match.start(), match.end(), 'italic', match.group(1)))
+        
+        all_matches.sort(key=lambda x: x[0])
+        
+        if not all_matches:
+            paragraph.add_run(text)
+            return
+        
+        last_end = 0
+        for start, end, style, content in all_matches:
+            if start > last_end:
+                paragraph.add_run(text[last_end:start])
+            run = paragraph.add_run(content)
+            if style == 'bold':
+                run.bold = True
+            elif style == 'italic':
+                run.italic = True
+            last_end = end
+        
+        if last_end < len(text):
+            paragraph.add_run(text[last_end:])
+    
+    def create_text_file(self, content, filename):
+        """Create a plain text file with proper formatting"""
+        output_path = self.output_dir / filename
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return output_path
+    
+    def create_excel_file(self, content, filename):
+        """Create an Excel file from markdown table or CSV content"""
+        import openpyxl
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        wb = openpyxl.Workbook()
+        ws = wb.active
+        ws.title = "Sheet1"
+        
+        # Parse content - look for markdown tables first
+        lines = content.strip().split('\n')
+        table_data = []
+        in_table = False
+        
+        for line in lines:
+            if '|' in line and line.count('|') >= 2:
+                cells = [cell.strip() for cell in line.split('|')]
+                cells = [c for c in cells if c or (cells.index(c) > 0 and cells.index(c) < len(cells)-1)]
+                if cells:
+                    if not in_table:
+                        in_table = True
+                    # Skip separator rows
+                    if not all('-' in cell for cell in cells if cell):
+                        table_data.append(cells)
+            elif in_table and not line.strip():
+                in_table = False
+        
+        if not table_data:
+            # Try CSV format
+            for line in lines:
+                if ',' in line:
+                    table_data.append([cell.strip() for cell in line.split(',')])
+                elif line.strip():
+                    table_data.append([line.strip()])
+        
+        # Write to Excel with styling
+        if table_data:
+            thin_border = Border(
+                left=Side(style='thin'), right=Side(style='thin'),
+                top=Side(style='thin'), bottom=Side(style='thin')
+            )
+            header_fill = PatternFill(start_color='366092', end_color='366092', fill_type='solid')
+            header_font = Font(color='FFFFFF', bold=True)
+            
+            for i, row in enumerate(table_data):
+                for j, cell_value in enumerate(row):
+                    cell = ws.cell(row=i+1, column=j+1, value=cell_value)
+                    cell.border = thin_border
+                    cell.alignment = Alignment(horizontal='left', vertical='center')
+                    if i == 0:
+                        cell.fill = header_fill
+                        cell.font = header_font
+        
+        # Auto-adjust column widths
+        for column in ws.columns:
+            max_length = 0
+            column_letter = column[0].column_letter
+            for cell in column:
+                try:
+                    if len(str(cell.value)) > max_length:
+                        max_length = len(str(cell.value))
+                except:
+                    pass
+            adjusted_width = min(max_length + 2, 50)
+            ws.column_dimensions[column_letter].width = adjusted_width
+        
+        output_path = self.output_dir / filename
+        wb.save(str(output_path))
+        return output_path
+    
+    def create_csv_file(self, content, filename):
+        """Create a CSV file from markdown table or text content"""
+        import csv
+        
+        # Parse content - look for markdown tables
+        lines = content.strip().split('\n')
+        table_data = []
+        in_table = False
+        
+        for line in lines:
+            if '|' in line and line.count('|') >= 2:
+                cells = [cell.strip() for cell in line.split('|')]
+                cells = [c for c in cells if c or (cells.index(c) > 0 and cells.index(c) < len(cells)-1)]
+                if cells:
+                    if not in_table:
+                        in_table = True
+                    if not all('-' in cell for cell in cells if cell):
+                        table_data.append(cells)
+            elif in_table and not line.strip():
+                in_table = False
+        
+        if not table_data:
+            # Try plain CSV or text
+            for line in lines:
+                if ',' in line:
+                    table_data.append([cell.strip() for cell in line.split(',')])
+                elif line.strip():
+                    table_data.append([line.strip()])
+        
+        output_path = self.output_dir / filename
+        with open(output_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            writer.writerows(table_data)
+        
+        return output_path
+    
+    def create_powerpoint(self, content, filename):
+        """Create a PowerPoint presentation with proper slide separation and formatting"""
+        from pptx.util import Inches as PptxInches
+        from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
+        from pptx.dml.color import RGBColor as PptxRGBColor
+        
+        prs = Presentation()
+        
+        # Set slide dimensions (standard 16:9)
+        prs.slide_width = PptxInches(13.333)
+        prs.slide_height = PptxInches(7.5)
+        
+        # Parse slides - split by "---" or "## Slide" patterns
+        slides_content = []
+        
+        # Try to split by markdown slide separators
+        if '---' in content:
+            raw_slides = content.split('---')
+            for slide in raw_slides:
+                if slide.strip():
+                    slides_content.append(slide.strip())
+        else:
+            # Try to split by "## Slide" pattern
+            import re
+            slide_pattern = r'(?:##\s*Slide\s*\d+)\s*\n(.*?)(?=(?:##\s*Slide|$))'
+            matches = re.findall(slide_pattern, content, re.DOTALL)
+            if matches:
+                slides_content = matches
+            else:
+                # Try to split by numbered slides
+                numbered_slides = re.split(r'\n(?=\d+\.\s+[A-Z])', content)
+                if len(numbered_slides) > 1:
+                    slides_content = numbered_slides
+                else:
+                    # Single slide
+                    slides_content = [content]
+        
+        # If no slides found, create one slide with all content
+        if not slides_content:
+            slides_content = [content]
+        
+        for slide_idx, slide_content in enumerate(slides_content):
+            if not slide_content.strip():
+                continue
+                
+            lines = slide_content.split('\n')
+            
+            # Clean up lines - remove empty lines at start/end
+            while lines and not lines[0].strip():
+                lines.pop(0)
+            while lines and not lines[-1].strip():
+                lines.pop()
+            
+            if not lines:
+                continue
+            
+            # Extract title and body content
+            slide_title = ""
+            body_lines = []
+            
+            # First line as potential title
+            first_line = lines[0].strip()
+            
+            # Check if first line is a heading (starts with #)
+            if first_line.startswith('#'):
+                slide_title = first_line.lstrip('#').strip()
+                body_lines = lines[1:]
+            elif first_line.startswith('Slide') or first_line.startswith('**'):
+                slide_title = first_line.replace('**', '').replace('Slide', '').strip()
+                if slide_title and slide_title[0].isdigit():
+                    # Extract just the title part
+                    parts = slide_title.split(' ', 1)
+                    if len(parts) > 1:
+                        slide_title = parts[1]
+                    else:
+                        slide_title = f"Slide {slide_idx + 1}"
+                body_lines = lines[1:] if len(lines) > 1 else []
+            else:
+                # No clear title, use generic title
+                slide_title = f"Slide {slide_idx + 1}"
+                body_lines = lines
+            
+            # Determine slide layout
+            if slide_idx == 0 and (len(body_lines) == 0 or len(slide_title) < 30):
+                # Title slide
+                slide_layout = prs.slide_layouts[0]
+                slide = prs.slides.add_slide(slide_layout)
+                
+                # Set title
+                if slide.shapes.title:
+                    title_shape = slide.shapes.title
+                    title_shape.text = slide_title if slide_title else "Presentation Title"
+                    
+                    # Format title
+                    for paragraph in title_shape.text_frame.paragraphs:
+                        paragraph.font.size = PptxInches(0.44)
+                        paragraph.font.bold = True
+                        paragraph.alignment = PP_ALIGN.CENTER
+                
+                # Set subtitle if available
+                if len(slide.placeholders) > 1 and body_lines:
+                    subtitle_placeholder = slide.placeholders[1]
+                    subtitle_text = '\n'.join(body_lines[:3])
+                    subtitle_placeholder.text = subtitle_text
+                    
+                    # Format subtitle
+                    for paragraph in subtitle_placeholder.text_frame.paragraphs:
+                        paragraph.font.size = PptxInches(0.28)
+                        paragraph.alignment = PP_ALIGN.CENTER
+            else:
+                # Content slide
+                slide_layout = prs.slide_layouts[1]
+                slide = prs.slides.add_slide(slide_layout)
+                
+                # Set title
+                if slide.shapes.title:
+                    title_shape = slide.shapes.title
+                    title_shape.text = slide_title if slide_title else f"Slide {slide_idx + 1}"
+                    
+                    # Format title
+                    for paragraph in title_shape.text_frame.paragraphs:
+                        paragraph.font.size = PptxInches(0.36)
+                        paragraph.font.bold = True
+                
+                # Set content
+                if len(slide.placeholders) > 1:
+                    content_placeholder = slide.placeholders[1]
+                    
+                    # Clear existing content
+                    content_placeholder.text = ""
+                    text_frame = content_placeholder.text_frame
+                    text_frame.clear()
+                    
+                    # Process body lines and add to content
+                    for line in body_lines:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        
+                        # Add a new paragraph
+                        p = text_frame.add_paragraph()
+                        
+                        # Handle bullet points
+                        if line.startswith('- ') or line.startswith('* '):
+                            p.text = line[2:]
+                            p.level = 0
+                            p.bullet = True
+                        elif line.startswith('  - ') or line.startswith('  * '):
+                            p.text = line[4:]
+                            p.level = 1
+                            p.bullet = True
+                        elif line.startswith('    - ') or line.startswith('    * '):
+                            p.text = line[6:]
+                            p.level = 2
+                            p.bullet = True
+                        elif re.match(r'^\d+\.\s', line):
+                            # Numbered list
+                            p.text = line
+                            p.bullet = False
+                        elif line.startswith('**') and line.endswith('**'):
+                            # Bold heading within content
+                            p.text = line.strip('*')
+                            p.font.bold = True
+                        else:
+                            # Regular paragraph
+                            p.text = line
+                            p.bullet = False
+                        
+                        # Set font size
+                        p.font.size = PptxInches(0.24)
+                        
+                        # Add spacing between paragraphs
+                        p.space_after = PptxInches(0.06)
+        
+        # Remove any empty slides at the end
+        slides_to_remove = []
+        for i, slide in enumerate(prs.slides):
+            has_content = False
+            for shape in slide.shapes:
+                if hasattr(shape, "text") and shape.text and shape.text.strip():
+                    has_content = True
+                    break
+            if not has_content and i > 0:
+                slides_to_remove.append(i)
+        
+        # Note: python-pptx doesn't support direct slide removal easily
+        # We'll just save as is - empty slides are rare
+        
+        output_path = self.output_dir / filename
+        prs.save(str(output_path))
+        return output_path
+    
+    def create_image_from_text(self, content, filename):
+        """Create an image from text content with proper formatting"""
+        from PIL import Image, ImageDraw, ImageFont
+        
+        # Clean content
+        lines = []
+        for line in content.split('\n'):
+            if line.strip():
+                # Remove markdown formatting for image
+                clean_line = re.sub(r'\*\*([^*]+)\*\*', r'\1', line)
+                clean_line = re.sub(r'\*([^*]+)\*', r'\1', clean_line)
+                clean_line = re.sub(r'#+\s*', '', clean_line)
+                lines.append(clean_line)
+        
+        if not lines:
+            lines = [content[:100]]
+        
+        # Calculate image size
+        max_line_length = max(len(line) for line in lines) if lines else 40
+        img_width = min(1200, max(400, max_line_length * 12))
+        line_height = 30
+        img_height = max(400, len(lines) * line_height + 100)
+        
+        img = Image.new('RGB', (img_width, img_height), color='white')
+        draw = ImageDraw.Draw(img)
+        
+        # Try to load a better font
+        try:
+            font = ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", 16)
+        except:
+            try:
+                font = ImageFont.truetype("arial.ttf", 16)
+            except:
+                font = ImageFont.load_default()
+        
+        y = 40
+        for line in lines:
+            # Wrap long lines
+            wrapped_lines = textwrap.wrap(line, width=img_width // 10)
+            for wrapped in wrapped_lines:
+                draw.text((20, y), wrapped, fill='black', font=font)
+                y += line_height
+        
+        output_path = self.output_dir / filename
+        img.save(str(output_path))
+        return output_path
+    
+    def create_pdf_from_content(self, content, filename):
+        """Create a PDF from markdown content with proper formatting"""
+        from reportlab.lib.pagesizes import letter
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.units import inch
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+        from reportlab.lib import colors
+        
+        output_path = self.output_dir / filename
+        doc = SimpleDocTemplate(str(output_path), pagesize=letter,
+                                rightMargin=72, leftMargin=72,
+                                topMargin=72, bottomMargin=72)
+        
+        styles = getSampleStyleSheet()
+        story = []
+        
+        # Create custom styles
+        heading1_style = ParagraphStyle('Heading1Custom', parent=styles['Heading1'], fontSize=16, spaceAfter=12, spaceBefore=12)
+        heading2_style = ParagraphStyle('Heading2Custom', parent=styles['Heading2'], fontSize=14, spaceAfter=10, spaceBefore=10)
+        normal_style = ParagraphStyle('NormalCustom', parent=styles['Normal'], fontSize=10, spaceAfter=6)
+        
+        lines = content.split('\n')
+        in_table = False
+        table_data = []
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                if not in_table:
+                    story.append(Spacer(1, 6))
+                continue
+            
+            # Handle markdown tables
+            if '|' in line and line.count('|') >= 2:
+                cells = [cell.strip() for cell in line.split('|')]
+                cells = [c for c in cells if c or (cells.index(c) > 0 and cells.index(c) < len(cells)-1)]
+                if cells:
+                    if not in_table:
+                        in_table = True
+                        table_data = [cells]
+                    elif not all('-' in cell for cell in cells if cell):
+                        table_data.append(cells)
+                continue
+            elif in_table:
+                # Create table
+                if table_data:
+                    # Convert to ReportLab table
+                    rt_table = Table(table_data)
+                    rt_table.setStyle(TableStyle([
+                        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                        ('FONTSIZE', (0, 0), (-1, 0), 10),
+                        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+                    ]))
+                    story.append(rt_table)
+                    story.append(Spacer(1, 12))
+                in_table = False
+                table_data = []
+                continue
+            
+            # Handle headings
+            if line.startswith('# '):
+                story.append(Paragraph(line[2:], heading1_style))
+            elif line.startswith('## '):
+                story.append(Paragraph(line[3:], heading2_style))
+            elif line.startswith('### '):
+                story.append(Paragraph(line[4:], normal_style))
+            elif line.startswith('- ') or line.startswith('* '):
+                story.append(Paragraph('• ' + line[2:], normal_style))
+            elif re.match(r'^\d+\.\s', line):
+                story.append(Paragraph(line, normal_style))
+            else:
+                story.append(Paragraph(line, normal_style))
+        
+        doc.build(story)
+        return output_path
+    
+    def create_document(self, content, doc_type, filename, template_id=None):
+        """
+        Main method to create a document based on type
+        
+        Args:
+            content: The content to put in the document
+            doc_type: Type of document ('word', 'txt', 'excel', 'csv', 'ppt', 'image', 'pdf')
+            filename: Desired filename (without extension)
+            template_id: Optional template ID for formatting
+        
+        Returns:
+            Path to created document
+        """
+        # Ensure filename has proper extension
+        ext_map = {
+            'word': '.docx',
+            'txt': '.txt',
+            'pdf': '.pdf',
+            'excel': '.xlsx',
+            'csv': '.csv',
+            'ppt': '.pptx',
+            'image': '.png'
+        }
+        
+        ext = ext_map.get(doc_type, '.txt')
+        full_filename = f"{filename}{ext}"
+        
+        # Enhance content with template-specific formatting
+        if template_id:
+            content = self._apply_template_formatting(content, doc_type, template_id)
+        
+        # Create document based on type
+        if doc_type == 'word':
+            return self.create_word_document(content, full_filename)
+        elif doc_type == 'txt':
+            return self.create_text_file(content, full_filename)
+        elif doc_type == 'excel':
+            return self.create_excel_file(content, full_filename)
+        elif doc_type == 'csv':
+            return self.create_csv_file(content, full_filename)
+        elif doc_type == 'ppt':
+            return self.create_powerpoint(content, full_filename)
+        elif doc_type == 'image':
+            return self.create_image_from_text(content, full_filename)
+        elif doc_type == 'pdf':
+            return self.create_pdf_from_content(content, full_filename)
+        else:
+            raise ValueError(f"Unsupported document type: {doc_type}")
+    
+    def _apply_template_formatting(self, content, doc_type, template_id):
+        """Apply template-specific formatting instructions to content"""
+        if template_id == 'professional':
+            if doc_type == 'word':
+                content += """
+                
+                Format this as a professional document with:
+                - Clear headings (use ### for main sections)
+                - Bullet points where appropriate
+                - Professional tone
+                - Proper spacing between sections"""
+            elif doc_type == 'ppt':
+                content += """
+                
+                Format this as a presentation with:
+                - Title slide (presentation title)
+                - 3-5 content slides with headings and bullet points
+                - Closing slide with summary or call to action
+                Separate slides with ---"""
+            elif doc_type == 'excel':
+                content += """
+                
+                Format this as structured data with:
+                - Column headers as first row
+                - Each row as a data entry
+                - Use consistent formatting"""
+        
+        return content
+    
+    def get_download_url(self, filename, base_url="/api/docs/download/"):
+        """Get download URL for a file"""
+        return f"{base_url}{filename}"
+
+
+# Convenience functions for quick document creation
+
+def create_word_document(content, filename, output_dir="generated_docs"):
+    """Quickly create a Word document"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_word_document(content, filename)
+
+
+def create_text_file(content, filename, output_dir="generated_docs"):
+    """Quickly create a text file"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_text_file(content, filename)
+
+
+def create_excel_file(content, filename, output_dir="generated_docs"):
+    """Quickly create an Excel file"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_excel_file(content, filename)
+
+
+def create_powerpoint(content, filename, output_dir="generated_docs"):
+    """Quickly create a PowerPoint presentation"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_powerpoint(content, filename)
+
+
+def create_image_from_text(content, filename, output_dir="generated_docs"):
+    """Quickly create an image from text"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_image_from_text(content, filename)
+
+
+def create_pdf_from_content(content, filename, output_dir="generated_docs"):
+    """Quickly create a PDF from text"""
+    creator = DocumentCreator(output_dir)
+    return creator.create_pdf_from_content(content, filename)
+
+
+# Example usage
+if __name__ == "__main__":
+    # Test the document creator
+    creator = DocumentCreator()
+    
+    # Create a sample Word document
+    sample_content = """# Welcome to My Document
+## Introduction
+This is a sample document created with the DocumentCreator class.
+
+## Features
+- Easy document creation
+- Multiple format support
+- Professional formatting
+
+### Conclusion
+Thank you for using this utility!"""
+    
+    doc_path = creator.create_document(sample_content, 'word', 'sample_document')
+    print(f"Created Word document: {doc_path}")
+    
+    # Create a sample text file
+    text_path = creator.create_document("Hello, World!", 'txt', 'hello_world')
+    print(f"Created text file: {text_path}")

vision.py

@@ -0,0 +1,282 @@
+# vision.py - Multi-Model Vision Processor for HenAi
+# Supports multiple vision models with automatic fallback
+# No metadata analysis - pure image content understanding
+
+import torch
+from PIL import Image
+import io
+import base64
+import requests
+import re
+
+# ============= TRY IMPORTS WITH FALLBACKS =============
+
+# BLIP Model (Salesforce)
+try:
+    from transformers import BlipProcessor, BlipForConditionalGeneration
+    BLIP_AVAILABLE = True
+except ImportError:
+    BLIP_AVAILABLE = False
+    print("Warning: BLIP not available. Install with: pip install transformers")
+
+# Florence-2 Model (Microsoft - more detailed)
+try:
+    from transformers import AutoProcessor, AutoModelForCausalLM
+    FLORENCE_AVAILABLE = True
+except ImportError:
+    FLORENCE_AVAILABLE = False
+
+# OFA Model (Microsoft - good all-rounder)
+try:
+    from transformers import OFATokenizer, OFAModel
+    OFA_AVAILABLE = True
+except ImportError:
+    OFA_AVAILABLE = False
+
+# Git (ViT + GPT2)
+try:
+    from transformers import GitProcessor, GitForCausalLM
+    GIT_AVAILABLE = True
+except ImportError:
+    GIT_AVAILABLE = False
+
+
+class VisionModel:
+    """
+    Multi-model vision processor with automatic fallback.
+    Tries models in order: BLIP -> Florence-2 -> GIT -> Fallback text analysis
+    """
+    
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"🖼️ Initializing Vision Model on {self.device}...")
+        
+        self.models = {}
+        self.current_model = None
+        
+        # Try to load BLIP (smallest, fastest)
+        if BLIP_AVAILABLE:
+            try:
+                print("  Loading BLIP model...")
+                self.models['blip'] = {
+                    'processor': BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base"),
+                    'model': BlipForConditionalGeneration.from_pretrained(
+                        "Salesforce/blip-image-captioning-base",
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                    ).to(self.device),
+                    'name': 'BLIP'
+                }
+                self.models['blip']['model'].eval()
+                print("  ✓ BLIP model loaded")
+                self.current_model = 'blip'
+            except Exception as e:
+                print(f"  ✗ Failed to load BLIP: {e}")
+        
+        # Try to load Florence-2 (more detailed captions)
+        if FLORENCE_AVAILABLE and not self.current_model:
+            try:
+                print("  Loading Florence-2 model...")
+                self.models['florence'] = {
+                    'processor': AutoProcessor.from_pretrained("microsoft/florence-2-base", trust_remote_code=True),
+                    'model': AutoModelForCausalLM.from_pretrained(
+                        "microsoft/florence-2-base",
+                        trust_remote_code=True,
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                    ).to(self.device),
+                    'name': 'Florence-2'
+                }
+                self.models['florence']['model'].eval()
+                print("  ✓ Florence-2 model loaded")
+                self.current_model = 'florence'
+            except Exception as e:
+                print(f"  ✗ Failed to load Florence-2: {e}")
+        
+        # Try to load GIT (good for detailed descriptions)
+        if GIT_AVAILABLE and not self.current_model:
+            try:
+                print("  Loading GIT model...")
+                self.models['git'] = {
+                    'processor': GitProcessor.from_pretrained("microsoft/git-base"),
+                    'model': GitForCausalLM.from_pretrained(
+                        "microsoft/git-base",
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                    ).to(self.device),
+                    'name': 'GIT'
+                }
+                self.models['git']['model'].eval()
+                print("  ✓ GIT model loaded")
+                self.current_model = 'git'
+            except Exception as e:
+                print(f"  ✗ Failed to load GIT: {e}")
+        
+        if not self.current_model:
+            print("⚠️ No vision model loaded. Using fallback analysis.")
+            self.current_model = None
+    
+    def get_vision_caption(self, image_bytes, max_length=100):
+        """
+        Generate a natural description of the image content.
+        Returns a clean description without metadata.
+        """
+        if not self.current_model:
+            return None
+        
+        try:
+            # Load image
+            image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+            
+            # Use the loaded model
+            if self.current_model == 'blip':
+                return self._caption_with_blip(image, max_length)
+            elif self.current_model == 'florence':
+                return self._caption_with_florence(image, max_length)
+            elif self.current_model == 'git':
+                return self._caption_with_git(image, max_length)
+            else:
+                return None
+                
+        except Exception as e:
+            print(f"Error generating vision caption with {self.current_model}: {e}")
+            # Try fallback to another model if available
+            return self._try_fallback_model(image_bytes, max_length)
+    
+    def _caption_with_blip(self, image, max_length):
+        """Generate caption using BLIP"""
+        processor = self.models['blip']['processor']
+        model = self.models['blip']['model']
+        
+        inputs = processor(images=image, return_tensors="pt").to(self.device)
+        
+        with torch.no_grad():
+            out = model.generate(
+                **inputs,
+                max_length=max_length,
+                num_beams=3,
+                temperature=0.7,
+                do_sample=True
+            )
+        
+        caption = processor.decode(out[0], skip_special_tokens=True)
+        return self._clean_caption(caption)
+    
+    def _caption_with_florence(self, image, max_length):
+        """Generate detailed caption using Florence-2"""
+        processor = self.models['florence']['processor']
+        model = self.models['florence']['model']
+        
+        prompt = "<MORE_DETAILED_CAPTION>"
+        inputs = processor(text=prompt, images=image, return_tensors="pt").to(self.device)
+        
+        with torch.no_grad():
+            generated_ids = model.generate(
+                **inputs,
+                max_new_tokens=max_length,
+                do_sample=False,
+                num_beams=3
+            )
+        
+        generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        # Remove the prompt from the output
+        generated_text = generated_text.replace(prompt, "").strip()
+        return self._clean_caption(generated_text)
+    
+    def _caption_with_git(self, image, max_length):
+        """Generate caption using GIT"""
+        processor = self.models['git']['processor']
+        model = self.models['git']['model']
+        
+        inputs = processor(images=image, return_tensors="pt").to(self.device)
+        
+        with torch.no_grad():
+            generated_ids = model.generate(
+                pixel_values=inputs.pixel_values,
+                max_length=max_length,
+                num_beams=3,
+                temperature=0.7
+            )
+        
+        caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        return self._clean_caption(caption)
+    
+    def _try_fallback_model(self, image_bytes, max_length):
+        """Try to use a different model if the current one fails"""
+        original_model = self.current_model
+        available_models = list(self.models.keys())
+        
+        for model_name in available_models:
+            if model_name != original_model:
+                print(f"  Trying fallback model: {model_name}")
+                self.current_model = model_name
+                try:
+                    result = self.get_vision_caption(image_bytes, max_length)
+                    if result:
+                        print(f"  ✓ Fallback to {model_name} successful")
+                        return result
+                except Exception as e:
+                    print(f"  ✗ Fallback to {model_name} failed: {e}")
+                    continue
+        
+        # Reset to original model
+        self.current_model = original_model
+        return None
+    
+    def _clean_caption(self, caption):
+        """Clean the caption by removing metadata and markdown"""
+        if not caption:
+            return None
+        
+        # Remove common metadata patterns
+        patterns_to_remove = [
+            r'Photo by\s+\w+',  # Photo by [name]
+            r'©\s+\d{4}\s+\w+',  # Copyright notices
+            r'Image courtesy of\s+\w+',  # Courtesy notices
+            r'Sourced from\s+\w+',  # Source notices
+            r'Image from\s+\w+',  # Image from...
+            r'Source:\s*\w+',  # Source:
+            r'\(Photo credit:.*?\)',  # Photo credit
+            r'\[.*?\]',  # Any bracketed text
+            r'^\w+:\s*',  # "Label: " at start
+            r'\*\*|\*|__|_',  # Markdown markers
+        ]
+        
+        cleaned = caption
+        for pattern in patterns_to_remove:
+            cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
+        
+        # Clean up multiple spaces
+        cleaned = re.sub(r'\s+', ' ', cleaned)
+        
+        # Ensure first letter is capitalized
+        if cleaned and len(cleaned) > 0:
+            cleaned = cleaned[0].upper() + cleaned[1:] if cleaned[1:] else cleaned
+        
+        # Remove any trailing punctuation that looks like metadata
+        cleaned = re.sub(r'\s*[|;:]\s*$', '', cleaned)
+        
+        return cleaned.strip()
+    
+    def analyze_image(self, image_bytes):
+        """
+        Generate a comprehensive, clean analysis of the image.
+        Returns only the image content description, no metadata.
+        """
+        caption = self.get_vision_caption(image_bytes, max_length=120)
+        
+        if caption and len(caption) > 10:
+            # Ensure the description is natural and doesn't mention metadata
+            # Remove any remaining "a photo of", "an image of" patterns
+            caption = re.sub(r'^(a|an)\s+(photo|picture|image)\s+of\s+', '', caption, flags=re.IGNORECASE)
+            return caption
+        
+        return None
+
+
+# Create global instance (lazy initialization)
+_vision_model = None
+
+def get_vision_model():
+    """Get or create the global vision model instance"""
+    global _vision_model
+    if _vision_model is None:
+        _vision_model = VisionModel()
+    return _vision_model