Update main.py

main.py

@@ -851,73 +851,105 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
     logger.info(f"[Gemini {model_name}] Generating {summary_type} summary using {model_name}. Input length: {len(text)}")
 
     prompt = PROMPT_PARAGRAPH if summary_type == "paragraph" else PROMPT_POINTS
+    # Determine max input length based on model - Flash Preview is likely 1M like Flash 2.0, Pro Exp is 2M
+    # Use a conservative estimate for safety, but larger than Llama/Deepseek
     MAX_INPUT_LENGTH_GEMINI = 900000
+    if 'pro-exp' in model_name.lower(): MAX_INPUT_LENGTH_GEMINI = 1800000 # Higher for Pro
+
     if len(text) > MAX_INPUT_LENGTH_GEMINI:
-        logger.warning(f"[Gemini {model_name}] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH_GEMINI}). Truncating.");
+        logger.warning(f"[Gemini {model_name}] Input length ({len(text)}) exceeds estimated limit ({MAX_INPUT_LENGTH_GEMINI}). Truncating.");
         text = text[:MAX_INPUT_LENGTH_GEMINI] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
 
-    # FIX: Define safety_settings explicitly with the 5 categories from the error log
-    # Removed the problematic loop that dynamically added potentially unsupported categories.
+    # Define safety_settings explicitly with the 5 known categories set to BLOCK_NONE.
+    # This satisfies the requirement "make sure that all safety censors are set to none".
     try:
         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,
-            HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY: HarmBlockThreshold.BLOCK_NONE, # Added based on error msg
+            HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY: HarmBlockThreshold.BLOCK_NONE, # Present in previous code
         }
         logger.debug(f"[Gemini {model_name}] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }")
-    except AttributeError:
-        # Handle case where HarmCategory or HarmBlockThreshold might not be loaded correctly
-        # This shouldn't happen if _gemini_sdk_available is True, but defensive coding
-        logger.error(f"[Gemini {model_name}] Failed to define safety settings. HarmCategory/HarmBlockThreshold missing?")
-        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name})."
+    except (NameError, AttributeError): # Catch if HarmCategory/Threshold are not loaded (SDK issue)
+        logger.error(f"[Gemini {model_name}] Failed to define safety settings. HarmCategory/HarmBlockThreshold missing or SDK not fully available?")
+        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). Safety settings unavailable."
 
     try:
         logger.debug(f"[Gemini {model_name}] Initializing model {model_name}")
         model = genai.GenerativeModel(model_name)
         logger.info(f"[Gemini {model_name}] Sending request to Gemini ({model_name})...")
-        request_options = {"timeout": 120}
+        request_options = {"timeout": 120} # Keep timeout reasonable
         response = await model.generate_content_async(
-             full_prompt, generation_config=genai.types.GenerationConfig(),
+             full_prompt, generation_config=genai.types.GenerationConfig(), # Use default config
              safety_settings=safety_settings, request_options=request_options )
         logger.info(f"[Gemini {model_name}] Received response from Gemini.")
+
+        # Check for prompt blocking first
         if response.prompt_feedback and response.prompt_feedback.block_reason:
             block_reason_str = getattr(response.prompt_feedback.block_reason, 'name', str(response.prompt_feedback.block_reason))
             logger.warning(f"[Gemini {model_name}] Request blocked by API. Reason: {block_reason_str}");
             return None, f"Sorry, the AI model ({model_name}) blocked the request (Reason: {block_reason_str})."
+
         summary = None; finish_reason_str = 'UNKNOWN'
+        # Check candidates for content and safety blocking
         if response.candidates:
             candidate = response.candidates[0]
             finish_reason_name = getattr(candidate.finish_reason, 'name', None)
-            finish_reason_str = finish_reason_name or 'N/A'
+            finish_reason_str = finish_reason_name or 'N/A' # Default if None
+
+            # Check if the *candidate* was blocked by safety
             if finish_reason_name == 'SAFETY':
                 safety_ratings_str = ", ".join([f"{rating.category.name}: {rating.probability.name}" for rating in candidate.safety_ratings])
                 logger.warning(f"[Gemini {model_name}] Candidate blocked due to SAFETY. Finish Reason: {finish_reason_str}. Ratings: [{safety_ratings_str}]")
