Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Correcting SyntaxError at line 424)
+# main.py (Corrected SyntaxError at line 424 - Now with Gemini 2.0 as primary)
 import os
 import re
 import logging
@@ -65,7 +65,7 @@ logging.getLogger('starlette').setLevel(logging.INFO)
 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}")
-if not _gemini_available: logger.warning("google-generativeai library not found. Gemini fallback disabled.")
+if not _gemini_available: logger.warning("google-generativeai library not found. Gemini functionality disabled.")
 
 
 # --- Global variable for PTB app ---
@@ -80,22 +80,28 @@ def get_secret(secret_name):
     return value
 
 TELEGRAM_TOKEN = get_secret('TELEGRAM_TOKEN')
-OPENROUTER_API_KEY = get_secret('OPENROUTER_API_KEY')
+OPENROUTER_API_KEY = get_secret('OPENROUTER_API_KEY') # Now Fallback
 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')
+GEMINI_API_KEY = get_secret('GEMINI_API_KEY') # Now Primary
 
-OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324:free")
+# Models (User can still configure via env vars)
+OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324:free") # Fallback Model
 APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts")
-GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash")
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash") # Primary Model
 
 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. Primary summarization will fail.")
-_gemini_fallback_enabled = _gemini_available and bool(GEMINI_API_KEY)
-if _gemini_fallback_enabled and not GEMINI_API_KEY: logger.warning("⚠️ WARNING: GEMINI_API_KEY found in env but value seems empty. Fallback disabled.")
-elif not _gemini_fallback_enabled and _gemini_available : logger.warning("⚠️ WARNING: GEMINI_API_KEY not found. Fallback disabled.")
+if not GEMINI_API_KEY: logger.error("❌ ERROR: GEMINI_API_KEY not found. Primary summarization (Gemini) will fail.")
+if not OPENROUTER_API_KEY: logger.warning("⚠️ WARNING: OPENROUTER_API_KEY not found. Fallback summarization will fail.")
+
+_gemini_primary_enabled = _gemini_available and bool(GEMINI_API_KEY)
+if not _gemini_available: logger.warning("⚠️ WARNING: google-generativeai library missing. Gemini disabled.")
+elif not GEMINI_API_KEY: logger.warning("⚠️ WARNING: GEMINI_API_KEY not found or empty. Gemini disabled.")
+
+_openrouter_fallback_enabled = bool(OPENROUTER_API_KEY)
+if not _openrouter_fallback_enabled: logger.warning("⚠️ WARNING: OPENROUTER_API_KEY not found. Fallback disabled.")
 
 
 if not URLTOTEXT_API_KEY: pass
@@ -104,16 +110,15 @@ 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 (Primary): {OPENROUTER_MODEL}")
-if _gemini_fallback_enabled: logger.info(f"Using Gemini Model (Fallback): {GEMINI_MODEL}")
-else: logger.info("Gemini Fallback: Disabled")
+logger.info(f"Using Gemini Model (Primary): {GEMINI_MODEL if _gemini_primary_enabled else 'DISABLED'}")
+logger.info(f"Using OpenRouter Model (Fallback): {OPENROUTER_MODEL if _openrouter_fallback_enabled else 'DISABLED'}")
 logger.info(f"Using Apify Actor (via REST): {APIFY_ACTOR_ID}")
 _apify_token_exists = bool(APIFY_API_TOKEN)
 
 
-if _gemini_fallback_enabled:
+if _gemini_primary_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
+    except Exception as e: logger.error(f"Failed to configure Google GenAI client: {e}"); _gemini_primary_enabled = False
 
 # --- 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 )
@@ -322,12 +327,16 @@ async def get_website_content_via_api(url: str, api_key: str) -> Optional[str]:
     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 Functions ---
-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."); return "Error: Fallback AI service not available."
-    logger.info(f"[Gemini Fallback] Generating {summary_type} summary using {GEMINI_MODEL}. Input length: {len(text)}")
 
