Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Updated for Groq Llama 4, Gemini 2.5 Pro/Flash, DeepSeek hierarchy)
+# main.py (Updated for Specific April 2025 Models: Llama 4 Scout & DeepSeek V3 Free)
 import os
 import re
 import logging
@@ -7,7 +7,7 @@ import json
 import html
 import contextlib
 import traceback
-import urllib.parse # Added for URL encoding
+import urllib.parse
 from typing import Optional, Dict, Any, Tuple
 
 # --- Frameworks ---
@@ -45,15 +45,14 @@ except ImportError:
 try:
     import google.generativeai as genai
     from google.generativeai.types import HarmCategory, HarmBlockThreshold
-    _gemini_sdk_available = True # <<< CHANGE: Renamed flag
+    _gemini_sdk_available = True
 except ImportError:
     genai = None
     HarmCategory = None
     HarmBlockThreshold = None
     _gemini_sdk_available = False
-    # logger will be defined later, log warning after logger setup
 
-# --- Groq SDK --- # <<< CHANGE: Added Groq import
+# --- Groq SDK ---
 try:
     from groq import Groq, GroqError
     _groq_sdk_available = True
@@ -72,11 +71,11 @@ logging.getLogger('gunicorn.error').setLevel(logging.INFO)
 logging.getLogger('uvicorn').setLevel(logging.INFO)
 logging.getLogger('starlette').setLevel(logging.INFO)
 if _gemini_sdk_available: logging.getLogger("google.ai.generativelanguage").setLevel(logging.WARNING)
-if _groq_sdk_available: logging.getLogger("groq").setLevel(logging.INFO) # <<< CHANGE: Add Groq logger config
+if _groq_sdk_available: logging.getLogger("groq").setLevel(logging.INFO)
 logger = logging.getLogger(__name__)
 logger.info(f"Logging configured. Using BS4 parser: {DEFAULT_PARSER}")
 if not _gemini_sdk_available: logger.warning("google-generativeai library not found. Gemini functionality disabled.")
-if not _groq_sdk_available: logger.warning("groq library not found. Groq functionality disabled.") # <<< CHANGE: Log Groq status
+if not _groq_sdk_available: logger.warning("groq library not found. Groq functionality disabled.")
 
 
 # --- Global variable for PTB app ---
@@ -91,27 +90,27 @@ def get_secret(secret_name):
     return value
 
 TELEGRAM_TOKEN = get_secret('TELEGRAM_TOKEN')
-GROQ_API_KEY = get_secret('GROQ_API_KEY')         # <<< CHANGE: Added Groq key
-GEMINI_API_KEY = get_secret('GEMINI_API_KEY')     # Used for Gemini 2.5 Pro and 2.0 Flash
-OPENROUTER_API_KEY = get_secret('OPENROUTER_API_KEY') # Summarizer Fallback 3
-URLTOTEXT_API_KEY = get_secret('URLTOTEXT_API_KEY') # Scrape Fallback 1
-SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY') # YT Fallback 1
-APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')   # YT Fallback 2 + Scrape Fallbacks 4 & 5
-RAPIDAPI_KEY = get_secret('RAPIDAPI_KEY')         # Scrape Fallbacks 2 & 3
+GROQ_API_KEY = get_secret('GROQ_API_KEY')         # For Llama 4
+GEMINI_API_KEY = get_secret('GEMINI_API_KEY')     # For Gemini 2.5 Pro and 2.0 Flash
+OPENROUTER_API_KEY = get_secret('OPENROUTER_API_KEY') # For DeepSeek
+URLTOTEXT_API_KEY = get_secret('URLTOTEXT_API_KEY')
+SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY')
+APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
+RAPIDAPI_KEY = get_secret('RAPIDAPI_KEY')
 WEBHOOK_SECRET = get_secret('WEBHOOK_SECRET')
 
-# <<< CHANGE: Updated Model Configurations >>>
+# <<< CHANGE: Using EXACT Model Identifiers from User Docs >>>
 # Model Priority:
-# 1. Groq Llama 4
-# 2. Gemini 2.5 Pro
+# 1. Groq Llama 4 Scout
+# 2. Gemini 2.5 Pro Exp
 # 3. Gemini 2.0 Flash
-# 4. OpenRouter DeepSeek
-GROQ_LLAMA_MODEL = os.environ.get("GROQ_LLAMA_MODEL", "llama3-70b-8192") # Default to Llama 3 70b on Groq (Llama 4 Scout not available via API yet - Fall 2024)
-GEMINI_PRO_MODEL = os.environ.get("GEMINI_PRO_MODEL", "gemini-1.5-pro-latest") # Gemini 2.5 Pro equivalent (as of Fall 2024)
-GEMINI_FLASH_MODEL = os.environ.get("GEMINI_FLASH_MODEL", "gemini-1.5-flash-latest") # Gemini 2.0 Flash equivalent (as of Fall 2024)
-OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat") # Fallback 3 Model (Updated Deepseek name)
+# 4. OpenRouter DeepSeek V3 Free
+GROQ_LLAMA4_MODEL = os.environ.get("GROQ_LLAMA4_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct") # <<< Specific Llama 4 model
+GEMINI_PRO_EXP_MODEL = os.environ.get("GEMINI_PRO_EXP_MODEL", "gemini-2.5-pro-exp-03-25")
+GEMINI_FLASH_MODEL = os.environ.get("GEMINI_FLASH_MODEL", "gemini-2.0-flash-001")
+OPENROUTER_DEEPSEEK_MODEL = os.environ.get("OPENROUTER_DEEPSEEK_MODEL", "deepseek/deepseek-chat-v3-0324:free") # <<< Specific DeepSeek model
 
-APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts") # Default YT Actor
+APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts") # YT Default
 APIFY_CRAWLER_ACTOR_ID = "apify/website-content-crawler" # Scrape Fallback 4
 APIFY_TEXT_SCRAPER_ACTOR_ID = "karamelo/text-scraper-free" # Scrape Fallback 5
 
@@ -120,23 +119,21 @@ if not TELEGRAM_TOKEN: logger.critical("❌ FATAL: TELEGRAM_TOKEN not found.");
 
 # Summarizer Availability Checks
 _groq_enabled = _groq_sdk_available and bool(GROQ_API_KEY)
-_gemini_api_enabled = _gemini_sdk_available and bool(GEMINI_API_KEY) # <<< CHANGE: Renamed flag
+_gemini_api_enabled = _gemini_sdk_available and bool(GEMINI_API_KEY)
 _openrouter_fallback_enabled = bool(OPENROUTER_API_KEY)
 
 if not _groq_enabled:
-    if not _groq_sdk_available: logger.error("❌ ERROR: groq library missing. Groq (Llama) disabled.")
-    elif not GROQ_API_KEY: logger.error("❌ ERROR: GROQ_API_KEY not found. Primary summarization (Groq Llama) will fail.")
+    if not _groq_sdk_available: logger.error("❌ ERROR: groq library missing. Groq (Llama 4) disabled.")
+    elif not GROQ_API_KEY: logger.error("❌ ERROR: GROQ_API_KEY not found. Primary summarization (Groq Llama 4) will fail.")
 if not _gemini_api_enabled:
     if not _gemini_sdk_available: logger.warning("⚠️ WARNING: google-generativeai library missing. Gemini disabled.")