-                return None, f"Sorry, the AI model ({model_name}) blocked the response due to safety filters ({finish_reason_str})."
-            elif finish_reason_name not in ['STOP', 'MAX_TOKENS', None]:
+                # Provide a more specific error message about response blocking
+                return None, f"Sorry, the AI model ({model_name}) generated a response that was blocked due to safety filters ({finish_reason_str})."
+            elif finish_reason_name not in ['STOP', 'MAX_TOKENS', None]: # Log other unusual finish reasons
                  logger.warning(f"[Gemini {model_name}] Candidate finished with non-standard reason: {finish_reason_str}")
+
+            # Extract content if available
             if candidate.content and candidate.content.parts:
                  summary = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
+
+        # Fallback: try accessing response.text directly (might raise ValueError if blocked)
         if summary is None:
             try: summary = response.text
-            except ValueError as e: logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked): {e}"); summary = None
+            except ValueError as e: logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked/no content): {e}"); summary = None
+            except Exception as e: logger.warning(f"[Gemini {model_name}] Unexpected error accessing response.text: {e}"); summary = None
+
+        # Final check if we got a summary
         if summary:
             logger.info(f"[Gemini {model_name}] Success generating summary. Finish Reason: {finish_reason_str}. Output len: {len(summary)}");
             return summary.strip(), None
         else:
+            # If no summary after checking candidate and response.text, report failure
             logger.warning(f"[Gemini {model_name}] Gemini returned empty summary or content was blocked. Final Finish Reason: {finish_reason_str}");
             return None, f"Sorry, the AI model ({model_name}) did not provide a summary (Finish Reason: {finish_reason_str})."
+
     except AttributeError as ae:
+         # This can happen if the response structure changes or expected fields are missing
          logger.error(f"[Gemini {model_name}] AttributeError during Gemini response processing: {ae}. SDK might be incompatible or response structure unexpected.", exc_info=True);
-         return None, f"Sorry, there was an issue processing the response from the AI service ({model_name})."
+         return None, f"Sorry, there was an issue processing the response from the AI service ({model_name}). Attribute error."
+    except google.api_core.exceptions.InvalidArgument as iae:
+         # Catch specific InvalidArgument, often related to safety settings or model params
+         logger.error(f"[Gemini {model_name}] Invalid Argument error from Gemini API: {iae}", exc_info=False) # Don't need full stack trace often
+         error_detail = str(iae)
+         user_message = f"Sorry, the AI service ({model_name}) reported an invalid argument."
+         if "safety_settings" in error_detail: user_message += " (Safety Settings issue)."
+         elif "temperature" in error_detail: user_message += " (Generation Parameter issue)."
+         return None, user_message
+    except google.api_core.exceptions.GoogleAPIError as gae:
+        # Catch other potential Google API errors (like permission denied, quota exceeded, etc.)
+        logger.error(f"[Gemini {model_name}] Google API error during Gemini call: {gae}", exc_info=False)
+        status_code = getattr(gae, 'code', 'Unknown')
+        user_message = f"Sorry, the AI service ({model_name}) encountered an API error (Code: {status_code})."
+        if status_code == 429: user_message = f"Sorry, the AI model ({model_name}) is busy (Rate Limit/Quota Exceeded). Try again later."
+        elif status_code == 500: user_message = f"Sorry, the AI service ({model_name}) had an internal server error."
+        return None, user_message
     except Exception as e:
+        # General catch-all for unexpected issues
         logger.error(f"[Gemini {model_name}] Unexpected error during Gemini API call: {e}", exc_info=True);
-        # Check if it's the specific InvalidArgument error we were seeing
-        if isinstance(e, google.api_core.exceptions.InvalidArgument) and "safety_settings" in str(e):
-             logger.error(f"[Gemini {model_name}] Safety settings InvalidArgument error persisted: {e}")
-             return None, f"Sorry, the AI service ({model_name}) reported an invalid configuration (Safety Settings). Please report this issue."
         error_msg = f"Sorry, an unexpected error occurred while using the AI service ({model_name})."
         return None, error_msg
 
