Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Correcting SyntaxError at line 201)
+# main.py (Adding Gemini Fallback)
 import os
 import re
 import logging
@@ -40,6 +40,19 @@ try:
 except ImportError:
     DEFAULT_PARSER = 'html.parser'
 
+# --- Google Gemini ---
+try:
+    import google.generativeai as genai
+    from google.generativeai.types import HarmCategory, HarmBlockThreshold
+    _gemini_available = True
+except ImportError:
+    genai = None
+    HarmCategory = None
+    HarmBlockThreshold = None
+    _gemini_available = False
+    logger.warning("google-generativeai library not found. Gemini fallback disabled.")
+
+
 # --- Logging Setup ---
 logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO )
 logging.getLogger("httpx").setLevel(logging.WARNING)
@@ -49,6 +62,8 @@ logging.getLogger("urllib3").setLevel(logging.INFO)
 logging.getLogger('gunicorn.error').setLevel(logging.INFO)
 logging.getLogger('uvicorn').setLevel(logging.INFO)
 logging.getLogger('starlette').setLevel(logging.INFO)
+# Reduce Gemini log noise if needed
+if _gemini_available: logging.getLogger("google.ai.generativelanguage").setLevel(logging.WARNING)
 logger = logging.getLogger(__name__)
 logger.info(f"Logging configured. Using BS4 parser: {DEFAULT_PARSER}")
 
@@ -69,12 +84,19 @@ URLTOTEXT_API_KEY = get_secret('URLTOTEXT_API_KEY')
 SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY')
 APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
 WEBHOOK_SECRET = get_secret('WEBHOOK_SECRET')
+GEMINI_API_KEY = get_secret('GEMINI_API_KEY') # Added Gemini Key
 
+# --- Model Configuration ---
 OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324:free")
-APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts") # Using ~ as per last attempt
+APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts")
+# Use latest flash model, allow override via env var
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash")
 
+# --- Key Checks ---
 if not TELEGRAM_TOKEN: logger.critical("❌ FATAL: TELEGRAM_TOKEN not found."); raise RuntimeError("Exiting: Telegram token missing.")
-if not OPENROUTER_API_KEY: logger.error("❌ ERROR: OPENROUTER_API_KEY not found. Summarization will fail.")
+if not OPENROUTER_API_KEY: logger.error("❌ ERROR: OPENROUTER_API_KEY not found. Primary summarization will fail.")
+# Gemini is a fallback, so only warn if key is missing and library is available
+if _gemini_available and not GEMINI_API_KEY: logger.warning("⚠️ WARNING: GEMINI_API_KEY not found. Fallback summarization via Gemini disabled.")
 
 if not URLTOTEXT_API_KEY: pass
 if not SUPADATA_API_KEY: pass
@@ -82,11 +104,24 @@ if not APIFY_API_TOKEN: pass
 if not WEBHOOK_SECRET: logger.info("Optional secret 'WEBHOOK_SECRET' not found. Webhook security disabled.")
 
 logger.info("Secret loading and configuration check finished.")
-logger.info(f"Using OpenRouter Model: {OPENROUTER_MODEL}")
+logger.info(f"Using OpenRouter Model (Primary): {OPENROUTER_MODEL}")
+if _gemini_available and GEMINI_API_KEY: logger.info(f"Using Gemini Model (Fallback): {GEMINI_MODEL}")
+else: logger.info("Gemini Fallback: Disabled (library or API key missing)")
 logger.info(f"Using Apify Actor (via REST): {APIFY_ACTOR_ID}")
 
 _apify_token_exists = bool(APIFY_API_TOKEN)
+_gemini_fallback_enabled = _gemini_available and bool(GEMINI_API_KEY)
 
+# --- Configure Gemini Client (Do this once globally if possible) ---
+if _gemini_fallback_enabled:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        logger.info("Google GenAI client configured successfully.")
+    except Exception as e:
+        logger.error(f"Failed to configure Google GenAI client: {e}")
+        _gemini_fallback_enabled = False # Disable fallback if config fails
+
+# (Retry Decorator, Helper Functions remain the same)
 # --- Retry Decorator ---
 @retry( stop=stop_after_attempt(4), wait=wait_exponential(multiplier=1, min=2, max=15), retry=retry_if_exception_type((NetworkError, RetryAfter, TimedOut, BadRequest)), before_sleep=before_sleep_log(logger, logging.WARNING), reraise=True )
 async def retry_bot_operation(func, *args, **kwargs):