-    elif not GEMINI_API_KEY: logger.warning("⚠️ WARNING: GEMINI_API_KEY not found. Gemini summarization fallbacks (Pro/Flash) will fail.")
+    elif not GEMINI_API_KEY: logger.warning("⚠️ WARNING: GEMINI_API_KEY not found. Gemini summarization fallbacks (2.5 Pro / 2.0 Flash) will fail.")
 if not _openrouter_fallback_enabled: logger.warning("⚠️ WARNING: OPENROUTER_API_KEY not found. Final fallback summarization (DeepSeek) will fail.")
 
 if not _groq_enabled and not _gemini_api_enabled and not _openrouter_fallback_enabled:
     logger.critical("❌ FATAL: No summarization models are configured or enabled. Bot cannot function.")
-    # Depending on deployment, might want to raise RuntimeError here
-    # raise RuntimeError("No summarization models configured.")
 elif not _groq_enabled:
-    logger.warning("⚠️ Primary summarizer (Groq Llama) is disabled. Will start with Gemini Pro.")
+    logger.warning("⚠️ Primary summarizer (Groq Llama 4) is disabled. Will start with Gemini 2.5 Pro.")
 
 # Scraper Availability Checks (Warnings only)
 if not RAPIDAPI_KEY: logger.warning("⚠️ WARNING: RAPIDAPI_KEY not found. RapidAPI scraping fallbacks (2 & 3) will be unavailable.")
@@ -146,25 +143,25 @@ if not SUPADATA_API_KEY: logger.warning("Optional secret 'SUPADATA_API_KEY' not
 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"Summarizer 1 (Groq): {GROQ_LLAMA_MODEL if _groq_enabled else 'DISABLED'}") # <<< CHANGE
-logger.info(f"Summarizer 2 (Gemini Pro): {GEMINI_PRO_MODEL if _gemini_api_enabled else 'DISABLED'}") # <<< CHANGE
-logger.info(f"Summarizer 3 (Gemini Flash): {GEMINI_FLASH_MODEL if _gemini_api_enabled else 'DISABLED'}") # <<< CHANGE
-logger.info(f"Summarizer 4 (OpenRouter): {OPENROUTER_MODEL if _openrouter_fallback_enabled else 'DISABLED'}") # <<< CHANGE
+logger.info(f"Summarizer 1 (Groq): {GROQ_LLAMA4_MODEL if _groq_enabled else 'DISABLED'}")
+logger.info(f"Summarizer 2 (Gemini Pro Exp): {GEMINI_PRO_EXP_MODEL if _gemini_api_enabled else 'DISABLED'}")
+logger.info(f"Summarizer 3 (Gemini Flash): {GEMINI_FLASH_MODEL if _gemini_api_enabled else 'DISABLED'}")
+logger.info(f"Summarizer 4 (OpenRouter): {OPENROUTER_DEEPSEEK_MODEL if _openrouter_fallback_enabled else 'DISABLED'}")
 logger.info(f"Using Apify Actor (YT Default): {APIFY_ACTOR_ID}")
 logger.info(f"Using Apify Actor (Web Scrape Fallback 4): {APIFY_CRAWLER_ACTOR_ID}")
 logger.info(f"Using Apify Actor (Web Scrape Fallback 5): {APIFY_TEXT_SCRAPER_ACTOR_ID}")
 
-# Flags for scraper key existence (unchanged naming)
+# Flags for scraper key existence
 _apify_token_exists = bool(APIFY_API_TOKEN)
 _urltotext_key_exists = bool(URLTOTEXT_API_KEY)
 _rapidapi_key_exists = bool(RAPIDAPI_KEY)
 
 # --- Configure APIs ---
-if _gemini_api_enabled: # <<< CHANGE: Use renamed flag
+if _gemini_api_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_api_enabled = False
 
-# Groq client is often initialized per-request or within the function call
+# Groq client is initialized per-request in the _call_groq function
 
 # --- 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 )
@@ -187,14 +184,13 @@ 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 ---
 # (These functions: get_transcript_via_supadata, get_transcript_via_apify, get_youtube_transcript,
 # fetch_url_content_for_scrape, get_website_content, get_website_content_via_api,
 # get_website_content_via_scrapers_proxy, get_website_content_via_ai_web_scraper,
 # _run_apify_actor_for_web_content, get_website_content_via_apify_crawler,
 # get_website_content_via_apify_text_scraper remain UNCHANGED. They are omitted here for brevity
-# but should be included in the final main.py file)
+# but MUST be included in the final main.py file)
 # --- START OMITTED CONTENT FETCHING FUNCTIONS ---
 async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[str]:
     if not video_id: logger.error("[Supadata] No video_id provided"); return None
@@ -228,44 +224,30 @@ async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[s
 
 async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[str]:
     """Fallback YT 2: Fetches YouTube transcript using default Apify Actor."""
-    global APIFY_ACTOR_ID # Uses the default YT actor ID
+    global APIFY_ACTOR_ID
     if not video_url: logger.error("[Apify YT] No video_url provided"); return None
     if not api_token: logger.error("[Apify YT] API token missing."); return None
     logger.info(f"[YT Fallback 2] Attempting fetch for URL: {video_url} (Actor: {APIFY_ACTOR_ID})")
-
     sync_items_endpoint = f"https://api.apify.com/v2/acts/{APIFY_ACTOR_ID}/run-sync-get-dataset-items"
     params = {"token": api_token}
-    payload = {
-        "urls": [video_url],
-        "outputFormat": "singleStringText",
-        "maxRetries": 5,
-        "channelHandleBoolean": False,
-        "channelNameBoolean": False,
-        "datePublishedBoolean": False,
-        "relativeDateTextBoolean": False,
-    }
+    payload = { "urls": [video_url], "outputFormat": "singleStringText", "maxRetries": 5, "channelHandleBoolean": False, "channelNameBoolean": False, "datePublishedBoolean": False, "relativeDateTextBoolean": False, }
     headers = {"Content-Type": "application/json"}
-
     try:
-        async with httpx.AsyncClient(timeout=120.0) as client: # Long timeout for potential YT processing
+        async with httpx.AsyncClient(timeout=120.0) as client:
             logger.debug(f"[Apify YT] POST Request to {sync_items_endpoint} for {video_url}")
             response = await client.post(sync_items_endpoint, headers=headers, params=params, json=payload)
             logger.debug(f"[Apify YT] Received status code {response.status_code} for {video_url}")
-
             if response.status_code == 200:
                 try:
                     results = response.json()
                     if isinstance(results, list) and len(results) > 0:
-                        item = results[0]
-                        content = None
-                        # Check common keys for transcript text
+                        item = results[0]; content = None
                         if "captions" in item and isinstance(item["captions"], str): content = item["captions"]
                         elif "text" in item and isinstance(item["text"], str): content = item["text"]
                         elif "transcript" in item and isinstance(item["transcript"], str): content = item["transcript"]
-                        elif "captions" in item and isinstance(item["captions"], list): # Handle list format if needed
+                        elif "captions" in item and isinstance(item["captions"], list):
                              if len(item["captions"]) > 0 and isinstance(item["captions"][0], dict) and 'text' in item["captions"][0]: content = " ".join(line.get("text", "") for line in item["captions"] if line.get("text"))
                              elif len(item["captions"]) > 0 and isinstance(item["captions"][0], str): content = " ".join(item["captions"])
-
                         if content and isinstance(content, str): logger.info(f"[Apify YT] Success via REST for {video_url}. Length: {len(content)}"); return content.strip()
                         else: logger.warning(f"[Apify YT] Dataset item parsed but transcript content empty/invalid format for {video_url}. Item keys: {list(item.keys())}"); return None
                     else: logger.warning(f"[Apify YT] Actor success but dataset was empty for {video_url}. Response: {results}"); return None
@@ -281,11 +263,10 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
     except Exception as e: logger.error(f"[Apify YT] Unexpected error during Apify YT call for {video_url}: {e}", exc_info=True); return None
 
 async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]:
-    global SUPADATA_API_KEY, APIFY_API_TOKEN, _apify_token_exists # <<< Added _apify_token_exists
+    global SUPADATA_API_KEY, APIFY_API_TOKEN, _apify_token_exists
     if not video_id: logger.error("get_youtube_transcript: No video_id"); return None
     logger.info(f"Fetching transcript for video ID: {video_id} (URL: {video_url})")
     transcript_text = None
-    # Method 1: youtube-transcript-api (Primary)
     logger.info("[Primary YT] Attempting youtube-transcript-api...")
     try:
         transcript_list = await asyncio.to_thread( YouTubeTranscriptApi.get_transcript, video_id, languages=['en', 'en-GB', 'en-US'] )
@@ -295,8 +276,6 @@ async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]
     except NoTranscriptFound: logger.warning(f"[Primary YT] No transcript found via lib for {video_id}.")
     except TranscriptsDisabled: logger.warning(f"[Primary YT] Transcripts disabled via lib for {video_id}.")
     except Exception as e: logger.warning(f"[Primary YT] Error via lib for {video_id}: {e}"); transcript_text = None
-
-    # Method 2: Supadata (Fallback 1)
     if transcript_text is None:
         logger.info("[Fallback YT 1] Trying Supadata API...")
         if SUPADATA_API_KEY:
@@ -304,33 +283,26 @@ async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]
             if transcript_text: logger.info(f"[Fallback YT 1] Success via Supadata for {video_id}"); return transcript_text
             else: logger.warning(f"[Fallback YT 1] Supadata failed or no content for {video_id}.")
         else: logger.warning("[Fallback YT 1] Supadata API key unavailable. Skipping.")
-
-    # Method 3: Apify (Fallback 2 - Default YT Actor)
     if transcript_text is None:
         logger.info("[Fallback YT 2] Trying Apify REST API (Default YT Actor)...")
-        if _apify_token_exists: # Use the global flag
+        if _apify_token_exists:
             transcript_text = await get_transcript_via_apify(video_url, APIFY_API_TOKEN)
             if transcript_text: logger.info(f"[Fallback YT 2] Success via Apify Default YT Actor for {video_url}"); return transcript_text
             else: logger.warning(f"[Fallback YT 2] Apify Default YT Actor failed or no content for {video_url}.")
         else: logger.warning("[Fallback YT 2] Apify API token unavailable. Skipping.")
-
-    # Final Result
     if transcript_text is None: logger.error(f"All methods failed for YT transcript: {video_id}"); return None
     return transcript_text
 
 async def fetch_url_content_for_scrape(url: str, timeout: int = 25) -> Optional[str]:
-    """Directly fetches URL content using httpx. (Primary Web Method - Fetching part)"""
     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:
         async with httpx.AsyncClient(follow_redirects=True, timeout=timeout, headers=headers) as client:
             logger.debug(f"[Web Scrape Direct] Sending GET request to {url}")
             response = await client.get(url)
             logger.debug(f"[Web Scrape Direct] Received response {response.status_code} from {url}")
-            response.raise_for_status() # Raise HTTPStatusError for 4xx/5xx
+            response.raise_for_status()
             content_type = response.headers.get('content-type', '').lower()
-            if 'html' not in content_type:
-                logger.warning(f"[Web Scrape Direct] Non-HTML content type received from {url}: {content_type}")
-                return None
+            if 'html' not in content_type: logger.warning(f"[Web Scrape Direct] Non-HTML content type received from {url}: {content_type}"); return None
             try: return response.text
             except Exception as e: logger.error(f"[Web Scrape Direct] Error decoding response text for {url}: {e}"); return None
     except httpx.HTTPStatusError as e: logger.error(f"[Web Scrape Direct] HTTP error {e.response.status_code} fetching {url}: {e}")
@@ -341,19 +313,15 @@ async def fetch_url_content_for_scrape(url: str, timeout: int = 25) -> Optional[
     return None
 
 async def get_website_content(url: str) -> Optional[str]:
-    """Primary method: Fetches HTML directly and parses with BeautifulSoup."""
     if not url: logger.error("[Web Scrape Primary] No URL provided"); return None
     logger.info(f"[Web Scrape Primary] Attempting direct fetch and parse for: {url}")
     html_content = await fetch_url_content_for_scrape(url)
-    if not html_content:
-        logger.warning(f"[Web Scrape Primary] Direct fetch failed for {url}.")
-        return None
+    if not html_content: logger.warning(f"[Web Scrape Primary] Direct fetch failed for {url}."); return None
     try:
         def parse_html(content: str) -> Optional[str]:
             try:
                 soup = BeautifulSoup(content, DEFAULT_PARSER)
-                for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "picture", "source", "map", "area"]):
-                    element.extract()
+                for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "picture", "source", "map", "area"]): element.extract()
                 main_content = soup.find('main') or soup.find('article') or soup.find(role='main') or soup.find(id=re.compile(r'content|main|body', re.I)) or soup.find(class_=re.compile(r'content|main|body|article|post', re.I))
                 target_element = main_content if main_content else soup.body
                 if not target_element: logger.warning(f"[Web Scrape Primary Parse] Could not find body or main content container for {url}"); return None
@@ -368,7 +336,6 @@ async def get_website_content(url: str) -> Optional[str]:
     except Exception as e: logger.error(f"[Web Scrape Primary] Unexpected error during parsing process for {url}: {e}", exc_info=True); return None
 
 async def get_website_content_via_api(url: str, api_key: str) -> Optional[str]:
-    """Fallback 1: Fetches website content using urltotext.com API."""
     if not url: logger.error("[Web Scrape Fallback 1] No URL"); return None
     if not api_key: logger.error("[Web Scrape Fallback 1] urltotext.com API key missing."); return None
     logger.info(f"[Web Scrape Fallback 1] Attempting fetch for: {url} using urltotext.com API")
@@ -396,7 +363,6 @@ async def get_website_content_via_api(url: str, api_key: str) -> Optional[str]:
     except Exception as e: logger.error(f"[Web Scrape Fallback 1] Unexpected error during urltotext.com API call for {url}: {e}", exc_info=True); return None
 
 async def get_website_content_via_scrapers_proxy(url: str, api_key: str) -> Optional[str]:
-    """Fallback 2: Fetches website content using Scraper's Proxy Parser via RapidAPI."""
     if not url: logger.error("[Web Scrape Fallback 2] No URL provided"); return None
     if not api_key: logger.error("[Web Scrape Fallback 2] RapidAPI key missing."); return None
     logger.info(f"[Web Scrape Fallback 2] Attempting fetch for: {url} using Scraper's Proxy Parser API")
@@ -430,7 +396,6 @@ async def get_website_content_via_scrapers_proxy(url: str, api_key: str) -> Opti
     except Exception as e: logger.error(f"[Web Scrape Fallback 2] Unexpected error during {api_host} API call for {url}: {e}", exc_info=True); return None
 
 async def get_website_content_via_ai_web_scraper(url: str, api_key: str) -> Optional[str]:
-    """Fallback 3: Fetches website content using AI Web Scraper via RapidAPI."""
     if not url: logger.error("[Web Scrape Fallback 3] No URL provided"); return None
     if not api_key: logger.error("[Web Scrape Fallback 3] RapidAPI key missing."); return None
     logger.info(f"[Web Scrape Fallback 3] Attempting fetch for: {url} using AI Web Scraper API")
@@ -467,7 +432,6 @@ async def get_website_content_via_ai_web_scraper(url: str, api_key: str) -> Opti
     except Exception as e: logger.error(f"[Web Scrape Fallback 3] Unexpected error during {api_host} API call for {url}: {e}", exc_info=True); return None
 
 async def _run_apify_actor_for_web_content(url: str, api_token: str, actor_id: str, actor_name: str) -> Optional[str]:
-    """Generic function to run an Apify actor and get text content."""
     if not url: logger.error(f"[{actor_name}] No URL provided"); return None
     if not api_token: logger.error(f"[{actor_name}] API token missing."); return None
     logger.info(f"[{actor_name}] Attempting fetch for URL: {url} (Actor: {actor_id})")
@@ -510,16 +474,14 @@ async def _run_apify_actor_for_web_content(url: str, api_token: str, actor_id: s
     except Exception as e: logger.error(f"[{actor_name}] Unexpected error during {actor_name} call for {url}: {e}", exc_info=True); return None
 
 async def get_website_content_via_apify_crawler(url: str, api_token: str) -> Optional[str]:
-    """Fallback 4: Fetches website content using Apify Website Content Crawler."""
     return await _run_apify_actor_for_web_content( url=url, api_token=api_token, actor_id=APIFY_CRAWLER_ACTOR_ID, actor_name="Apify Crawler" )
 
 async def get_website_content_via_apify_text_scraper(url: str, api_token: str) -> Optional[str]:
-    """Fallback 5: Fetches website content using Apify Text Scraper Free."""
     return await _run_apify_actor_for_web_content( url=url, api_token=api_token, actor_id=APIFY_TEXT_SCRAPER_ACTOR_ID, actor_name="Apify Text Scraper" )
 # --- END OMITTED CONTENT FETCHING FUNCTIONS ---
 
 
-# --- Summarization Functions (REVISED SECTION) ---
+# --- Summarization Functions (Using Specific April 2025 Models) ---
 
 # --- Prompts (Defined once, used by all models) ---
 PROMPT_PARAGRAPH = (
@@ -554,38 +516,33 @@ PROMPT_POINTS = (
     "Here is the text to summarise:"
 )
 
-# <<< CHANGE: New function for Groq API Call >>>
+# <<< Uses the specific GROQ_LLAMA4_MODEL constant >>>
 async def _call_groq(text: str, summary_type: str) -> Tuple[Optional[str], Optional[str]]:
-    """Internal function to call Groq API (Primary). Returns (summary, error_message)."""
-    global GROQ_API_KEY, GROQ_LLAMA_MODEL, _groq_enabled
+    """Internal function to call Groq API (Primary - Llama 4 Scout). Returns (summary, error_message)."""
+    global GROQ_API_KEY, GROQ_LLAMA4_MODEL, _groq_enabled
     if not _groq_enabled:
         logger.error("[Groq Primary] Called but is disabled.");
-        return None, "Error: Primary AI service (Groq Llama) not configured/available."
-    logger.info(f"[Groq Primary] Generating {summary_type} summary using {GROQ_LLAMA_MODEL}. Input length: {len(text)}")
+        return None, f"Error: Primary AI service (Groq {GROQ_LLAMA4_MODEL}) not configured/available."
+    logger.info(f"[Groq Primary] Generating {summary_type} summary using {GROQ_LLAMA4_MODEL}. Input length: {len(text)}")
 
     prompt = PROMPT_PARAGRAPH if summary_type == "paragraph" else PROMPT_POINTS
 
-    # Input Length Check (Llama 3 70b on Groq supports 8192 tokens - text length is a rough proxy)
-    # Let's be conservative, ~3 chars per token -> ~24k chars. Use 20k for safety margin.
-    MAX_INPUT_LENGTH_GROQ = 20000
+    # Input Length Check for Llama 4 Scout (16k context? Be conservative)
+    MAX_INPUT_LENGTH_GROQ = 40000 # ~13k tokens
     if len(text) > MAX_INPUT_LENGTH_GROQ:
         logger.warning(f"[Groq Primary] Input length ({len(text)}) exceeds estimated limit ({MAX_INPUT_LENGTH_GROQ}). Truncating.");
         text = text[:MAX_INPUT_LENGTH_GROQ] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
 
     try:
-        # Initialize client within the function with timeout
-        groq_client = Groq(
-            api_key=GROQ_API_KEY,
-            timeout=httpx.Timeout(120.0, connect=10.0) # 120s read timeout, 10s connect
-        )
-        logger.info(f"[Groq Primary] Sending request to Groq ({GROQ_LLAMA_MODEL})...")
+        groq_client = Groq( api_key=GROQ_API_KEY, timeout=httpx.Timeout(120.0, connect=10.0) )
+        logger.info(f"[Groq Primary] Sending request to Groq ({GROQ_LLAMA4_MODEL})...")
 
         chat_completion = await groq_client.chat.completions.create(
             messages=[ { "role": "user", "content": full_prompt } ],
-            model=GROQ_LLAMA_MODEL,
-            temperature=0.7, # Adjust temperature as needed (0.5-0.8 is often good for summaries)
-            max_tokens=2048, # Max tokens for the *output* summary
+            model=GROQ_LLAMA4_MODEL, # <<< Use specific Llama 4 model name
+            temperature=0.7, # <<< Groq default is 1, adjust if needed
+            max_tokens=2048, # <<< Groq default is 1024, adjust if needed for longer summaries
             top_p=1,
             stream=False,
             stop=None,
@@ -598,30 +555,27 @@ async def _call_groq(text: str, summary_type: str) -> Tuple[Optional[str], Optio
             logger.info(f"[Groq Primary] Success generating summary. Finish Reason: {finish_reason}. Output len: {len(summary)}");
             return summary.strip(), None
         else:
-            # Handle cases where response structure is unexpected or content is empty
             logger.warning(f"[Groq Primary] Groq response structure unexpected or content empty. Response: {chat_completion.model_dump_json(indent=2)}")
             finish_reason = chat_completion.choices[0].finish_reason if chat_completion.choices else 'N/A'
-            return None, f"Sorry, the primary AI model ({GROQ_LLAMA_MODEL}) provided an empty or invalid response (Finish Reason: {finish_reason})."
+            return None, f"Sorry, the primary AI model ({GROQ_LLAMA4_MODEL}) provided an empty or invalid response (Finish Reason: {finish_reason})."
 
     except GroqError as ge:
-         # Handle API-specific errors (rate limits, auth issues etc.)
-         logger.error(f"[Groq Primary] Groq API error: {ge.status_code} - {ge.message}", exc_info=False) # Keep log cleaner for common errors
-         error_msg = f"Sorry, the primary AI service ({GROQ_LLAMA_MODEL}) failed. API Error: {ge.status_code}."
-         if ge.status_code == 401: error_msg = "Error: Primary AI service (Groq) API key is invalid."
-         elif ge.status_code == 429: error_msg = f"Sorry, primary AI model ({GROQ_LLAMA_MODEL}) is busy (Rate Limit). Try again."
+         logger.error(f"[Groq Primary] Groq API error: {ge.status_code} - {ge.message}", exc_info=False)
+         error_msg = f"Sorry, the primary AI service ({GROQ_LLAMA4_MODEL}) failed. API Error: {ge.status_code}."
+         if ge.status_code == 401: error_msg = f"Error: Primary AI service (Groq {GROQ_LLAMA4_MODEL}) API key is invalid."
+         elif ge.status_code == 429: error_msg = f"Sorry, primary AI model ({GROQ_LLAMA4_MODEL}) is busy (Rate Limit). Try again."
          return None, error_msg
     except httpx.TimeoutException as te:
          logger.error(f"[Groq Primary] Timeout during Groq API call: {te}")
-         return None, f"Sorry, the primary AI service ({GROQ_LLAMA_MODEL}) timed out."
+         return None, f"Sorry, the primary AI service ({GROQ_LLAMA4_MODEL}) timed out."
     except httpx.RequestError as re:
          logger.error(f"[Groq Primary] Network error during Groq API call: {re}")
-         return None, f"Sorry, couldn't connect to the primary AI service ({GROQ_LLAMA_MODEL})."
+         return None, f"Sorry, couldn't connect to the primary AI service ({GROQ_LLAMA4_MODEL})."
     except Exception as e:
         logger.error(f"[Groq Primary] Unexpected error during Groq API call: {e}", exc_info=True);
-        return None, f"Sorry, an unexpected error occurred while using the primary AI service ({GROQ_LLAMA_MODEL})."
+        return None, f"Sorry, an unexpected error occurred while using the primary AI service ({GROQ_LLAMA4_MODEL})."
 
 
-# <<< CHANGE: Modified function to accept model_name >>>
 async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[Optional[str], Optional[str]]:
     """Internal function to call Gemini API. Returns (summary, error_message)."""
     global _gemini_api_enabled
@@ -631,22 +585,15 @@ 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
-
-    # Input Length Check (Gemini 1.5 has large context, but let's keep a practical limit)
-    MAX_INPUT_LENGTH_GEMINI = 900000 # Keep previous limit, seems reasonable
+    MAX_INPUT_LENGTH_GEMINI = 900000
     if len(text) > MAX_INPUT_LENGTH_GEMINI:
         logger.warning(f"[Gemini {model_name}] 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}"
-
-    # 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, }
-    # <<< CHANGE: Removed specific check for CIVIC_INTEGRITY, rely on hasattr instead >>>
-    # Handle potential new categories gracefully
     for category_name in dir(HarmCategory):
         if category_name.startswith('HARM_CATEGORY_') and getattr(HarmCategory, category_name) not in safety_settings:
             safety_settings[getattr(HarmCategory, category_name)] = HarmBlockThreshold.BLOCK_NONE
-
     logger.debug(f"[Gemini {model_name}] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }")
 
     try:
@@ -655,89 +602,77 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
         logger.info(f"[Gemini {model_name}] Sending request to Gemini ({model_name})...")
         request_options = {"timeout": 120}
         response = await model.generate_content_async(
-             full_prompt,
-             generation_config=genai.types.GenerationConfig(), # Basic config
-             safety_settings=safety_settings,
-             request_options=request_options
-        )
+             full_prompt, generation_config=genai.types.GenerationConfig(),
+             safety_settings=safety_settings, request_options=request_options )
         logger.info(f"[Gemini {model_name}] Received response from Gemini.")
-
-        # Check for immediate blocking reasons
         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})."
-
-        # Check candidate-level blocking and extract text safely
-        summary = None
-        finish_reason_str = 'UNKNOWN'
+        summary = None; finish_reason_str = 'UNKNOWN'
         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'
-
             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]:
                  logger.warning(f"[Gemini {model_name}] Candidate finished with non-standard reason: {finish_reason_str}")
-
-            # Safely access content text
             if candidate.content and candidate.content.parts:
                  summary = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
-
-        # Fallback check via response.text
         if summary is None:
             try: summary = response.text
-            except ValueError as e: logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked content based on previous checks): {e}"); summary = None
-
+            except ValueError as e: logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked): {e}"); summary = None
         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:
             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:
          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})."
     except Exception as e:
         logger.error(f"[Gemini {model_name}] Unexpected error during Gemini API call: {e}", exc_info=True);
-        # Check for specific Gemini API errors if possible (e.g., AuthenticationFailed, RateLimitExceeded)
-        # This might require inspecting the error details or type.
         error_msg = f"Sorry, an unexpected error occurred while using the AI service ({model_name})."
-        # Example: if "API key not valid" in str(e): error_msg = "Error: AI service (Gemini) API key is invalid."
         return None, error_msg
 
-
-# <<< CHANGE: Function remains the same, but is now the last fallback >>>
+# <<< Uses the specific OPENROUTER_DEEPSEEK_MODEL constant >>>
 async def _call_openrouter(text: str, summary_type: str) -> Tuple[Optional[str], Optional[str]]:
-    """Internal function to call OpenRouter API (Final Fallback). Returns (summary, error_message)."""
-    global OPENROUTER_API_KEY, OPENROUTER_MODEL, _openrouter_fallback_enabled
+    """Internal function to call OpenRouter API (Final Fallback - DeepSeek V3 Free). Returns (summary, error_message)."""
+    global OPENROUTER_API_KEY, OPENROUTER_DEEPSEEK_MODEL, _openrouter_fallback_enabled
     if not _openrouter_fallback_enabled:
         logger.error("[OpenRouter Fallback] Called but is disabled.");
         return None, "Error: Final fallback AI service (OpenRouter) not configured/available."
-    logger.info(f"[OpenRouter Fallback] Generating {summary_type} summary using {OPENROUTER_MODEL}. Input length: {len(text)}")
+    logger.info(f"[OpenRouter Fallback] Generating {summary_type} summary using {OPENROUTER_DEEPSEEK_MODEL}. Input length: {len(text)}")
 
     prompt = PROMPT_PARAGRAPH if summary_type == "paragraph" else PROMPT_POINTS
-
-    # Input Length Check (Adjust if DeepSeek model limit is known, 100k is generous)
-    MAX_INPUT_LENGTH_OR = 100000
+    MAX_INPUT_LENGTH_OR = 100000 # DeepSeek V3 has 131k context, 100k chars is safe
     if len(text) > MAX_INPUT_LENGTH_OR:
-        logger.warning(f"[OpenRouter Fallback] Input length ({len(text)}) exceeds estimated limit ({MAX_INPUT_LENGTH_OR}) for {OPENROUTER_MODEL}. Truncating.");
+        logger.warning(f"[OpenRouter Fallback] Input length ({len(text)}) exceeds estimated limit ({MAX_INPUT_LENGTH_OR}) for {OPENROUTER_DEEPSEEK_MODEL}. 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", "HTTP-Referer": "https://github.com/your-repo", "X-Title": "TelegramSummariserBot" }
-    payload = { "model": OPENROUTER_MODEL, "messages": [{"role": "user", "content": full_prompt}], }
+    # Use the direct httpx call as before, ensuring the correct model name is in the payload
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": os.environ.get("YOUR_SITE_URL", "https://github.com/your-repo"), # Optional header
+        "X-Title": os.environ.get("YOUR_SITE_NAME", "TelegramSummariserBot") # Optional header
+        }
+    payload = {
+        "model": OPENROUTER_DEEPSEEK_MODEL, # <<< Use specific DeepSeek model name
+        "messages": [{"role": "user", "content": full_prompt}],
+        }
     openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
-    api_timeouts = httpx.Timeout(connect=10.0, read=60.0, write=10.0, pool=60.0) # Slightly longer read timeout for fallback
+    api_timeouts = httpx.Timeout(connect=10.0, read=60.0, write=10.0, pool=60.0)
     response = None
 
     try:
         async with httpx.AsyncClient(timeout=api_timeouts) as client:
-            logger.info(f"[OpenRouter Fallback] Sending request to OpenRouter ({OPENROUTER_MODEL}) with read timeout {api_timeouts.read}s...")
+            logger.info(f"[OpenRouter Fallback] Sending request to OpenRouter ({OPENROUTER_DEEPSEEK_MODEL}) with read timeout {api_timeouts.read}s...")
             response = await client.post(openrouter_api_endpoint, headers=headers, json=payload)
             logger.info(f"[OpenRouter Fallback] Received response from OpenRouter. Status code: {response.status_code}")
 
@@ -749,116 +684,112 @@ async def _call_openrouter(text: str, summary_type: str) -> Tuple[Optional[str],
                         if message and isinstance(message, dict):
                             summary = message.get("content")
                             if summary: logger.info(f"[OpenRouter Fallback] Success via OpenRouter. Finish: {finish_reason}. Output len: {len(summary)}"); return summary.strip(), None
-                            else: logger.warning(f"[OpenRouter Fallback] OpenRouter success but content empty. Finish: {finish_reason}. Resp: {data}"); return None, f"Sorry, the fallback AI model ({OPENROUTER_MODEL}) returned an empty summary (Finish: {finish_reason})."
+                            else: logger.warning(f"[OpenRouter Fallback] OpenRouter success but content empty. Finish: {finish_reason}. Resp: {data}"); return None, f"Sorry, the fallback AI model ({OPENROUTER_DEEPSEEK_MODEL}) returned an empty summary (Finish: {finish_reason})."
                         else: logger.error(f"[OpenRouter Fallback] Unexpected message structure: {message}. Finish: {finish_reason}. Full: {data}"); return None, "Sorry, could not parse fallback AI response (message format)."
                     else:
                         error_details = data.get("error", {}); logger.error(f"[OpenRouter Fallback] Unexpected choices structure or error in response: {data.get('choices')}. Error: {error_details}. Full: {data}");
                         return None, f"Sorry, could not parse fallback AI response (choices structure or error: {error_details.get('message', 'Unknown')})."
                 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."
-            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/Quota Exceeded (402)."); return None, f"Sorry, fallback AI service ({OPENROUTER_MODEL}) quota/limit issue."
-            elif response.status_code == 429: logger.warning("[OpenRouter Fallback] Rate Limit Exceeded (429)."); return None, f"Sorry, fallback AI model ({OPENROUTER_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, f"Sorry, fallback AI service ({OPENROUTER_MODEL}) had an internal error."
+            elif response.status_code == 401: logger.error("[OpenRouter Fallback] API key invalid (401)."); return None, f"Error: Fallback AI model ({OPENROUTER_DEEPSEEK_MODEL}) configuration key is invalid."
+            elif response.status_code == 402: logger.error("[OpenRouter Fallback] Payment Required/Quota Exceeded (402)."); return None, f"Sorry, fallback AI service ({OPENROUTER_DEEPSEEK_MODEL}) quota/limit issue."
+            elif response.status_code == 429: logger.warning("[OpenRouter Fallback] Rate Limit Exceeded (429)."); return None, f"Sorry, fallback AI model ({OPENROUTER_DEEPSEEK_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, f"Sorry, fallback AI service ({OPENROUTER_DEEPSEEK_MODEL}) had an 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 ({OPENROUTER_MODEL}) returned unexpected status ({response.status_code})."
+                return None, f"Sorry, fallback AI service ({OPENROUTER_DEEPSEEK_MODEL}) 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.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_DEEPSEEK_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"[OpenRouter Fallback] Unexpected error during OpenRouter call: {e}", exc_info=True); return None, "Sorry, an unexpected error occurred while using the fallback AI service."
 
 
-# <<< CHANGE: Rewritten function for new model hierarchy >>>
 async def generate_summary(text: str, summary_type: str) -> str:
     """
-    Generates summary using the defined model hierarchy:
-    1. Groq (Llama 4/3)
-    2. Gemini (2.5 Pro)
+    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)
-    4. OpenRouter (DeepSeek)
+    4. OpenRouter (DeepSeek V3 Free)
     Returns the summary text or a comprehensive error message.
     """
     global _groq_enabled, _gemini_api_enabled, _openrouter_fallback_enabled
-    global GROQ_LLAMA_MODEL, GEMINI_PRO_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_MODEL
+    global GROQ_LLAMA4_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL
 
-    logger.info("[Summary Generation] Starting process with new model hierarchy.")
+    logger.info("[Summary Generation] Starting process with specific April 2025 model hierarchy.")
     summary: Optional[str] = None
-    errors: Dict[str, Optional[str]] = { # Store errors from each step
-        "Groq": None,
-        "GeminiPro": None,
+    errors: Dict[str, Optional[str]] = {
+        "Llama4Scout": None, # <<< Use more descriptive keys
+        "GeminiProExp": None,
         "GeminiFlash": None,
-        "OpenRouter": None,
+        "DeepSeekV3": None,
     }
 
-    # --- Attempt 1: Groq (Primary) ---
+    # --- Attempt 1: Groq (Llama 4 Scout) ---
     if _groq_enabled:
-        logger.info(f"[Summary Generation] Attempting 1: Groq ({GROQ_LLAMA_MODEL})")
-        summary, errors["Groq"] = await _call_groq(text, summary_type)
+        logger.info(f"[Summary Generation] Attempting 1: Groq ({GROQ_LLAMA4_MODEL})")
+        summary, errors["Llama4Scout"] = await _call_groq(text, summary_type)
         if summary:
-            logger.info(f"[Summary Generation] Success with Groq ({GROQ_LLAMA_MODEL}).")
+            logger.info(f"[Summary Generation] Success with Groq ({GROQ_LLAMA4_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Groq failed. Error: {errors['Groq']}. Proceeding to Gemini Pro.")
+            logger.warning(f"[Summary Generation] Groq Llama 4 Scout failed. Error: {errors['Llama4Scout']}. Proceeding to Gemini 2.5 Pro Exp.")
     else:
-        logger.warning("[Summary Generation] Groq is disabled or unavailable. Skipping.")
-        errors["Groq"] = "Service disabled/unavailable."
+        logger.warning("[Summary Generation] Groq (Llama 4 Scout) is disabled or unavailable. Skipping.")
+        errors["Llama4Scout"] = "Service disabled/unavailable."
 
-    # --- Attempt 2: Gemini 2.5 Pro ---
+    # --- Attempt 2: Gemini 2.5 Pro Exp ---
     if _gemini_api_enabled:
-        logger.info(f"[Summary Generation] Attempting 2: Gemini ({GEMINI_PRO_MODEL})")
-        summary, errors["GeminiPro"] = await _call_gemini(text, summary_type, GEMINI_PRO_MODEL)
+        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)
         if summary:
-            logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_PRO_MODEL}).")
+            logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_PRO_EXP_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Gemini Pro failed. Error: {errors['GeminiPro']}. Proceeding to Gemini Flash.")
+            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 Pro & Flash.")
-        errors["GeminiPro"] = "Service disabled/unavailable."
-        errors["GeminiFlash"] = "Service disabled/unavailable." # Also skip Flash if API is down
+        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."
 
     # --- Attempt 3: Gemini 2.0 Flash ---
-    if _gemini_api_enabled and errors["GeminiFlash"] is None: # Only attempt if API enabled and not already marked unavailable
+    if _gemini_api_enabled and errors["GeminiFlash"] 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)
         if summary:
             logger.info(f"[Summary Generation] Success with Gemini ({GEMINI_FLASH_MODEL}).")
             return summary
         else:
-            logger.warning(f"[Summary Generation] Gemini Flash failed. Error: {errors['GeminiFlash']}. Proceeding to OpenRouter.")
-    elif errors["GeminiFlash"] is None: # Should have been marked unavailable above if _gemini_api_enabled was false
-         logger.warning("[Summary Generation] Skipping Gemini Flash (API was disabled).")
+            logger.warning(f"[Summary Generation] Gemini 2.0 Flash failed. Error: {errors['GeminiFlash']}. Proceeding to OpenRouter DeepSeek V3.")
+    elif errors["GeminiFlash"] is None:
+         logger.warning("[Summary Generation] Skipping Gemini 2.0 Flash (API was disabled).")
          errors["GeminiFlash"] = "Service disabled/unavailable."
 
-
-    # --- Attempt 4: OpenRouter (Final Fallback) ---
+    # --- Attempt 4: OpenRouter (DeepSeek V3 Free - Final Fallback) ---
     if _openrouter_fallback_enabled:
-        logger.info(f"[Summary Generation] Attempting 4: OpenRouter ({OPENROUTER_MODEL})")
-        summary, errors["OpenRouter"] = await _call_openrouter(text, summary_type)
+        logger.info(f"[Summary Generation] Attempting 4: OpenRouter ({OPENROUTER_DEEPSEEK_MODEL})")
+        summary, errors["DeepSeekV3"] = await _call_openrouter(text, summary_type)
         if summary:
-            logger.info(f"[Summary Generation] Success with OpenRouter ({OPENROUTER_MODEL}).")
+            logger.info(f"[Summary Generation] Success with OpenRouter ({OPENROUTER_DEEPSEEK_MODEL}).")
             return summary
         else:
-            logger.error(f"[Summary Generation] OpenRouter (Final Fallback) also failed. Error: {errors['OpenRouter']}")
+            logger.error(f"[Summary Generation] OpenRouter DeepSeek V3 (Final Fallback) also failed. Error: {errors['DeepSeekV3']}")
     else:
-        logger.error("[Summary Generation] OpenRouter fallback is disabled or unavailable. Cannot proceed.")
-        errors["OpenRouter"] = "Service disabled/unavailable."
+        logger.error("[Summary Generation] OpenRouter fallback (DeepSeek V3) is disabled or unavailable. Cannot proceed.")
+        errors["DeepSeekV3"] = "Service disabled/unavailable."
 
     # --- All Attempts Failed ---
     logger.error("[Summary Generation] All summarization models failed.")
-    # Construct a final error message
     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}"
 
 
 # --- Main Processing Logic ---
-# (process_summary_task remains UNCHANGED in its core logic of fetching content,
-# but it now calls the updated `generate_summary` function.
-# Omitted here for brevity, but should be included in the final file.)
+# (process_summary_task remains UNCHANGED in its core logic, it correctly calls the updated generate_summary.
+# Omitted here for brevity, but MUST be included in the final file.)
 # --- START OMITTED process_summary_task ---
 async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit: Optional[int], url: str, summary_type: str, bot_token: str ) -> None:
     """Handles the entire process: fetching content (with ALL fallbacks) and summarizing."""
@@ -897,12 +828,12 @@ async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit:
                 else: user_feedback_message = "Sorry, I couldn't understand that YouTube URL format."
                 if not content and not user_feedback_message: user_feedback_message = "Sorry, I couldn't get the transcript for that YouTube video using any available method (unavailable/private/no captions?)."
             else:
-                global URLTOTEXT_API_KEY, RAPIDAPI_KEY, APIFY_API_TOKEN, _urltotext_key_exists, _rapidapi_key_exists, _apify_token_exists # <<< Added globals
+                global URLTOTEXT_API_KEY, RAPIDAPI_KEY, APIFY_API_TOKEN, _urltotext_key_exists, _rapidapi_key_exists, _apify_token_exists
 
                 logger.info(f"[Task {task_id}] Trying Web Scrape Method 1 (Direct Fetch + BS4)..."); content = await get_website_content(url)
                 if not content:
                     logger.warning(f"[Task {task_id}] Method 1 failed. Trying Method 2 (urltotext.com)...")
-                    if _urltotext_key_exists: await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing'); content = await get_website_content_via_api(url, URLTOTEXT_API_KEY);
+                    if _urltotext_key_exists: await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing'); content = await get_website_content_via_api(url, URLTOTEXT_API_KEY)
                     else: logger.warning("[Task {task_id}] Method 2 (urltotext.com) API key unavailable. Skipping.")
                 if not content:
                     logger.warning(f"[Task {task_id}] Method 2 failed. Trying Method 3 (Scraper's Proxy)...")
@@ -932,8 +863,7 @@ async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit:
                 except Exception as edit_e: logger.warning(f"[Task {task_id}] Failed to edit status message before summary: {edit_e}")
 
                 await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')
-                # <<< CHANGE: Calls the updated generate_summary function >>>
-                final_summary = await generate_summary(content, summary_type)
+                final_summary = await generate_summary(content, summary_type) # Calls the updated function
 
                 if final_summary.startswith("Error:") or final_summary.startswith("Sorry,"):
                     user_feedback_message = final_summary
@@ -978,8 +908,7 @@ async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit:
 
 # --- Telegram Handlers ---
 # (start, help_command, handle_potential_url, handle_summary_type_callback, error_handler
-# remain UNCHANGED, except for a small modification in handle_summary_type_callback
-# to check the new availability flags. Omitted here for brevity, but include in final file.)
+# remain UNCHANGED. Omitted here for brevity, but include in final file.)
 # --- START OMITTED TELEGRAM HANDLERS ---
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     user = update.effective_user; mention = user.mention_html()
@@ -996,7 +925,7 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
                   "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, Gemini Pro, Gemini Flash, DeepSeek) to summarise.\n\n" # <<< Updated help text slightly
+                  "⚙️ 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
                   "**Commands:**\n"
                   "`/start` - Display the welcome message\n"
                   "`/help` - Show this help message" )
@@ -1054,7 +983,7 @@ 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}")
 
-    # <<< CHANGE: Check essential configurations based on new flags >>>
+    # Check essential configurations - requires at least ONE summarizer to be enabled
     global TELEGRAM_TOKEN, _groq_enabled, _gemini_api_enabled, _openrouter_fallback_enabled
     if not TELEGRAM_TOKEN:
         logger.critical("TELEGRAM_TOKEN missing in callback!")
@@ -1066,16 +995,10 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
         try: await query.edit_message_text(text="❌ AI configuration error: No summarization models available.")
         except Exception: pass
         return
-    # Log warnings if primary models are unavailable but don't stop the process if fallbacks exist
-    if not _groq_enabled: logger.warning("Primary AI (Groq) is unavailable, will start with Gemini Pro.")
-    if not _gemini_api_enabled: logger.warning("Gemini API is unavailable, will rely on Groq and/or OpenRouter.")
-    if not _openrouter_fallback_enabled and not (_groq_enabled or _gemini_api_enabled) :
-        # This case should already be caught above, but as a safeguard
-        logger.critical("No models available at all!")
-        try: await query.edit_message_text(text="❌ AI configuration error: No summarization models available.")
-        except Exception: pass
-        return
-
+    # Log warnings if specific models/APIs are unavailable but don't stop the process if fallbacks exist
+    if not _groq_enabled: logger.warning("Primary AI (Groq Llama 4 Scout) is unavailable.")
+    if not _gemini_api_enabled: logger.warning("Gemini API is unavailable (skipping 2.5 Pro Exp & 2.0 Flash).")
+    if not _openrouter_fallback_enabled: logger.warning("Final Fallback AI (OpenRouter DeepSeek V3) is unavailable.")
 
     logger.info(f"Scheduling background task for user {user.id}, chat {query.message.chat_id}, msg {message_id_to_edit}")
     asyncio.create_task(
@@ -1097,10 +1020,10 @@ async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> N
 
 
 # --- Application Setup & Web Framework ---
-# (setup_bot_config, lifespan, health_check, telegram_webhook, app definition
-# remain mostly UNCHANGED, except for updating the health_check response string.
+# (setup_bot_config, lifespan, telegram_webhook, app definition
+# remain UNCHANGED. health_check is modified below.
 # Omitted here for brevity, include in final file.)
-# --- START OMITTED APP SETUP/WEB FRAMEWORK ---
+# --- START OMITTED APP SETUP/WEB FRAMEWORK (excluding health_check) ---
 async def setup_bot_config() -> Application:
     logger.info("Configuring Telegram Application..."); global TELEGRAM_TOKEN
     if not TELEGRAM_TOKEN: raise ValueError("TELEGRAM_TOKEN missing.")
@@ -1170,10 +1093,35 @@ async def lifespan(app: Starlette):
         else: logger.info("PTB application was not fully initialized or failed during startup. No shutdown actions needed.")
         logger.info("ASGI Lifespan: Shutdown complete.")
 
+async def telegram_webhook(request: Request) -> Response:
+    """Handles incoming updates from Telegram."""
+    global WEBHOOK_SECRET
+    if not ptb_app: logger.error("Webhook received but PTB application not initialized."); return PlainTextResponse('Bot not initialized', status_code=503)
+    if not ptb_app.running: logger.warning("Webhook received but PTB application not running."); return PlainTextResponse('Bot not running, cannot process update', status_code=503)
+    if WEBHOOK_SECRET:
+         token_header = request.headers.get("X-Telegram-Bot-Api-Secret-Token")
+         if token_header != WEBHOOK_SECRET: logger.warning(f"Webhook received with invalid secret token. Header: '{token_header}'"); return Response(content="Invalid secret token", status_code=403)
+    try:
+        update_data = await request.json(); update = Update.de_json(data=update_data, bot=ptb_app.bot)
+        logger.debug(f"Processing update_id: {update.update_id} via webhook"); await ptb_app.process_update(update)
+        return Response(status_code=200)
+    except json.JSONDecodeError: logger.error("Webhook received invalid JSON."); return PlainTextResponse('Bad Request: Invalid JSON', status_code=400)
+    except Exception as e: logger.error(f"Error processing webhook update: {e}", exc_info=True); return Response(status_code=200)
+
+# --- Starlette App Definition ---
+# Note: health_check is defined below
+app = Starlette(
+    debug=False,
+    lifespan=lifespan,
+    routes=[ Route("/", endpoint=health_check, methods=["GET"]), Route("/webhook", endpoint=telegram_webhook, methods=["POST"]), ]
+)
+logger.info("Starlette ASGI application created with health check and webhook routes.")
+# --- END OMITTED APP SETUP/WEB FRAMEWORK ---
+
+# <<< CHANGE: Updated health check response for specific models >>>
 async def health_check(request: Request) -> PlainTextResponse:
     """Simple health check endpoint."""
-    # <<< CHANGE: Updated health check response format >>>
-    global GROQ_LLAMA_MODEL, GEMINI_PRO_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_MODEL, APIFY_ACTOR_ID
+    global GROQ_LLAMA4_MODEL, GEMINI_PRO_EXP_MODEL, GEMINI_FLASH_MODEL, OPENROUTER_DEEPSEEK_MODEL, APIFY_ACTOR_ID
     global _groq_enabled, _gemini_api_enabled, _openrouter_fallback_enabled
     global _apify_token_exists, _urltotext_key_exists, _rapidapi_key_exists, SUPADATA_API_KEY
 
@@ -1191,15 +1139,15 @@ async def health_check(request: Request) -> PlainTextResponse:
              bot_status = f"Error checking status: {type(e).__name__}"; logger.warning(f"Health check: Error getting bot info: {e}")
     else: bot_status = "Not Initialized"; bot_username = "N/A"
 
-    # <<< CHANGE: Update response string with new model order >>>
+    # <<< Update response string with specific model names >>>
     return PlainTextResponse(
         f"TG Bot Summariser - Status: {bot_status} ({bot_username})\n"
         f"---\n"
-        f"Summarizer Priority:\n"
-        f"1. Groq API: {GROQ_LLAMA_MODEL if _groq_enabled else 'DISABLED'}\n"
-        f"2. Gemini API (Pro): {GEMINI_PRO_MODEL if _gemini_api_enabled else 'DISABLED'}\n"
-        f"3. Gemini API (Flash): {GEMINI_FLASH_MODEL if _gemini_api_enabled else 'DISABLED'}\n"
-        f"4. OpenRouter API: {OPENROUTER_MODEL if _openrouter_fallback_enabled else 'DISABLED'}\n"
+        f"Summarizer Priority (April 2025 - Specific):\n"
+        f"1. Groq API: {GROQ_LLAMA4_MODEL if _groq_enabled else 'DISABLED'}\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"---\n"
         f"Content Fetching Status:\n"
         f"YT Fallback 1 (Supadata): {'Enabled' if SUPADATA_API_KEY else 'Disabled'}\n"
@@ -1210,31 +1158,6 @@ async def health_check(request: Request) -> PlainTextResponse:
         f"Web Scrape 5/6 (Apify Actors): {'Enabled' if _apify_token_exists else 'Disabled'}"
     )
 
-async def telegram_webhook(request: Request) -> Response:
-    """Handles incoming updates from Telegram."""
-    global WEBHOOK_SECRET
-    if not ptb_app: logger.error("Webhook received but PTB application not initialized."); return PlainTextResponse('Bot not initialized', status_code=503)
-    if not ptb_app.running: logger.warning("Webhook received but PTB application not running."); return PlainTextResponse('Bot not running, cannot process update', status_code=503)
-    if WEBHOOK_SECRET:
-         token_header = request.headers.get("X-Telegram-Bot-Api-Secret-Token")
-         if token_header != WEBHOOK_SECRET: logger.warning(f"Webhook received with invalid secret token. Header: '{token_header}'"); return Response(content="Invalid secret token", status_code=403)
-    try:
-        update_data = await request.json(); update = Update.de_json(data=update_data, bot=ptb_app.bot)
-        logger.debug(f"Processing update_id: {update.update_id} via webhook"); await ptb_app.process_update(update)
-        return Response(status_code=200)
-    except json.JSONDecodeError: logger.error("Webhook received invalid JSON."); return PlainTextResponse('Bad Request: Invalid JSON', status_code=400)
-    except Exception as e: logger.error(f"Error processing webhook update: {e}", exc_info=True); return Response(status_code=200)
-
-# --- Starlette App Definition ---
-app = Starlette(
-    debug=False,
-    lifespan=lifespan,
-    routes=[ Route("/", endpoint=health_check, methods=["GET"]), Route("/webhook", endpoint=telegram_webhook, methods=["POST"]), ]
-)
-logger.info("Starlette ASGI application created with health check and webhook routes.")
-# --- END OMITTED APP SETUP/WEB FRAMEWORK ---
-
-
 # --- Development Server (if run directly) ---
 if __name__ == '__main__':
     import uvicorn