+async def _call_gemini(text: str, summary_type: str) -> Tuple[Optional[str], Optional[str]]:
+    """Internal function to call Gemini API. Returns (summary, error_message)."""
+    global GEMINI_MODEL, _gemini_primary_enabled
+    if not _gemini_primary_enabled:
+        logger.error("[Gemini Primary] Called but is disabled.");
+        return None, "Error: Primary AI service (Gemini) not configured/available."
+    logger.info(f"[Gemini Primary] Generating {summary_type} summary using {GEMINI_MODEL}. Input length: {len(text)}")
+
+    # Define prompts (same logic 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: # points summary
         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"
@@ -345,47 +354,74 @@ async def generate_summary_gemini(text: str, summary_type: str) -> str:
                   "• 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 = 1000000
-    if len(text) > MAX_INPUT_LENGTH: logger.warning(f"[Gemini Fallback] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Content truncated)"
+
+    # Input Length Check (Gemini-specific limits if known, otherwise use a large default)
+    MAX_INPUT_LENGTH_GEMINI = 1000000 # Default limit for Gemini
+    if len(text) > MAX_INPUT_LENGTH_GEMINI:
+        logger.warning(f"[Gemini Primary] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH_GEMINI}). Truncating.");
+        text = text[:MAX_INPUT_LENGTH_GEMINI] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
-    # *** FIX: Set all safety settings to BLOCK_NONE ***
+
+    # Safety Settings (Block None)
     safety_settings = {
         HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
         HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
         HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
         HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-        # getattr used for safety in case the category doesn't exist in the SDK version
         getattr(HarmCategory, 'HARM_CATEGORY_CIVIC_INTEGRITY', None): HarmBlockThreshold.BLOCK_NONE
     }
     safety_settings = {k: v for k, v in safety_settings.items() if k is not None}
-    logger.debug(f"[Gemini Fallback] Using safety settings: {safety_settings}")
+    logger.debug(f"[Gemini Primary] Using safety settings: {safety_settings}")
 
     try:
-        logger.debug(f"[Gemini Fallback] Initializing model {GEMINI_MODEL}")
+        logger.debug(f"[Gemini Primary] Initializing model {GEMINI_MODEL}")
         model = genai.GenerativeModel(GEMINI_MODEL)
-        logger.info(f"[Gemini Fallback] Sending request to Gemini ({GEMINI_MODEL})...")
-        request_options = {"timeout": 120}
+        logger.info(f"[Gemini Primary] Sending request to Gemini ({GEMINI_MODEL})...")
+        request_options = {"timeout": 120} # Generous timeout for Gemini
         response = await model.generate_content_async( full_prompt, safety_settings=safety_settings, request_options=request_options )
-        logger.info("[Gemini Fallback] Received response from Gemini.")
-
-        if response.prompt_feedback.block_reason: logger.warning(f"[Gemini Fallback] Request blocked unexpectedly. Reason: {response.prompt_feedback.block_reason}");
-        for cand in response.candidates:
-            if cand.finish_reason == 'SAFETY': logger.warning(f"[Gemini Fallback] Candidate blocked due to SAFETY. Ratings: {cand.safety_ratings}")
-
-        try: summary = response.text
-        except ValueError as e: logger.warning(f"[Gemini Fallback] Error accessing response text (likely blocked content): {e}"); summary = None
+        logger.info("[Gemini Primary] Received response from Gemini.")
 
-        if summary: logger.info(f"[Gemini Fallback] Success generating summary. Output len: {len(summary)}"); return summary.strip().replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
-        else: logger.warning(f"[Gemini Fallback] Gemini returned empty summary or content was blocked. Finish reason: {response.candidates[0].finish_reason if response.candidates else 'N/A'}"); return "Sorry, the fallback AI model did not provide a summary (possibly due to content filters)."
-    except Exception as e: 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."
+        # Check for immediate blocking reasons
+        if response.prompt_feedback.block_reason:
+            logger.warning(f"[Gemini Primary] Request blocked by API. Reason: {response.prompt_feedback.block_reason}");
+            return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) blocked the request (Reason: {response.prompt_feedback.block_reason})."
 
+        # Check candidate-level blocking
+        for cand in response.candidates:
+            if cand.finish_reason == 'SAFETY':
+                logger.warning(f"[Gemini Primary] Candidate blocked due to SAFETY. Ratings: {cand.safety_ratings}")
+                return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) blocked the response due to safety filters."
 
-async def generate_summary(text: str, summary_type: str) -> str:
-    """Generates summary using OpenRouter (Primary) with Gemini fallback on 10s 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."
+        # Try to get text, handle potential ValueError if blocked
+        try:
+            summary = response.text
+        except ValueError as e:
+            logger.warning(f"[Gemini Primary] Error accessing response text (likely blocked content): {e}");
+            summary = None
+
+        if summary:
+            logger.info(f"[Gemini Primary] Success generating summary. Output len: {len(summary)}");
+            # Escape Markdown for Telegram
+            escaped_summary = summary.strip().replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
+            return escaped_summary, None
+        else:
+            finish_reason = response.candidates[0].finish_reason if response.candidates else 'N/A'
+            logger.warning(f"[Gemini Primary] Gemini returned empty summary or content was blocked. Finish reason: {finish_reason}");
+            return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) did not provide a summary (Finish Reason: {finish_reason})."
 
+    except Exception as e:
+        logger.error(f"[Gemini Primary] Unexpected error during Gemini API call: {e}", exc_info=True);
+        return None, f"Sorry, an unexpected error occurred while using the primary AI service ({GEMINI_MODEL})."
+
+async def _call_openrouter(text: str, summary_type: str) -> Tuple[Optional[str], Optional[str]]:
+    """Internal function to call OpenRouter API (Fallback). Returns (summary, error_message)."""
+    global OPENROUTER_API_KEY, OPENROUTER_MODEL, _openrouter_fallback_enabled
+    if not _openrouter_fallback_enabled:
+        logger.error("[OpenRouter Fallback] Called but is disabled.");
+        return None, "Error: Fallback AI service (OpenRouter) not configured/available."
+    logger.info(f"[OpenRouter Fallback] Generating {summary_type} summary using {OPENROUTER_MODEL}. Input length: {len(text)}")
+
+    # Define prompts (same logic 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: # points summary
         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"
@@ -403,57 +439,124 @@ async def generate_summary(text: str, summary_type: str) -> str:
                   "• 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"[Primary Summary] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Content truncated)"
+
+    # Input Length Check (OpenRouter-specific limit)
+    MAX_INPUT_LENGTH_OR = 500000
+    if len(text) > MAX_INPUT_LENGTH_OR:
+        logger.warning(f"[OpenRouter Fallback] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH_OR}). Truncating.");
+        text = text[:MAX_INPUT_LENGTH_OR] + "... (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=10.0, write=15.0, pool=60.0)
+
+    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"
+    # Use reasonable timeouts for fallback
+    api_timeouts = httpx.Timeout(25.0, read=20.0, write=25.0, pool=60.0)
     response = None
 
     try:
         async with httpx.AsyncClient(timeout=api_timeouts) as client:
-            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."
-
-                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"[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."
-                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:
-                    error_info = "";
-                    try: # Correct Indentation
-                        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})."
-
-            except httpx.ReadTimeout:
-                logger.warning(f"[Primary Summary] Read Timeout ({api_timeouts.read}s) waiting for OpenRouter. Attempting Gemini fallback...")
-                if _gemini_fallback_enabled: 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."
-            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."
-
-    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."
+            logger.info(f"[OpenRouter Fallback] 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"[OpenRouter Fallback] Received response from OpenRouter. Status code: {response.status_code}")
+            else: logger.error("[OpenRouter Fallback] No response from OpenRouter (unexpected)."); return None, "Sorry, fallback 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"[OpenRouter Fallback] Success via OpenRouter. Output len: {len(summary)}")
+                                # Escape Markdown for Telegram
+                                escaped_summary = summary.strip().replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
+                                return escaped_summary, None
+                            else:
+                                logger.warning(f"[OpenRouter Fallback] OpenRouter success but content empty. Resp: {data}")
+                                return None, "Sorry, the fallback AI model returned an empty summary."
+                        else:
+                            logger.error(f"[OpenRouter Fallback] Unexpected message structure: {message}. Full: {data}")
+                            return None, "Sorry, could not parse fallback AI response (format)."
+                    else:
+                        logger.error(f"[OpenRouter Fallback] Unexpected choices structure: {data.get('choices')}. Full: {data}")
+                        return None, "Sorry, could not parse fallback AI response (choices)."
+                except json.JSONDecodeError:
+                    logger.error(f"[OpenRouter Fallback] Failed JSON decode OpenRouter. Status:{response.status_code}. Resp:{response.text[:500]}")
+                    return None, "Sorry, failed to understand fallback AI response."
+                except Exception as e:
+                    logger.error(f"[OpenRouter Fallback] Error processing OpenRouter success response: {e}", exc_info=True)
+                    return None, "Sorry, error processing fallback AI response."
+            # Handle specific error codes
+            elif response.status_code == 401: logger.error("[OpenRouter Fallback] API key invalid (401)."); return None, "Error: Fallback AI model configuration key is invalid."
+            elif response.status_code == 402: logger.error("[OpenRouter Fallback] Payment Required (402)."); return None, "Sorry, fallback AI service limits/payment issue."
+            elif response.status_code == 429: logger.warning("[OpenRouter Fallback] Rate Limit Exceeded (429)."); return None, "Sorry, fallback AI model is busy. Try again."
+            elif response.status_code == 500: logger.error(f"[OpenRouter Fallback] Internal Server Error (500). Resp:{response.text[:500]}"); return None, "Sorry, fallback AI service internal error."
+            else:
+                error_info = "";
+                try: error_info = response.json().get("error", {}).get("message", "")
+                except Exception: pass
+                logger.error(f"[OpenRouter Fallback] Unexpected status {response.status_code}. Error: '{error_info}' Resp:{response.text[:500]}");
+                return None, f"Sorry, fallback AI service returned unexpected status ({response.status_code})."
+
+    except httpx.TimeoutException as e:
+        logger.error(f"[OpenRouter Fallback] Timeout error ({type(e)}) connecting/reading from OpenRouter API: {e}")
+        return None, f"Sorry, the fallback AI service ({OPENROUTER_MODEL}) timed out."
+    except httpx.RequestError as e:
+        logger.error(f"[OpenRouter Fallback] Request error connecting to OpenRouter API: {e}")
+        return None, "Sorry, there was an error connecting to the fallback AI model service."
     except Exception as e:
-        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."
+        logger.error(f"[OpenRouter Fallback] Unexpected error during OpenRouter call: {e}", exc_info=True)
+        return None, "Sorry, an unexpected error occurred while using the fallback AI service."
+
+async def generate_summary(text: str, summary_type: str) -> str:
+    """
+    Generates summary using Gemini (Primary) and falls back to OpenRouter if needed.
+    """
+    global _gemini_primary_enabled, _openrouter_fallback_enabled, GEMINI_MODEL, OPENROUTER_MODEL
+    logger.info(f"[Summary Generation] Starting process. Primary: Gemini ({GEMINI_MODEL}), Fallback: OpenRouter ({OPENROUTER_MODEL})")
+
+    final_summary: Optional[str] = None
+    error_message: Optional[str] = None
+
+    # --- Attempt 1: Gemini (Primary) ---
+    if _gemini_primary_enabled:
+        logger.info(f"[Summary Generation] Attempting primary AI: Gemini ({GEMINI_MODEL})")
+        final_summary, error_message = await _call_gemini(text, summary_type)
+        if final_summary:
+            logger.info(f"[Summary Generation] Success with primary AI (Gemini).")
+            return final_summary
+        else:
+            logger.warning(f"[Summary Generation] Primary AI (Gemini) failed or returned unusable result. Error: {error_message}. Proceeding to fallback.")
+    else:
+        logger.warning("[Summary Generation] Primary AI (Gemini) is disabled or unavailable. Proceeding directly to fallback.")
+        error_message = "Primary AI (Gemini) unavailable." # Set initial error message
+
+    # --- Attempt 2: OpenRouter (Fallback) ---
+    if _openrouter_fallback_enabled:
+        logger.info(f"[Summary Generation] Attempting fallback AI: OpenRouter ({OPENROUTER_MODEL})")
+        fallback_summary, fallback_error = await _call_openrouter(text, summary_type)
+        if fallback_summary:
+            logger.info(f"[Summary Generation] Success with fallback AI (OpenRouter).")
+            return fallback_summary
+        else:
+            logger.error(f"[Summary Generation] Fallback AI (OpenRouter) also failed. Error: {fallback_error}")
+            # Combine error messages if possible
+            if error_message: # Keep the primary error if it exists
+                 return f"{error_message} Fallback AI ({OPENROUTER_MODEL}) also failed: {fallback_error}"
+            else: # If primary was skipped
+                 return f"Fallback AI ({OPENROUTER_MODEL}) failed: {fallback_error}"
+    else:
+        logger.error("[Summary Generation] Fallback AI (OpenRouter) is disabled or unavailable. Cannot proceed.")
+        if error_message: # Return the primary error
+            return f"{error_message} Fallback AI is also unavailable."
+        else: # Should not happen if logic is correct, but safeguard
+            return "Error: Both primary and fallback AI services are unavailable."
+
+    # Should ideally not be reached if logic above is sound, but as a final catch
+    logger.error("[Summary Generation] Reached end of function without returning a summary or specific error.")
+    return "Sorry, an unknown error occurred during summary generation after trying all available models."
 
 
 # (process_summary_task, handlers, setup, lifespan, routes, etc. remain the same)
@@ -495,7 +598,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')
-                final_summary = await generate_summary(content, summary_type) # This now handles the fallback internally
+                final_summary = await generate_summary(content, summary_type) # This now calls Gemini first, then OpenRouter
                 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:
                     max_length = 4096; summary_parts = [final_summary[i:i+max_length] for i in range(0, len(final_summary), max_length)]
@@ -565,17 +668,23 @@ 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, GEMINI_API_KEY, OPENROUTER_API_KEY, _gemini_primary_enabled, _openrouter_fallback_enabled
     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:
-        logger.error("OpenRouter key missing!")
-        try: await query.edit_message_text(text="❌ AI config error.")
+    if not _gemini_primary_enabled and not _openrouter_fallback_enabled:
+        logger.critical("Neither Gemini nor OpenRouter API keys are configured/valid!")
+        try: await query.edit_message_text(text="❌ AI config error: No models available.")
         except Exception: pass
         return
+    elif not _gemini_primary_enabled:
+         logger.warning("Primary AI (Gemini) is unavailable, will rely on fallback.")
+         # No need to inform user unless fallback also fails later
+    elif not _openrouter_fallback_enabled:
+         logger.warning("Fallback AI (OpenRouter) is unavailable.")
+         # No need to inform user unless primary fails later
 
     logger.info(f"Scheduling task for user {user.id}, chat {query.message.chat_id}, msg {message_id_to_edit}")
     asyncio.create_task( process_summary_task( user_id=user.id, chat_id=query.message.chat_id, message_id_to_edit=message_id_to_edit, url=url, summary_type=summary_type, bot_token=TELEGRAM_TOKEN ), name=f"SummaryTask-{user.id}-{message_id_to_edit}" )
@@ -639,14 +748,14 @@ async def lifespan(app: Starlette):
         logger.info("ASGI Lifespan: Shutdown complete.")
 
 async def health_check(request: Request) -> PlainTextResponse:
-    global OPENROUTER_MODEL, GEMINI_MODEL, APIFY_ACTOR_ID, _apify_token_exists, _gemini_fallback_enabled
+    global OPENROUTER_MODEL, GEMINI_MODEL, APIFY_ACTOR_ID, _apify_token_exists, _gemini_primary_enabled, _openrouter_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}\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)'}" )
+    return PlainTextResponse( f"TG Bot Summarizer - Status: {bot_status}\n" f"Primary Model: {GEMINI_MODEL if _gemini_primary_enabled else 'N/A (Disabled)'}\n" f"Fallback Model: {OPENROUTER_MODEL if _openrouter_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