@@ -108,7 +143,9 @@ def extract_youtube_id(url):
     if match: video_id = match.group(1); logger.debug(f"Extracted YT ID '{video_id}' from {url}"); return video_id
     else: logger.warning(f"Could not extract YT ID from {url}"); return None
 
+
 # --- Content Fetching Functions ---
+# (fetch_url_content_for_scrape, get_transcript_via_supadata, get_transcript_via_apify, get_youtube_transcript, get_website_content, get_website_content_via_api remain the same as previous version)
 async def fetch_url_content_for_scrape(url: str, timeout: int = 25) -> Optional[str]:
     headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.5', 'Connection': 'keep-alive', 'DNT': '1', 'Upgrade-Insecure-Requests': '1' }
     try:
@@ -198,14 +235,8 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
             elif response.status_code == 400: logger.error(f"[Apify SyncItems] Bad Request (400) for {video_url}. Check payload. Resp:{response.text[:200]}"); return None
             elif response.status_code == 401: logger.error("[Apify SyncItems] Auth error (401). Check token."); return None
             elif response.status_code == 404:
-                 # *** FIX: Correct indentation for error info extraction ***
-                 error_info = ""
-                 try:
-                     error_info = response.json().get("error", {}).get("message", "")
-                 except Exception:
-                     pass
-                 logger.error(f"[Apify SyncItems] Endpoint/Actor Not Found (404). Error: '{error_info}' Resp:{response.text[:200]}");
-                 return None
+                 error_info = ""; try: error_info = response.json().get("error", {}).get("message", "") except Exception: pass
+                 logger.error(f"[Apify SyncItems] Endpoint/Actor Not Found (404). Error: '{error_info}' Resp:{response.text[:200]}"); return None
             else: logger.error(f"[Apify SyncItems] Unexpected status {response.status_code} for {video_url}. Resp:{response.text[:200]}"); return None
 
     except httpx.TimeoutException as e: logger.error(f"[Apify SyncItems] Timeout during API interaction for {video_url}: {e}"); return None
@@ -213,8 +244,6 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
     except httpx.RequestError as e: logger.error(f"[Apify SyncItems] Request error during API interaction for {video_url}: {e}"); return None
     except Exception as e: logger.error(f"[Apify SyncItems] Unexpected error during Apify SyncItems REST call for {video_url}: {e}", exc_info=True); return None
 
-
-# (get_youtube_transcript, get_website_content, get_website_content_via_api remain the same)
 async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]:
     global SUPADATA_API_KEY, APIFY_API_TOKEN
     if not video_id: logger.error("get_youtube_transcript: No video_id"); return None
@@ -296,56 +325,138 @@ async def get_website_content_via_api(url: str, api_key: str) -> Optional[str]:
     except httpx.RequestError as e: logger.error(f"[Fallback Web API] Request error connecting to urltotext.com API for {url}: {e}"); return None
     except Exception as e: logger.error(f"[Fallback Web API] Unexpected error during urltotext.com API call for {url}: {e}", exc_info=True); return None
 