@@ -984,80 +1016,96 @@ async def _call_openrouter(text: str, summary_type: str) -> Tuple[Optional[str],
 
 async def generate_summary(text: str, summary_type: str) -> str:
     """
-    Generates summary using the specific model hierarchy (April 2025):
-    1. Groq (Llama 4 Scout)
-    2. Gemini (2.5 Pro Exp)
-    3. Gemini (2.0 Flash)
+    Generates summary using the specific model hierarchy (April 2025 - Updated):
+    1. Gemini 2.5 Flash Preview (NEW)
+    2. Gemini 2.5 Pro Exp
+    3. Gemini 2.0 Flash
     4. OpenRouter (DeepSeek V3 Free)
+    5. Groq (Llama 4 Scout)
     Returns the summary text or a comprehensive error message.
     """
-    global _groq_enabled, _gemini_api_enabled, _openrouter_fallback_enabled
-    global GROQ_LLAMA4_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL
+    global _gemini_api_enabled, _openrouter_fallback_enabled, _groq_enabled
+    global GEMINI_FLASH_PREVIEW_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL, GROQ_LLAMA4_MODEL
 
-    logger.info("[Summary Generation] Starting process with specific April 2025 model hierarchy.")
+    logger.info("[Summary Generation] Starting process with updated April 2025 model hierarchy.")
     summary: Optional[str] = None
+    # Use more descriptive keys matching the model variables
     errors: Dict[str, Optional[str]] = {
-        "Llama4Scout": None,
-        "GeminiProExp": None,
-        "GeminiFlash": None,
-        "DeepSeekV3": None,
+        GEMINI_FLASH_PREVIEW_MODEL: None,
+        GEMINI_PRO_EXP_MODEL: None,
+        GEMINI_FLASH_MODEL: None,
+        OPENROUTER_DEEPSEEK_MODEL: None,
+        GROQ_LLAMA4_MODEL: None,
     }
 
-    # --- Attempt 1: Groq (Llama 4 Scout) ---
-    if _groq_enabled:
-        logger.info(f"[Summary Generation] Attempting 1: Groq ({GROQ_LLAMA4_MODEL})")
-        summary, errors["Llama4Scout"] = await _call_groq(text, summary_type)
+    # --- Attempt 1: Gemini 2.5 Flash Preview (NEW) ---
+    if _gemini_api_enabled:
+        logger.info(f"[Summary Generation] Attempting 1: Gemini ({GEMINI_FLASH_PREVIEW_MODEL})")
+        summary, errors[GEMINI_FLASH_PREVIEW_MODEL] = await _call_gemini(text, summary_type, GEMINI_FLASH_PREVIEW_MODEL)
         if summary:
-            logger.info(f"[Summary Generation] Success with Groq ({GROQ_LLAMA4_MODEL}).")
+            logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_FLASH_PREVIEW_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Groq Llama 4 Scout failed. Error: {errors['Llama4Scout']}. Proceeding to Gemini 2.5 Pro Exp.")
+            logger.warning(f"[Summary Generation] Gemini Flash Preview failed. Error: {errors[GEMINI_FLASH_PREVIEW_MODEL]}. Proceeding to Gemini 2.5 Pro Exp.")
     else:
-        logger.warning("[Summary Generation] Groq (Llama 4 Scout) is disabled or unavailable. Skipping.")
-        errors["Llama4Scout"] = "Service disabled/unavailable."
+        logger.warning("[Summary Generation] Gemini API is disabled or unavailable. Skipping all Gemini models.")
+        errors[GEMINI_FLASH_PREVIEW_MODEL] = "Service disabled/unavailable."
+        errors[GEMINI_PRO_EXP_MODEL] = "Service disabled/unavailable."
+        errors[GEMINI_FLASH_MODEL] = "Service disabled/unavailable."
 
     # --- Attempt 2: Gemini 2.5 Pro Exp ---
-    if _gemini_api_enabled:
+    # Only attempt if API is enabled AND the previous step didn't mark it as disabled
+    if _gemini_api_enabled and errors[GEMINI_PRO_EXP_MODEL] is None:
         logger.info(f"[Summary Generation] Attempting 2: Gemini ({GEMINI_PRO_EXP_MODEL})")
-        summary, errors["GeminiProExp"] = await _call_gemini(text, summary_type, GEMINI_PRO_EXP_MODEL)
+        summary, errors[GEMINI_PRO_EXP_MODEL] = await _call_gemini(text, summary_type, GEMINI_PRO_EXP_MODEL)
         if summary:
             logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_PRO_EXP_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Gemini 2.5 Pro Exp failed. Error: {errors['GeminiProExp']}. Proceeding to Gemini 2.0 Flash.")
-    else:
-        logger.warning("[Summary Generation] Gemini API is disabled or unavailable. Skipping Gemini 2.5 Pro Exp & 2.0 Flash.")
-        errors["GeminiProExp"] = "Service disabled/unavailable."
-        errors["GeminiFlash"] = "Service disabled/unavailable."
+            logger.warning(f"[Summary Generation] Gemini 2.5 Pro Exp failed. Error: {errors[GEMINI_PRO_EXP_MODEL]}. Proceeding to Gemini 2.0 Flash.")
+    # No separate 'else' needed here, handled by the initial Gemini API check
 
     # --- Attempt 3: Gemini 2.0 Flash ---
-    if _gemini_api_enabled and errors["GeminiFlash"] is None: # Check if Gemini API is enabled AND wasn't already marked as failed/skipped
+    # Only attempt if API is enabled AND it wasn't marked as disabled earlier
+    if _gemini_api_enabled and errors[GEMINI_FLASH_MODEL] is None:
         logger.info(f"[Summary Generation] Attempting 3: Gemini ({GEMINI_FLASH_MODEL})")
-        summary, errors["GeminiFlash"] = await _call_gemini(text, summary_type, GEMINI_FLASH_MODEL)
+        summary, errors[GEMINI_FLASH_MODEL] = await _call_gemini(text, summary_type, GEMINI_FLASH_MODEL)
         if summary:
             logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_FLASH_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Gemini 2.0 Flash failed. Error: {errors['GeminiFlash']}. Proceeding to OpenRouter DeepSeek V3.")
-    elif errors["GeminiFlash"] is None: # Only log skip message if it wasn't already marked as disabled
-         logger.warning("[Summary Generation] Skipping Gemini 2.0 Flash (API was disabled).")
-         errors["GeminiFlash"] = "Service disabled/unavailable."
+            logger.warning(f"[Summary Generation] Gemini 2.0 Flash failed. Error: {errors[GEMINI_FLASH_MODEL]}. Proceeding to OpenRouter DeepSeek V3.")
+    # No separate 'else' needed here
 
-    # --- Attempt 4: OpenRouter (DeepSeek V3 Free - Final Fallback) ---
+    # --- Attempt 4: OpenRouter (DeepSeek V3 Free) ---
     if _openrouter_fallback_enabled:
         logger.info(f"[Summary Generation] Attempting 4: OpenRouter ({OPENROUTER_DEEPSEEK_MODEL})")
-        summary, errors["DeepSeekV3"] = await _call_openrouter(text, summary_type)
+        summary, errors[OPENROUTER_DEEPSEEK_MODEL] = await _call_openrouter(text, summary_type)
         if summary:
             logger.info(f"[Summary Generation] Success with OpenRouter ({OPENROUTER_DEEPSEEK_MODEL}).")
             return summary
         else:
-            logger.error(f"[Summary Generation] OpenRouter DeepSeek V3 (Final Fallback) also failed. Error: {errors['DeepSeekV3']}")
+            logger.warning(f"[Summary Generation] OpenRouter DeepSeek V3 failed. Error: {errors[OPENROUTER_DEEPSEEK_MODEL]}. Proceeding to Groq Llama 4 Scout.")
+    else:
+        logger.warning("[Summary Generation] OpenRouter fallback (DeepSeek V3) is disabled or unavailable. Skipping.")
+        errors[OPENROUTER_DEEPSEEK_MODEL] = "Service disabled/unavailable."
+
+    # --- Attempt 5: Groq (Llama 4 Scout - Final Fallback) ---
+    if _groq_enabled:
+        logger.info(f"[Summary Generation] Attempting 5: Groq ({GROQ_LLAMA4_MODEL})")
+        summary, errors[GROQ_LLAMA4_MODEL] = await _call_groq(text, summary_type)
+        if summary:
+            logger.info(f"[Summary Generation] Success with Groq ({GROQ_LLAMA4_MODEL}).")
+            return summary
+        else:
+            logger.error(f"[Summary Generation] Groq Llama 4 Scout (Final Fallback) also failed. Error: {errors[GROQ_LLAMA4_MODEL]}")
     else:
-        logger.error("[Summary Generation] OpenRouter fallback (DeepSeek V3) is disabled or unavailable. Cannot proceed.")
-        errors["DeepSeekV3"] = "Service disabled/unavailable."
+        logger.error("[Summary Generation] Groq (Llama 4 Scout) is disabled or unavailable. Cannot proceed.")
+        errors[GROQ_LLAMA4_MODEL] = "Service disabled/unavailable."
 
     # --- All Attempts Failed ---
     logger.error("[Summary Generation] All summarization models failed.")
+    # Use the model names as keys for clearer error reporting
     error_details = "\n".join([f"- {model}: {err}" for model, err in errors.items() if err])
     return f"Sorry, I couldn't generate a summary after trying all available AI models.\nDetails:\n{error_details}"
 
@@ -1219,12 +1267,13 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
     user = update.effective_user
     if not user or not update.message: return
     logger.info(f"User {user.id} ({user.username or 'no_username'}) used /help.")
+    # Updated help text reflecting the new model order
     help_text = ( "🔍 **How to use this bot:**\n\n"
                   "1. Send me any YouTube video link or website URL.\n"
                   "2. I'll ask how you want it summarised (paragraph or points).\n"
                   "3. Click the button for your choice.\n"
                   "4. Wait while I fetch the content and generate the summary!\n\n"
-                  "⚙️ I try multiple methods to get content, especially for tricky websites or YouTube videos without standard transcripts. I then use a sequence of AI models (Llama 4 Scout, Gemini 2.5 Pro, Gemini 2.0 Flash, DeepSeek V3) to summarise.\n\n" # Updated help text
+                  "⚙️ I try multiple methods to get content, especially for tricky websites or YouTube videos without standard transcripts. I then use a sequence of AI models (Gemini 2.5 Flash Preview, Gemini 2.5 Pro, Gemini 2.0 Flash, DeepSeek V3, Llama 4 Scout) to summarise.\n\n" # Updated model list here
                   "**Commands:**\n"
                   "`/start` - Display the welcome message\n"
                   "`/help` - Show this help message" )
@@ -1388,48 +1437,59 @@ async def lifespan(app: Starlette):
 
 async def health_check(request: Request) -> PlainTextResponse:
     """Simple health check endpoint."""
-    global GROQ_LLAMA4_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL
-    global APIFY_ACTOR_ID, APIFY_STRUCTURED_YT_ACTOR_ID # Add new ID here
+    # Include the new model variable
+    global GEMINI_FLASH_PREVIEW_MODEL, GROQ_LLAMA4_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL
+    global APIFY_ACTOR_ID, APIFY_STRUCTURED_YT_ACTOR_ID
     global _groq_enabled, _gemini_api_enabled, _openrouter_fallback_enabled
     global _apify_token_exists, _urltotext_key_exists, _rapidapi_key_exists, SUPADATA_API_KEY
 
-    # ... (rest of the bot status checking logic remains the same) ...
     bot_status = "Not Initialized"; bot_username = "N/A"
     if ptb_app:
         try:
+            # Check if bot is running and get info
             if ptb_app.running:
-                 bot_info = await ptb_app.bot.get_me(); bot_username = f"@{bot_info.username}" if bot_info and bot_info.username else "Info Fetch Error"; bot_status = "Running"
+                 # Wrap get_me in a try-except in case the bot disconnects during check
+                 try:
+                     bot_info = await ptb_app.bot.get_me(); bot_username = f"@{bot_info.username}" if bot_info and bot_info.username else "Info Fetch Error"; bot_status = "Running"
+                 except (TimedOut, NetworkError, TelegramError) as bot_err:
+                     logger.warning(f"Health check: Error getting bot info while running: {bot_err}")
+                     bot_status = "Running (Info Error)"; bot_username = "Fetch Error"
             else:
                  bot_status = "Initialized but Not Running"
+                 # Try getting info even if not 'running' (might be initializing/shutting down)
                  if ptb_app.bot:
                       try: bot_info = await ptb_app.bot.get_me(); bot_username = f"@{bot_info.username}" if bot_info and bot_info.username else "Info Fetch Error"
-                      except Exception: bot_username = "Info Fetch Error (Not Running)"
-        except (TimedOut, NetworkError, Exception) as e:
-             bot_status = f"Error checking status: {type(e).__name__}"; logger.warning(f"Health check: Error getting bot info: {e}")
+                      except (TimedOut, NetworkError, TelegramError) as bot_err:
+                          logger.warning(f"Health check: Error getting bot info while not running: {bot_err}")
+                          bot_username = "Info Fetch Error (Not Running)"
+        except Exception as e: # Catch broader exceptions during status check
+             bot_status = f"Error checking status: {type(e).__name__}"; logger.warning(f"Health check: General error getting bot status: {e}")
+             bot_username = "Error"
     else: bot_status = "Not Initialized"; bot_username = "N/A"
 
 
-    # <<< Update response string with specific model names AND YT Fallback order >>>
+    # <<< Update response string with the new model order >>>
     return PlainTextResponse(
         f"TG Bot Summariser - Status: {bot_status} ({bot_username})\n"
         f"---\n"
-        f"Summarizer Priority (April 2025 - Specific):\n"
-        f"1. Groq API: {GROQ_LLAMA4_MODEL if _groq_enabled else 'DISABLED'}\n"
+        f"Summarizer Priority (April 2025 - Updated):\n"
+        f"1. Gemini API: {GEMINI_FLASH_PREVIEW_MODEL if _gemini_api_enabled else 'DISABLED'} (NEW)\n"
         f"2. Gemini API: {GEMINI_PRO_EXP_MODEL if _gemini_api_enabled else 'DISABLED'}\n"
         f"3. Gemini API: {GEMINI_FLASH_MODEL if _gemini_api_enabled else 'DISABLED'}\n"
         f"4. OpenRouter API: {OPENROUTER_DEEPSEEK_MODEL if _openrouter_fallback_enabled else 'DISABLED'}\n"
+        f"5. Groq API: {GROQ_LLAMA4_MODEL if _groq_enabled else 'DISABLED'} (Last Fallback)\n"
         f"---\n"
         f"Content Fetching Status:\n"
-        # --- Updated YT Fallback List ---
+        # --- YT Fallback List (Order already correct) ---
         f"YT Primary (Lib): Enabled\n"
         f"YT Fallback 1 (Apify Structured): {APIFY_STRUCTURED_YT_ACTOR_ID if _apify_token_exists else 'DISABLED'}\n"
         f"YT Fallback 2 (Supadata): {'Enabled' if SUPADATA_API_KEY else 'Disabled'}\n"
         f"YT Fallback 3 (Apify Default): {APIFY_ACTOR_ID if _apify_token_exists else 'DISABLED'}\n"
-        # --- End Updated List ---
+        # --- Web Scrape Fallback List (Order already correct) ---
         f"Web Scrape 1 (Direct+BS4): Enabled\n"
         f"Web Scrape 2 (urltotext): {'Enabled' if _urltotext_key_exists else 'Disabled'}\n"
         f"Web Scrape 3/4 (RapidAPI): {'Enabled' if _rapidapi_key_exists else 'Disabled'}\n"
-        f"Web Scrape 5/6 (Apify Actors): {'Enabled' if _apify_token_exists else 'Disabled'}" # Web scrape order already updated previously
+        f"Web Scrape 5/6 (Apify Actors): {'Enabled' if _apify_token_exists else 'Disabled'}"
     )
 
 async def telegram_webhook(request: Request) -> Response: