Update main.py

main.py

@@ -5,286 +5,342 @@ import re
 import tempfile
 import time
 from datetime import datetime
+from io import BytesIO
+
+# Third-party imports
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 import pandas as pd
 import pypdf
 import google.generativeai as genai
+from PIL import Image
+
+# specific import for image fallback
+try:
+    from pdf2image import convert_from_path
+    PDF_IMAGE_SUPPORT = True
+except ImportError:
+    PDF_IMAGE_SUPPORT = False
+    logging.warning("pdf2image not installed. Scanned/Encrypted PDF fallback will not work.")
 
 # Setup logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 app = Flask(__name__)
-CORS(app)  # Enable CORS for all routes
+CORS(app)
 
 # Get API key securely
 api_key = os.getenv('Gemini')
 if not api_key:
-    raise ValueError("Gemini API key not found in environment variables")
+    # Fallback for local testing if env var not set, though env var is preferred
+    logging.warning("Gemini API key not found in environment variables.")
 
 def configure_gemini(api_key):
     """Configure Gemini AI model."""
     try:
         genai.configure(api_key=api_key)
+        # Using 2.0 Flash as it has superior vision and long-context capabilities
         return genai.GenerativeModel('gemini-2.0-flash')
     except Exception as e:
         logging.error(f"Error configuring Gemini: {str(e)}")
         raise
 
-def read_pdf_pages(file_path):
-    """Extract text from each page of a PDF file as list of strings."""
-    try:
-        pages = []
-        with open(file_path, 'rb') as f:
-            reader = pypdf.PdfReader(f)
-            for page in reader.pages:
-                text = page.extract_text() or ""
-                pages.append(text)
-        return pages
-    except Exception as e:
-        logging.error(f"Error reading PDF: {str(e)}")
-        raise
+# -------------------------------------------------------------------------
+# PROMPTS
+# -------------------------------------------------------------------------
 
-PROMPT = """Analyze this bank statement and extract transactions in JSON format with these fields:
-- Date (format DD/MM/YYYY)
-- Description
-- Amount (just the integer value)
-- Type (categorize into one of the following based on the transaction nature):
-* 'income' - money received from customers, sales, services rendered
-* 'expense' - operational costs, purchases, payments made
-* 'asset' - purchase of equipment, property, vehicles, or other assets
-* 'liability' - taking on debt, loans received, credit facilities
-* 'equity' - owner investments, capital contributions, retained earnings transfers
-* 'transfer' - money moved between own accounts, internal transfers
-* 'investment' - securities purchases, investment account funding, portfolio additions
-* 'loan_repayment' - paying back borrowed money, loan principal payments
-* 'capital_injection' - owner or investor adding money to the business
-- Customer Name (Only if Type is 'income' and if no name is extracted write 'general income'. For all other types, extract relevant party name or write 'N/A')
-- City (In address of bank statement)
-- Destination_of_funds (categorize based on Type and description):
-* If 'expense': Water and electricity, Salaries and wages, Repairs & Maintenance, Motor vehicle expenses, Projects Expenses, Hardware expenses, Refunds, Accounting fees, Loan interest, Bank charges, Insurance, SARS PAYE UIF, Advertising & Marketing, Logistics and distribution, Fuel, Website hosting fees, Rentals, Subscriptions, Computer internet and Telephone, Staff training, Travel and accommodation, Depreciation, Other expenses
-* If 'income': 'income'
-* If 'asset': Equipment, Property, Vehicles, Technology, Furniture, Other assets
-* If 'liability': Bank loan, Credit facility, Supplier credit, Other liabilities
-* If 'equity': Owner investment, Retained earnings, Share capital, Other equity
-* If 'transfer': Internal transfer
-* If 'investment': Securities, Mutual funds, Fixed deposits, Other investments
-* If 'loan_repayment': Loan repayment
-* If 'capital_injection': Capital injection
-- ignore opening or closing balances.
-- extract the amount in full including decimals.
-Return ONLY the raw JSON object, without any surrounding text, explanations, or markdown fences like ```json.
-
-Return ONLY valid JSON with this structure:
-{
-"transactions": [
+# Enhanced Prompt for General Financial Documents (Statements, Invoices, Receipts)
+# Addresses Point 1 (Rounding/Dates) & Point 3 (Document Types)
+FINANCIAL_DOC_PROMPT = """Analyze this financial document (which could be a Bank Statement, Invoice, Receipt, or Transaction List).
+Extract all relevant transactions/items in JSON format.
+
+RULES:
+1. **Dates**: Extract the date printed on the document. Format as DD/MM/YYYY.
+   - If the year is missing in the row, use the document's context (e.g., header date).
+   - Do NOT use the current date (today) unless the document explicitly says "Today".
+2. **Amounts**: Extract the EXACT amount including decimals. DO NOT ROUND.
+3. **Ignore**: Opening/Closing balances, page numbers, or cumulative running totals.
+
+FIELDS TO EXTRACT:
+- Date: string (DD/MM/YYYY)
+- Description: string (Full description of item/transaction)
+- Amount: number (Float, exact value)
+- Type: string (Categorize exactly as one of: 'income', 'expense', 'asset', 'liability', 'equity', 'transfer', 'investment', 'loan_repayment', 'capital_injection')
+- Customer_name: string (If 'income', name of payer. If 'expense', name of payee/vendor. Else 'N/A')
+- City: string (Extract from address if present, else 'N/A')
+- Document_Type: string (Infer: 'statement', 'invoice', 'receipt', 'transaction_list')
+- Destination_of_funds: string (Categorize based on description. e.g., 'Salaries', 'Fuel', 'Rentals', 'Equipment', etc.)
+
+RETURN STRUCTURE:
 {
-"Date": "string",
-"Description": "string",
-"Customer_name": "string",
-"City": "string",
-"Amount": number,
-"Type": "string",
-"Destination_of_funds": "string"
+  "transactions": [
+    {
+      "Date": "DD/MM/YYYY",
+      "Description": "Item Description",
+      "Customer_name": "Vendor or Payer",
+      "City": "City Name",
+      "Amount": 123.45,
+      "Type": "expense",
+      "Destination_of_funds": "Category",
+      "Document_Type": "invoice"
+    }
+  ]
 }
-]
-}"""
 
-def get_text_prompt_with_date():
-    """Generate TEXT_PROMPT with current date context."""
+Return ONLY raw JSON. No markdown formatting.
+"""
+
+def get_text_prompt_with_fallback_date():
+    """
+    Generate prompt for raw text snippets where context might be missing.
+    Only allows current date fallback for raw text, not PDFs.
+    """
     current_date = datetime.now().strftime("%d/%m/%Y")
-    return f"""IMPORTANT: Today's date is {current_date}. If the user does not specify a date for a transaction, use {current_date} as the default date.
-
-Analyze the following natural language text and extract transactions in JSON format with these fields:
-- Date (format DD/MM/YYYY) - USE {current_date} IF NO DATE IS SPECIFIED
-- Description
-- Amount (just the integer value)
-- Type (categorize into one of the following based on the transaction nature):
-* 'income' - money received from customers, sales, services rendered
-* 'expense' - operational costs, purchases, payments made
-* 'asset' - purchase of equipment, property, vehicles, or other assets
-* 'liability' - taking on debt, loans received, credit facilities
-* 'equity' - owner investments, capital contributions, retained earnings transfers
-* 'transfer' - money moved between own accounts, internal transfers
-* 'investment' - securities purchases, investment account funding, portfolio additions
-* 'loan_repayment' - paying back borrowed money, loan principal payments
-* 'capital_injection' - owner or investor adding money to the business
-- Customer Name (Only if Type is 'income' and if no name is extracted write 'general income'. For all other types, extract relevant party name or write 'N/A')
-- City (extract from any address information provided or write 'N/A' if not available)
-- Destination_of_funds (categorize based on Type and description):
-* If 'expense': Water and electricity, Salaries and wages, Repairs & Maintenance, Motor vehicle expenses, Projects Expenses, Hardware expenses, Refunds, Accounting fees, Loan interest, Bank charges, Insurance, SARS PAYE UIF, Advertising & Marketing, Logistics and distribution, Fuel, Website hosting fees, Rentals, Subscriptions, Computer internet and Telephone, Staff training, Travel and accommodation, Depreciation, Other expenses
-* If 'income': 'income'
-* If 'asset': Equipment, Property, Vehicles, Technology, Furniture, Other assets
-* If 'liability': Bank loan, Credit facility, Supplier credit, Other liabilities
-* If 'equity': Owner investment, Retained earnings, Share capital, Other equity
-* If 'transfer': Internal transfer
-* If 'investment': Securities, Mutual funds, Fixed deposits, Other investments
-* If 'loan_repayment': Loan repayment
-* If 'capital_injection': Capital injection
-- ignore opening or closing balances.
-
-Return ONLY valid JSON with this structure:
-{{
-"transactions": [
-{{
-"Date": "string",
-"Description": "string",
-"Customer_name": "string",
-"City": "string",
-"Amount": number,
-"Type": "string",
-"Destination_of_funds": "string"
-}}
-]
-}}
-important: Return an empty array if no transactions are in the text. Do not make up false data.
+    return f"""IMPORTANT: Today's date is {current_date}.
+If the text below does not specify a year or date, reasonable assume {current_date} context, but prefer explicit dates in text.
+
+{FINANCIAL_DOC_PROMPT}
 """
 
+# -------------------------------------------------------------------------
+# HELPER FUNCTIONS
+# -------------------------------------------------------------------------
+
+def extract_json_from_response(response_text):
+    """Extract valid JSON from Gemini's response, handling Markdown fences."""
+    # Remove markdown code blocks
+    cleaned_text = re.sub(r'```json\s*', '', response_text)
+    cleaned_text = re.sub(r'```\s*', '', cleaned_text)
+    
+    # Find JSON object
+    match = re.search(r'(\{.*\})', cleaned_text, re.DOTALL)
+    if match:
+        json_string = match.group(1)
+    else:
+        # Fallback: assume the whole text is JSON
+        json_string = cleaned_text
+
+    try:
+        return json.loads(json_string)
+    except json.JSONDecodeError:
+        logging.warning("JSON parsing failed, attempting repair.")
+        raise ValueError(json_string) # Pass invalid string to caller for repair
+
 def repair_json_with_gemini(model, broken_json_string):
-    """Makes a second API call to Gemini to fix a broken JSON string."""
-    logging.info("Attempting to repair broken JSON with another Gemini call...")
-    repair_prompt = f"""The following text is a JSON object that is syntactically incorrect. 
-It might have missing commas, brackets, or other errors. 
-Please fix the syntax to make it a valid JSON object. 
-Return ONLY the corrected, raw JSON object and nothing else.
-
-Broken JSON:
-{broken_json_string}
-"""
+    """Uses Gemini to fix broken JSON syntax."""
+    repair_prompt = f"""Fix this broken JSON string. Return ONLY valid JSON.
+    Broken JSON: {broken_json_string}"""
     try:
         resp = model.generate_content(repair_prompt)
-        return resp.text
+        return extract_json_from_response(resp.text)
     except Exception as e:
-        logging.error(f"Error during JSON repair call: {e}")
-        raise ValueError("Failed to repair the JSON string.")
+        logging.error(f"JSON repair failed: {e}")
+        return {"transactions": []} # Fail safe
 
-def call_gemini_with_retry_custom(model, text, prompt, retries=3, backoff_factor=2):
-    """Call Gemini with retries, now with JSON repair logic."""
-    for attempt in range(1, retries + 1):
+def call_gemini_with_retry(model, content, prompt, retries=2):
+    """
+    Generic runner for Gemini.
+    Args:
+        content: Can be a String (text) or a PIL.Image object (vision).
+    """
+    for attempt in range(retries + 1):
         try:
-            resp = model.generate_content([prompt, text])
-            response_text = resp.text
+            # Gemini Python SDK handles [Prompt, Image] or [Prompt, Text] automatically
+            response = model.generate_content([prompt, content])
+            
             try:
-                # First attempt to parse the original response
-                return extract_json_from_response(response_text)
-            except Exception:
-                # If parsing fails, trigger the repair process
-                logging.warning("Initial JSON parsing failed. Attempting repair.")
-                repaired_text = repair_json_with_gemini(model, response_text)
-                return extract_json_from_response(repaired_text) # Parse the repaired text
+                return extract_json_from_response(response.text)
+            except ValueError as ve:
+                # Value error here contains the broken JSON string
+                broken_json = str(ve)
+                return repair_json_with_gemini(model, broken_json)
+                
         except Exception as e:
-            msg = str(e)
-            if '429' in msg or 'RateLimit' in msg and attempt < retries:
-                wait = backoff_factor ** attempt
-                logging.warning(f"Rate limit hit, retrying in {wait}s (attempt {attempt}/{retries})")
-                time.sleep(wait)
-            else:
-                logging.error(f"Error processing with Gemini after retries: {msg}")
+            if "429" in str(e) or "ResourceExhausted" in str(e):
+                time.sleep(2 * (attempt + 1))
+                continue
+            logging.error(f"Gemini Error: {e}")
+            if attempt == retries:
                 raise
 
-def call_gemini_with_retry(model, text, retries=3, backoff_factor=2):
-    """Call Gemini with retries, now with JSON repair logic."""
-    # This function now simply calls the custom one with the default PROMPT
-    return call_gemini_with_retry_custom(model, text, PROMPT, retries, backoff_factor)
+    return {"transactions": []}
 
-def extract_json_from_response(response_text):
-    """Extract valid JSON from Gemini's response, even if it's embedded."""
-    # First, try to find a JSON block enclosed in markdown fences
-    match = re.search(r'```json\s*(\{.*?\})\s*```', response_text, re.DOTALL)
-    if match:
-        json_string = match.group(1)
-    else:
-        # If no markdown, find the first '{' and the last '}'
-        match = re.search(r'{.*}', response_text, re.DOTALL)
-        if not match:
-            raise ValueError("No valid JSON object found in the LLM response")
-        json_string = match.group(0)
+def is_file_empty(file_path):
+    """Check if file is empty."""
+    return os.path.getsize(file_path) == 0
 
-    try:
-        # Clean and load the extracted JSON string
-        return json.loads(json_string)
-    except json.JSONDecodeError as e:
-        logging.error(f"Failed to parse extracted JSON. Error: {e}")
-        logging.error(f"Problematic JSON string was: {json_string}")
-        raise ValueError(f"Could not parse JSON from LLM response: {e}")
+# -------------------------------------------------------------------------
+# CORE LOGIC: PDF PROCESSING (HYBRID TEXT + VISION)
+# -------------------------------------------------------------------------
+
+def process_pdf_page_as_image(model, pdf_path, page_num):
+    """Point 4: Convert specific PDF page to image and process with Vision."""
+    if not PDF_IMAGE_SUPPORT:
+        raise ImportError("pdf2image/poppler not installed")
+
+    # Convert specific page to image
+    # first_page=page_num, last_page=page_num ensures we only convert 1 page at a time to save RAM
+    images = convert_from_path(pdf_path, first_page=page_num, last_page=page_num)
+    if not images:
+        return []
+    
+    # Process the image
+    result = call_gemini_with_retry(model, images[0], FINANCIAL_DOC_PROMPT)
+    return result.get('transactions', [])
 
 @app.route('/process-pdf', methods=['POST'])
 def process_pdf():
-    """Handle PDF upload, process it in page-chunks with Gemini, and aggregate results."""
+    """
+    Smart PDF Processor:
+    1. Checks if empty.
+    2. Tries standard Text extraction (Fast/Cheap).
+    3. If Text fails (Encryption) or is empty (Scanned), falls back to Vision (Slow/Powerful).
+    """
+    temp_path = None
     try:
+        # 1. Validation
         if 'file' not in request.files:
             return jsonify({'error': 'No file uploaded'}), 400
         file = request.files['file']
-        if file.filename == '' or not file.filename.lower().endswith('.pdf'):
-            return jsonify({'error': 'A valid PDF file must be uploaded'}), 400
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
 
-        # Save to temp file
+        # Save Temp
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
             file.save(tmp.name)
-            file_path = tmp.name
+            temp_path = tmp.name
+
+        # Point 2: Empty File Check
+        if is_file_empty(temp_path):
+             return jsonify({'error': 'Uploaded file is empty'}), 400
 
+        model = configure_gemini(api_key)
+        all_transactions = []
+        
+        # Determine strategy: Try reading PDF structure first
         try:
-            model = configure_gemini(api_key)
-            pages = read_pdf_pages(file_path)
-            all_transactions = []
-
-            for idx, page_text in enumerate(pages, start=1):
-                if not page_text.strip():
-                    continue
-                logging.info(f"Processing page {idx}/{len(pages)}")
-                result = call_gemini_with_retry(model, page_text)
+            reader = pypdf.PdfReader(temp_path)
+            num_pages = len(reader.pages)
+            
+            for i in range(num_pages):
+                logging.info(f"Processing page {i+1}/{num_pages}")
+                
+                # Attempt Text Extraction
+                try:
+                    text_content = reader.pages[i].extract_text()
+                except Exception:
+                    text_content = "" # Force fallback if extraction fails
+
+                # LOGIC: Check if text is sufficient. If < 50 chars, it's likely a scan or image-heavy.
+                if text_content and len(text_content.strip()) > 50:
+                    # Strategy A: Text Mode
+                    logging.info("Text detected. Using Text Strategy.")
+                    result = call_gemini_with_retry(model, text_content, FINANCIAL_DOC_PROMPT)
+                else:
+                    # Strategy B: Vision Fallback (Point 4)
+                    logging.info("Low text/Encryption detected. Switching to Vision Strategy.")
+                    if PDF_IMAGE_SUPPORT:
+                        # Page numbers in pypdf are 0-indexed, pdf2image uses 1-based indexing often, 
+                        # but convert_from_path handles slicing via first_page/last_page (1-based)
+                        txs = process_pdf_page_as_image(model, temp_path, i+1)
+                        all_transactions.extend(txs)
+                        continue # Skip the rest of loop
+                    else:
+                        logging.warning("Cannot process scanned PDF - pdf2image missing.")
+                        result = {"transactions": []}
+
                 txs = result.get('transactions', [])
                 all_transactions.extend(txs)
 
-            return jsonify({'transactions': all_transactions})
-        finally:
-            os.remove(file_path)
+        except pypdf.errors.PdfReadError:
+            # If pypdf fails completely (e.g., highly corrupted or weird encryption), try Vision on whole file
+            logging.warning("pypdf failed to read file. Attempting full Vision fallback.")
+            if PDF_IMAGE_SUPPORT:
+                # Warning: Processing all pages as images might be slow
+                images = convert_from_path(temp_path)
+                for img in images:
+                    result = call_gemini_with_retry(model, img, FINANCIAL_DOC_PROMPT)
+                    all_transactions.extend(result.get('transactions', []))
+            else:
+                raise ValueError("PDF is unreadable and Vision fallback is unavailable.")
+
+        return jsonify({'transactions': all_transactions})
 
-    except ValueError as ve:
-        logging.warning(f"Client error: {ve}")
-        return jsonify({'error': str(ve)}), 400
     except Exception as e:
-        logging.error(f"Internal server error: {e}")
-        return jsonify({'error': 'Internal server error'}), 500
+        logging.error(f"Server Error: {e}")
+        return jsonify({'error': str(e)}), 500
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)
+
+# -------------------------------------------------------------------------
+# TEXT & IMAGE ENDPOINTS (UPDATED)
+# -------------------------------------------------------------------------
 
 @app.route('/process-text', methods=['POST'])
 def process_text():
-    """Handle text input and extract transactions using Gemini."""
+    """Handle raw text input."""
     try:
-        # Get JSON data from request
         data = request.get_json()
         if not data or 'text' not in data:
             return jsonify({'error': 'No text provided'}), 400
         
         text_input = data['text']
-        
         if not text_input.strip():
-            return jsonify({'error': 'Text input cannot be empty'}), 400
+            return jsonify({'error': 'Text input cannot be empty'}), 400 # Point 2
         
-        # Configure Gemini model
         model = configure_gemini(api_key)
+        # Use specific prompt with date fallback for raw text
+        prompt = get_text_prompt_with_fallback_date()
         