-# --- Summarization Function ---
+# --- Summarization Functions ---
+
+# --- NEW: Gemini Summarization Function ---
+async def generate_summary_gemini(text: str, summary_type: str) -> str:
+    """Generates summary using Google Gemini API (Fallback)."""
+    global GEMINI_MODEL, _gemini_fallback_enabled
+    if not _gemini_fallback_enabled:
+        logger.error("[Gemini Fallback] Called but is disabled (no library or key).")
+        return "Error: Fallback AI service not available."
+
+    logger.info(f"[Gemini Fallback] Generating {summary_type} summary using {GEMINI_MODEL}. Input length: {len(text)}")
+
+    # Reuse the same prompts as OpenRouter/DeepSeek for consistency
+    if summary_type == "paragraph": prompt = ("You are an AI model designed to provide concise summaries using British English spellings. Your output MUST be:\n" "• Clear and simple language suitable for someone unfamiliar with the topic.\n" "• Uses British English spellings throughout.\n" "• Straightforward and understandable vocabulary; avoid complex terms.\n" "• Presented as ONE SINGLE PARAGRAPH.\n" "• No more than 85 words maximum; but does not have to be exactly 85.\n" "• Considers the entire text content equally.\n" "• Uses semicolons (;) instead of em dashes (– or —).\n\n" "Here is the text to summarise:")
+    else: prompt = ("You are an AI model designed to provide concise summaries using British English spellings. Your output MUST strictly follow this Markdown format:\n\n" "• For each distinct topic or section identified in the text, create a heading.\n" "• Each heading MUST be enclosed in double asterisks for bolding (e.g., **Section Title**).\n" "• Immediately following each heading, list the key points as a bulleted list.\n" "• Each bullet point MUST start with a hyphen and a space (- ) on a new line.\n" "• The text within each bullet point should NOT contain any bold formatting.\n" "• Use clear, simple, and straightforward language suitable for someone unfamiliar with the topic.\n" "• Use British English spellings throughout.\n" "• Avoid overly complex or advanced vocabulary.\n" "• Keep bullet points concise.\n" "• Ensure the entire summary takes no more than two minutes to read.\n" "• Consider the entire text's content, not just the beginning or a few topics.\n" "• Use semicolons (;) instead of em dashes (– or —).\n\n" "Here is the text to summarise:")
+
+    # Gemini handles large contexts well, but basic truncation is still wise
+    MAX_INPUT_LENGTH = 1000000 # Gemini Flash limit is ~1M tokens
+    if len(text) > MAX_INPUT_LENGTH:
+        logger.warning(f"[Gemini Fallback] Input length ({len(text)}) exceeds assumed limit ({MAX_INPUT_LENGTH}). Truncating.")
+        text = text[:MAX_INPUT_LENGTH] + "... (Content truncated)"
+    full_prompt = f"{prompt}\n\n{text}"
+
+    # Configure safety settings - block potentially harmful content
+    safety_settings = {
+        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    }
+
+    try:
+        logger.debug(f"[Gemini Fallback] Initializing model {GEMINI_MODEL}")
+        model = genai.GenerativeModel(GEMINI_MODEL)
+        logger.info(f"[Gemini Fallback] Sending request to Gemini ({GEMINI_MODEL})...")
+        # Use generate_content_async for non-blocking call
+        response = await model.generate_content_async(
+            full_prompt,
+            safety_settings=safety_settings
+        )
+        logger.info("[Gemini Fallback] Received response from Gemini.")
+
+        # Check for blocks and extract text
+        if response.prompt_feedback.block_reason:
+            logger.error(f"[Gemini Fallback] Request blocked by Gemini. Reason: {response.prompt_feedback.block_reason}")
+            return f"Sorry, the content could not be summarized by the fallback AI due to safety filters ({response.prompt_feedback.block_reason})."
+
+        summary = response.text
+        if summary:
+            logger.info(f"[Gemini Fallback] Success generating summary. Output len: {len(summary)}")
+            # Apply basic markdown escaping if needed (same as OpenRouter func)
+            summary = summary.replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
+            return summary.strip()
+        else:
+            logger.warning(f"[Gemini Fallback] Gemini returned an empty summary. Finish reason: {response.candidates[0].finish_reason if response.candidates else 'N/A'}")
+            return "Sorry, the fallback AI model returned an empty summary."
+
+    except Exception as e:
+        # Catch potential API errors (e.g., google.api_core.exceptions) or others
+        logger.error(f"[Gemini Fallback] Unexpected error during Gemini API call: {e}", exc_info=True)
+        return "Sorry, an unexpected error occurred while using the fallback AI service."
+
+
+# --- MODIFIED: Primary Summarization Function (Adds Fallback Logic) ---
 async def generate_summary(text: str, summary_type: str) -> str:
-    global OPENROUTER_API_KEY, OPENROUTER_MODEL
-    logger.info(f"Generating {summary_type} summary using {OPENROUTER_MODEL}. Input length: {len(text)}")
-    if not OPENROUTER_API_KEY: logger.error("OpenRouter key missing for generate_summary."); return "Error: AI model configuration key missing."
+    """Generates summary using OpenRouter (Primary) with Gemini fallback on ReadTimeout."""
+    global OPENROUTER_API_KEY, OPENROUTER_MODEL, _gemini_fallback_enabled
+    logger.info(f"[Primary Summary] Generating {summary_type} summary using {OPENROUTER_MODEL}. Input length: {len(text)}")
+    if not OPENROUTER_API_KEY: logger.error("[Primary Summary] OpenRouter key missing."); return "Error: AI model configuration key missing."
+
+    # Prompts (same as before)
     if summary_type == "paragraph": prompt = ("You are an AI model designed to provide concise summaries using British English spellings. Your output MUST be:\n" "• Clear and simple language suitable for someone unfamiliar with the topic.\n" "• Uses British English spellings throughout.\n" "• Straightforward and understandable vocabulary; avoid complex terms.\n" "• Presented as ONE SINGLE PARAGRAPH.\n" "• No more than 85 words maximum; but does not have to be exactly 85.\n" "• Considers the entire text content equally.\n" "• Uses semicolons (;) instead of em dashes (– or —).\n\n" "Here is the text to summarise:")
     else: prompt = ("You are an AI model designed to provide concise summaries using British English spellings. Your output MUST strictly follow this Markdown format:\n\n" "• For each distinct topic or section identified in the text, create a heading.\n" "• Each heading MUST be enclosed in double asterisks for bolding (e.g., **Section Title**).\n" "• Immediately following each heading, list the key points as a bulleted list.\n" "• Each bullet point MUST start with a hyphen and a space (- ) on a new line.\n" "• The text within each bullet point should NOT contain any bold formatting.\n" "• Use clear, simple, and straightforward language suitable for someone unfamiliar with the topic.\n" "• Use British English spellings throughout.\n" "• Avoid overly complex or advanced vocabulary.\n" "• Keep bullet points concise.\n" "• Ensure the entire summary takes no more than two minutes to read.\n" "• Consider the entire text's content, not just the beginning or a few topics.\n" "• Use semicolons (;) instead of em dashes (– or —).\n\n" "Here is the text to summarise:")
     MAX_INPUT_LENGTH = 500000
-    if len(text) > MAX_INPUT_LENGTH: logger.warning(f"Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Content truncated)"
+    if len(text) > MAX_INPUT_LENGTH: logger.warning(f"[Primary Summary] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
     headers = { "Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json" }; payload = { "model": OPENROUTER_MODEL, "messages": [{"role": "user", "content": full_prompt}] }; openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
     api_timeouts = httpx.Timeout(15.0, read=180.0, write=15.0, pool=60.0); response = None
+
     try:
+        # --- Attempt OpenRouter Request ---
         async with httpx.AsyncClient(timeout=api_timeouts) as client:
-            logger.info(f"Sending request to OpenRouter ({OPENROUTER_MODEL}) with read timeout {api_timeouts.read}s...")
-            response = await client.post(openrouter_api_endpoint, headers=headers, json=payload)
-            if response: logger.info(f"Received response from OpenRouter. Status code: {response.status_code}")
-            else: logger.error("No response received from OpenRouter after await completed (unexpected)."); return "Sorry, communication with the AI service failed unexpectedly."
-            if response.status_code == 200:
-                try:
-                    data = response.json()
-                    if data.get("choices") and isinstance(data["choices"], list) and len(data["choices"]) > 0:
-                        message = data["choices"][0].get("message")
-                        if message and isinstance(message, dict):
-                            summary = message.get("content")
-                            if summary: logger.info(f"Success generating summary via OpenRouter. Output len: {len(summary)}"); return summary.strip()
-                            else: logger.warning(f"OpenRouter success but content empty. Resp: {data}"); return "Sorry, the AI model returned an empty summary."
-                        else: logger.error(f"Unexpected message structure in OpenRouter resp: {message}. Full: {data}"); return "Sorry, could not parse AI response (format)."
-                    else: logger.error(f"Unexpected choices structure in OpenRouter resp: {data.get('choices')}. Full: {data}"); return "Sorry, could not parse AI response (choices)."
-                except json.JSONDecodeError: logger.error(f"Failed JSON decode OpenRouter. Status:{response.status_code}. Resp:{response.text[:500]}"); return "Sorry, failed to understand AI response."
-                except Exception as e: logger.error(f"Error processing OpenRouter success response: {e}", exc_info=True); return "Sorry, error processing AI response."
-            elif response.status_code == 401: logger.error("OpenRouter API key invalid (401)."); return "Error: AI model configuration key is invalid."
-            elif response.status_code == 402: logger.error("OpenRouter Payment Required (402)."); return "Sorry, AI service limits/payment issue."
-            elif response.status_code == 429: logger.warning("OpenRouter Rate Limit Exceeded (429)."); return "Sorry, AI model is busy. Try again."
-            elif response.status_code == 500: logger.error(f"OpenRouter Internal Server Error (500). Resp:{response.text[:500]}"); return "Sorry, AI service internal error."
-            else:
-                # Corrected Indentation for error info extraction
-                error_info = ""
-                try:
-                    error_info = response.json().get("error", {}).get("message", "")
-                except Exception:
-                    pass
-                logger.error(f"Unexpected status {response.status_code} from OpenRouter. Error: '{error_info}' Resp:{response.text[:500]}");
-                return f"Sorry, AI service returned unexpected status ({response.status_code})."
-    except httpx.ReadTimeout: logger.error(f"Read Timeout error ({api_timeouts.read}s) waiting for OpenRouter API response."); return f"Sorry, the request to the AI model timed out after {api_timeouts.read} seconds while waiting for a response. The content might be too long or the service busy. Please try again later or with shorter content."
-    except httpx.TimeoutException as e: logger.error(f"Timeout error ({type(e)}) connecting to/writing to OpenRouter API: {e}"); return "Sorry, the request to the AI model timed out. Please try again."
-    except httpx.RequestError as e: logger.error(f"Request error connecting to OpenRouter API: {e}"); return "Sorry, there was an error connecting to the AI model service."
+            logger.info(f"[Primary Summary] Sending request to OpenRouter ({OPENROUTER_MODEL}) with read timeout {api_timeouts.read}s...")
+            try:
+                response = await client.post(openrouter_api_endpoint, headers=headers, json=payload)
+                if response: logger.info(f"[Primary Summary] Received response from OpenRouter. Status code: {response.status_code}")
+                else: logger.error("[Primary Summary] No response from OpenRouter (unexpected)."); return "Sorry, primary AI service failed unexpectedly."
+
+                # --- Process OpenRouter Response ---
+                if response.status_code == 200:
+                    try: # Parsing successful response
+                        data = response.json()
+                        if data.get("choices") and isinstance(data["choices"], list) and len(data["choices"]) > 0:
+                            message = data["choices"][0].get("message")
+                            if message and isinstance(message, dict):
+                                summary = message.get("content")
+                                if summary: logger.info(f"[Primary Summary] Success via OpenRouter. Output len: {len(summary)}"); return summary.strip().replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
+                                else: logger.warning(f"[Primary Summary] OpenRouter success but content empty. Resp: {data}"); return "Sorry, the primary AI model returned an empty summary."
+                            else: logger.error(f"[Primary Summary] Unexpected message structure: {message}. Full: {data}"); return "Sorry, could not parse primary AI response (format)."
+                        else: logger.error(f"[Primary Summary] Unexpected choices structure: {data.get('choices')}. Full: {data}"); return "Sorry, could not parse primary AI response (choices)."
+                    except json.JSONDecodeError: logger.error(f"[Primary Summary] Failed JSON decode OpenRouter. Status:{response.status_code}. Resp:{response.text[:500]}"); return "Sorry, failed to understand primary AI response."
+                    except Exception as e: logger.error(f"[Primary Summary] Error processing OpenRouter success response: {e}", exc_info=True); return "Sorry, error processing primary AI response."
+
+                # --- Handle OpenRouter Error Status Codes ---
+                elif response.status_code == 401: logger.error("[Primary Summary] OpenRouter API key invalid (401)."); return "Error: Primary AI model configuration key is invalid."
+                elif response.status_code == 402: logger.error("[Primary Summary] OpenRouter Payment Required (402)."); return "Sorry, primary AI service limits/payment issue."
+                elif response.status_code == 429: logger.warning("[Primary Summary] OpenRouter Rate Limit Exceeded (429)."); return "Sorry, primary AI model is busy. Try again."
+                elif response.status_code == 500: logger.error(f"[Primary Summary] OpenRouter Internal Server Error (500). Resp:{response.text[:500]}"); return "Sorry, primary AI service internal error."
+                else: # Other non-200 errors
+                    error_info = ""; try: error_info = response.json().get("error", {}).get("message", "") except Exception: pass
+                    logger.error(f"[Primary Summary] Unexpected status {response.status_code} from OpenRouter. Error: '{error_info}' Resp:{response.text[:500]}");
+                    return f"Sorry, primary AI service returned unexpected status ({response.status_code})."
+
+            # --- Catch OpenRouter Read Timeout -> Trigger Fallback ---
+            except httpx.ReadTimeout:
+                logger.warning(f"[Primary Summary] Read Timeout ({api_timeouts.read}s) waiting for OpenRouter. Attempting Gemini fallback...")
+                if _gemini_fallback_enabled:
+                    # Call the Gemini function
+                    return await generate_summary_gemini(text, summary_type)
+                else:
+                    logger.error("[Fallback Attempt] Gemini fallback skipped (disabled or key missing).")
+                    return f"Sorry, the primary AI service timed out after {api_timeouts.read} seconds, and the fallback service is not available."
+            # --- Catch Other Timeouts (Connect, Write, Pool) ---
+            except httpx.TimeoutException as e:
+                 logger.error(f"[Primary Summary] Timeout error ({type(e)}) connecting/writing to OpenRouter API: {e}")
+                 return "Sorry, the request to the primary AI model timed out. Please try again."
+
+    # --- Catch Request Errors and Other Exceptions ---
+    except httpx.RequestError as e: logger.error(f"[Primary Summary] Request error connecting to OpenRouter API: {e}"); return "Sorry, there was an error connecting to the primary AI model service."
     except Exception as e:
-        logger.error(f"Unexpected error in generate_summary (OpenRouter request phase): {e}", exc_info=True)
-        if response: logger.error(f"--> Last response status before error: {response.status_code}")
+        logger.error(f"[Primary Summary] Unexpected error in generate_summary (Outer try): {e}", exc_info=True)
+        if response: logger.error(f"--> Last OpenRouter response status before error: {response.status_code}")
         return "Sorry, an unexpected error occurred while trying to generate the summary."
 
 # (process_summary_task, handlers, setup, lifespan, routes, etc. remain the same)
@@ -387,6 +498,7 @@ async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit:
             if content:
                 logger.info(f"[Task {task_id}] Content fetched (len:{len(content)}). Generating summary.")
                 await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')
+                # Call the primary summary function (which now includes the fallback)
                 final_summary = await generate_summary(content, summary_type)
                 if final_summary.startswith("Error:") or final_summary.startswith("Sorry,"): user_feedback_message = final_summary; logger.warning(f"[Task {task_id}] Summary generation failed: {final_summary}")
                 else:
@@ -457,13 +569,13 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
 
     context.user_data.pop('url_to_summarize', None); context.user_data.pop('original_message_id', None); logger.debug(f"Cleared URL context for user {user.id}")
 
-    global TELEGRAM_TOKEN, OPENROUTER_API_KEY
+    global TELEGRAM_TOKEN, OPENROUTER_API_KEY # Check primary keys needed to start task
     if not TELEGRAM_TOKEN:
         logger.critical("TG TOKEN missing!")
         try: await query.edit_message_text(text="❌ Bot config error.")
         except Exception: pass
         return
-    if not OPENROUTER_API_KEY:
+    if not OPENROUTER_API_KEY: # Check primary summarization key
         logger.error("OpenRouter key missing!")
         try: await query.edit_message_text(text="❌ AI config error.")
         except Exception: pass
@@ -531,13 +643,20 @@ async def lifespan(app: Starlette):
         logger.info("ASGI Lifespan: Shutdown complete.")
 
 async def health_check(request: Request) -> PlainTextResponse:
-    global OPENROUTER_MODEL, APIFY_ACTOR_ID, _apify_token_exists; bot_status = "Not Initialized"
+    global OPENROUTER_MODEL, GEMINI_MODEL, APIFY_ACTOR_ID, _apify_token_exists, _gemini_fallback_enabled
+    bot_status = "Not Initialized"
     if ptb_app and ptb_app.bot:
         try:
              if ptb_app.running: bot_info = await ptb_app.bot.get_me(); bot_status = f"Running (@{bot_info.username})"
              else: bot_status = "Initialized/Not running"
         except Exception as e: bot_status = f"Error checking status: {e}"
-    return PlainTextResponse(f"TG Bot Summarizer - Status: {bot_status}\nModel: {OPENROUTER_MODEL}\nApify Actor: {APIFY_ACTOR_ID if _apify_token_exists else 'N/A (No Token)'}")
+    # Updated health check to show both models
+    return PlainTextResponse(
+        f"TG Bot Summarizer - Status: {bot_status}\n"
+        f"Primary Model: {OPENROUTER_MODEL}\n"
+        f"Fallback Model: {GEMINI_MODEL if _gemini_fallback_enabled else 'N/A (Disabled)'}\n"
+        f"Apify Actor: {APIFY_ACTOR_ID if _apify_token_exists else 'N/A (No Token)'}"
+    )
 
 async def telegram_webhook(request: Request) -> Response:
     global WEBHOOK_SECRET