-        # Generate prompt with current date
-        text_prompt = get_text_prompt_with_date()
+        result = call_gemini_with_retry(model, text_input, prompt)
+        return jsonify({'transactions': result.get('transactions', [])})
         
-        # Process the text with Gemini
-        logging.info("Processing text input for transaction extraction")
-        result = call_gemini_with_retry_custom(model, text_input, text_prompt)
+    except Exception as e:
+        logging.error(f"Error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/process-image', methods=['POST'])
+def process_image():
+    """Handle raw image upload (Receipts, Photos of invoices)."""
+    temp_path = None
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file uploaded'}), 400
+        file = request.files['file']
+        
+        # Point 2: Empty check
+        file.seek(0, os.SEEK_END)
+        size = file.tell()
+        file.seek(0)
+        if size == 0:
+            return jsonify({'error': 'File is empty'}), 400
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as tmp:
+            file.save(tmp.name)
+            temp_path = tmp.name
+
+        model = configure_gemini(api_key)
         
-        transactions = result.get('transactions', [])
+        # Load image with PIL
+        img = Image.open(temp_path)
         
-        return jsonify({'transactions': transactions})
+        # Use the General Financial Prompt
+        result = call_gemini_with_retry(model, img, FINANCIAL_DOC_PROMPT)
         
-    except ValueError as ve:
-        logging.warning(f"Client error: {ve}")
-        return jsonify({'error': str(ve)}), 400
+        return jsonify({'transactions': result.get('transactions', [])})
+    
     except Exception as e:
-        logging.error(f"Internal server error: {e}")
-        return jsonify({'error': 'Internal server error'}), 500
+        logging.error(f"Error: {e}")
+        return jsonify({'error': str(e)}), 500
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)
 
 @app.route('/transaction-types', methods=['GET'])
 def get_transaction_types():
     """Return available transaction types and their categories."""
+    # Kept identical for backwards compatibility
     transaction_types = {
         "types": [
             {
@@ -353,67 +409,15 @@ def get_transaction_types():
     }
     return jsonify(transaction_types)
 
-@app.route('/process-image', methods=['POST'])
-def process_image():
-    """Handle image upload, process it with Gemini Vision, and extract transactions."""
-    try:
-        if 'file' not in request.files:
-            return jsonify({'error': 'No file uploaded'}), 400
-        
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({'error': 'No file selected'}), 400
-        
-        # Check if file is an image
-        allowed_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'}
-        file_ext = os.path.splitext(file.filename)[1].lower()
-        if file_ext not in allowed_extensions:
-            return jsonify({'error': 'Invalid file type. Supported formats: JPG, JPEG, PNG, GIF, BMP, WEBP'}), 400
-        
-        # Save to temp file
-        with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as tmp:
-            file.save(tmp.name)
-            file_path = tmp.name
-        
-        try:
-            model = configure_gemini(api_key)
-            
-            logging.info(f"Processing image file: {file.filename}")
-            
-            # Read image file as bytes
-            import PIL.Image
-            img = PIL.Image.open(file_path)
-            
-            # Generate content with the image and prompt
-            response = model.generate_content([PROMPT, img])
-            
-            # Parse the response
-            result = extract_json_from_response(response.text)
-            transactions = result.get('transactions', [])
-            
-            return jsonify({'transactions': transactions})
-            
-        finally:
-            # Clean up temp file
-            if os.path.exists(file_path):
-                os.remove(file_path)
-    
-    except ValueError as ve:
-        logging.warning(f"Client error: {ve}")
-        return jsonify({'error': str(ve)}), 400
-    except Exception as e:
-        logging.error(f"Internal server error: {e}")
-        return jsonify({'error': 'Internal server error'}), 500
-
-
 @app.route('/health', methods=['GET'])
 def health_check():
-    """Health check endpoint."""
     return jsonify({
         'status': 'healthy',
         'timestamp': datetime.now().isoformat(),
-        'version': '2.0.0'
+        'version': '2.1.0',
+        'vision_support': PDF_IMAGE_SUPPORT
     })
 
 if __name__ == '__main__':
+    # Ensure this port matches your server configuration
     app.run(debug=True, host="0.0.0.0", port=7860)