Update main.py

main.py

@@ -1,12 +1,19 @@
-# main.py (Revised: Apify 201 fix + Supadata verify=False + Gunicorn/Uvicorn compatible)
+# main.py (Revised: Starlette Lifespan for PTB Initialization)
 import os
 import re
 import logging
 import asyncio
 import json
-import html
-from flask import Flask, request, Response # For web server
+import html # For unescaping HTML entities
+import contextlib # For async context manager (lifespan)
 
+# --- Frameworks ---
+from flask import Flask, request, Response # Core web routes
+from starlette.applications import Starlette # ASGI App & Lifespan
+from starlette.routing import Mount # Mount Flask within Starlette
+from starlette.middleware.wsgi import WSGIMiddleware # Wrap Flask for Starlette
+
+# --- Telegram Bot ---
 from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
 from telegram.ext import (
     Application,
@@ -15,39 +22,41 @@ from telegram.ext import (
     filters,
     ContextTypes,
     CallbackQueryHandler,
-    # ApplicationBuilder is implicitly used by Application.builder()
 )
-from telegram.constants import ParseMode # Import ParseMode explicitly
+from telegram.constants import ParseMode
+from telegram.error import NetworkError # For specific error handling if needed
 
-# Import specific libraries (Ensure these are covered in requirements.txt)
+# --- Other Libraries ---
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
-# Only import ApifyClient if you might use it (i.e., have the secret)
 _apify_token_exists = bool(os.environ.get('APIFY_API_TOKEN'))
 if _apify_token_exists:
     from apify_client import ApifyClient
 else:
-    ApifyClient = None # Explicitly set to None if not imported
+    ApifyClient = None
 
 # --- Logging Setup ---
 logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.DEBUG # Keep DEBUG for detailed info
+    level=logging.DEBUG
 )
-# Reduce noise from libraries
 logging.getLogger("httpx").setLevel(logging.WARNING)
 if ApifyClient: logging.getLogger("apify_client").setLevel(logging.WARNING)
-logging.getLogger("telegram.ext").setLevel(logging.INFO) # INFO is usually enough for PTB ext
-logging.getLogger('telegram.bot').setLevel(logging.INFO) # INFO is usually enough for PTB bot API calls
+logging.getLogger("telegram.ext").setLevel(logging.INFO)
+logging.getLogger('telegram.bot').setLevel(logging.INFO)
 logging.getLogger("urllib3").setLevel(logging.INFO)
-logging.getLogger('gunicorn.error').setLevel(logging.INFO) # Gunicorn logs
-logging.getLogger('uvicorn.error').setLevel(logging.INFO) # Uvicorn logs
+logging.getLogger('gunicorn.error').setLevel(logging.INFO)
+logging.getLogger('uvicorn').setLevel(logging.INFO) # Uvicorn logs (incl. access)
+logging.getLogger('starlette').setLevel(logging.INFO) # Starlette logs
 logger = logging.getLogger(__name__)
-logger.info("Logging configured (Main logger: DEBUG).")
+logger.info("Logging configured.")
+
+# --- Global variable for PTB app (initialized during lifespan) ---
+ptb_app: Application | None = None
 
 # --- Environment Variable Loading ---
-logger.info("Attempting to load secrets from environment variables...")
+logger.info("Attempting to load secrets...")
 def get_secret(secret_name):
     logger.debug(f"Attempting to read secret: {secret_name}")
     value = os.environ.get(secret_name)
@@ -68,14 +77,12 @@ logger.info("Secret loading attempt finished.")
 def is_youtube_url(url):
     """Checks if the URL is a valid YouTube video or shorts URL."""
     youtube_regex = r'(https?://)?(www\.)?(youtube\.com/(watch\?v=|shorts/)|youtu\.be/)([\w-]{11})'
-    # Added check for common query params like si= or feature=
     match = re.search(youtube_regex, url)
     logger.debug(f"is_youtube_url check for '{url}': {'Match found' if match else 'No match'}")
     return bool(match)
 
 def extract_youtube_id(url):
     """Extracts the YouTube video ID from a URL."""
-    # Updated regex to better handle query parameters after the ID
     youtube_id_regex = r'(?:youtube\.com/(?:watch\?v=|shorts/)|youtu\.be/)([\w-]{11})(?:\?|&|\s|$)'
     match = re.search(youtube_id_regex, url)
     if match:
@@ -96,16 +103,12 @@ async def get_transcript_via_supadata(video_id: str, api_key: str):
     params = {"videoId": video_id, "format": "text"}
     headers = {"X-API-Key": api_key}
     try:
-        # --- Keep verify=False for testing, but log clearly ---
         logger.warning("[Supadata] Making request with verify=False (Attempting to bypass SSL verification)")
         response = await asyncio.to_thread(requests.get, api_endpoint, headers=headers, params=params, timeout=30, verify=False)
-        # --- End verify=False section ---
-
         logger.debug(f"[Supadata] Received status code {response.status_code} for {video_id}")
         if response.status_code == 200:
             try:
                 data = response.json()
-                # Handle both direct string response and JSON object response
                 content = data if isinstance(data, str) else data.get("transcript") or data.get("text") or data.get("data")
                 if content and isinstance(content, str):
                     logger.info(f"[Supadata] Successfully fetched transcript for {video_id}. Length: {len(content)}")
@@ -114,7 +117,6 @@ async def get_transcript_via_supadata(video_id: str, api_key: str):
                     logger.warning(f"[Supadata] API success but content empty/invalid for {video_id}. Response: {data}")
                     return None
             except json.JSONDecodeError:
-                # If JSON fails, maybe it's plain text?
                 if response.text:
                     logger.info(f"[Supadata] Successfully fetched transcript (plain text) for {video_id}. Length: {len(response.text)}")
                     return response.text.strip()
@@ -138,7 +140,6 @@ async def get_transcript_via_supadata(video_id: str, api_key: str):
         return None
     except requests.exceptions.RequestException as e:
         logger.error(f"[Supadata] Request error connecting to API for {video_id}: {e}")
-        # Log specific SSL Error details even with verify=False
         if isinstance(e, requests.exceptions.SSLError):
             logger.error(f"[Supadata] SSL Error occurred despite using verify=False. Details: {e}")
         return None
@@ -146,7 +147,7 @@ async def get_transcript_via_supadata(video_id: str, api_key: str):
         logger.error(f"[Supadata] Unexpected error during API call for {video_id}: {e}", exc_info=True)
         return None
 
-# Apify Transcript Fetching
+# Apify Transcript Fetching (with fixed fallback parsing)
 async def get_transcript_via_apify(video_url: str, api_token: str):
     """Fetches YouTube transcript via Apify API."""
     if not video_url: logger.error("[Apify] get_transcript_via_apify called with no video_url"); return None
@@ -182,35 +183,25 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
                     # --- !!! FIXED FALLBACK LOGIC !!! ---
                     if not content and item.get("captions"):
                         captions_data = item["captions"]
-                        # Check if 'captions' is a STRING (like in the log) or a LIST of dicts
                         if isinstance(captions_data, str):
                             logger.info("[Apify] Processing 'captions' string format as fallback.")
-                            # Use the string directly if it seems to be the transcript
                             content = captions_data.strip()
-                            # Basic check if it looks like a transcript vs an error message
                             if len(content) < 50 and "error" in content.lower():
                                 logger.warning(f"[Apify] 'captions' string looks like an error: {content}")
-                                content = None # Discard if it looks like an error
+                                content = None
                         elif isinstance(captions_data, list):
                             logger.info("[Apify] Processing 'captions' list format as fallback.")
-                            # Join text from list of dicts (handle potential missing 'text' keys)
                             texts = [cap.get("text", "") for cap in captions_data if isinstance(cap, dict) and cap.get("text")]
                             content = " ".join(texts).strip()
                         else:
                              logger.warning(f"[Apify] 'captions' field found but is neither string nor list: {type(captions_data)}")
-                             content = None # Cannot parse
+                             content = None
 
-                        # Clean up potential HTML entities like '
                         if content:
                            try:
-                               import html
-                               content = html.unescape(content)
-                           except ImportError:
-                               logger.warning("[Apify] 'html' module not found, cannot unescape entities.")
+                               content = html.unescape(content) # Use imported html module
                            except Exception as unescape_err:
                                logger.warning(f"[Apify] Error during html unescaping: {unescape_err}")
-
-
                     # --- !!! END FIXED FALLBACK LOGIC !!! ---
 
                     if content and isinstance(content, str):
@@ -223,9 +214,8 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
                         elif not item.get("captions"):
                             logger.warning(f"[Apify] Actor run successful ({response.status_code}) but no text/transcript/captions_concatenated/captions field found for {video_url}. Item: {item}")
                         else:
-                            # This case means the fallback parsing above failed
                             logger.warning(f"[Apify] Actor run successful ({response.status_code}), 'captions' field found but fallback parsing failed to extract content for {video_url}.")
-                        return None # Return None if no content extracted
+                        return None
                 else:
                     logger.warning(f"[Apify] Actor run successful ({response.status_code}) but dataset result list empty for {video_url}. Response: {results}")
                     return None
@@ -235,7 +225,6 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
             except Exception as e:
                 logger.error(f"[Apify] Error processing successful response ({response.status_code}) for {video_url}: {e}", exc_info=True)
                 return None
-        # ... (rest of the error handling remains the same) ...
         elif response.status_code == 400:
              logger.error(f"[Apify] Bad Request (400) for {video_url}. Check payload. Response: {response.text[:200]}...")
              return None
@@ -262,366 +251,179 @@ async def get_youtube_transcript(video_id: str, video_url: str, supadata_key: st
     if not video_id: logger.error("get_youtube_transcript called with no video_id"); return None
     logger.info(f"Fetching transcript for video ID: {video_id} (URL: {video_url})")
     transcript_text = None
-
-    # 1. Primary Method: youtube-transcript-api
-    logger.info("[Primary YT] Attempting youtube-transcript-api...")
-    try:
-        # Run the blocking IO call in a separate thread
+    try: # Wrap primary method in try/except
+        logger.info("[Primary YT] Attempting youtube-transcript-api...")
         transcript_list = await asyncio.to_thread(
             YouTubeTranscriptApi.get_transcript,
             video_id,
-            languages=['en', 'en-GB', 'en-US'] # Prioritize English variants
+            languages=['en', 'en-GB', 'en-US']
         )
         if transcript_list:
             transcript_text = " ".join([item['text'] for item in transcript_list if 'text' in item])
-            # Clean up excessive whitespace that might result from joining
             transcript_text = re.sub(r'\s+', ' ', transcript_text).strip()
             if transcript_text:
                 logger.info(f"[Primary YT] Successfully fetched transcript via library for {video_id} (length: {len(transcript_text)})")
                 return transcript_text
             else:
                  logger.warning(f"[Primary YT] Joined transcript text is empty after cleaning for {video_id}")
-                 transcript_text = None # Explicitly set to None
+                 transcript_text = None
         else:
             logger.warning(f"[Primary YT] Transcript list was empty for {video_id}")
             transcript_text = None
     except Exception as e:
-        # Log the specific error type for better debugging
         logger.warning(f"[Primary YT] Error getting transcript via library for {video_id}: {type(e).__name__} - {e}")
-        # Be more specific about common errors
-        if "YouTube is blocking requests" in str(e) or "HTTP Error 429" in str(e):
-            logger.warning("[Primary YT] IP likely blocked by YouTube (Rate Limit / Cloud IP).")
-        elif "No transcript found" in str(e):
-            logger.warning(f"[Primary YT] No transcript available in specified languages for {video_id}.")
-        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e):
-            logger.warning(f"[Primary YT] Transcripts are disabled for {video_id}.")
-        # Ensure transcript_text is None if any exception occurred
+        if "YouTube is blocking requests" in str(e) or "HTTP Error 429" in str(e): logger.warning("[Primary YT] IP likely blocked by YouTube (Rate Limit / Cloud IP).")
+        elif "No transcript found" in str(e): logger.warning(f"[Primary YT] No transcript available in specified languages for {video_id}.")
+        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e): logger.warning(f"[Primary YT] Transcripts are disabled for {video_id}.")
         transcript_text = None
 
-    # 2. Fallback 1: Supadata API
-    if transcript_text is None:
+    if transcript_text is None: # Fallback 1: Supadata
         logger.info("[Fallback YT 1] Primary method failed or yielded no text. Trying Supadata API...")
         if supadata_key:
             transcript_text = await get_transcript_via_supadata(video_id, supadata_key)
             if transcript_text:
                 logger.info(f"[Fallback YT 1] Successfully fetched transcript via Supadata for {video_id} (length: {len(transcript_text)})")
-                return transcript_text # Return immediately on success
-            else:
-                logger.warning(f"[Fallback YT 1] Supadata API failed or returned no content for {video_id}.")
-                # transcript_text remains None
-        else:
-            logger.warning("[Fallback YT 1] Supadata API key not available. Skipping.")
+                return transcript_text
+            else: logger.warning(f"[Fallback YT 1] Supadata API failed or returned no content for {video_id}.")
+        else: logger.warning("[Fallback YT 1] Supadata API key not available. Skipping.")
 
-    # 3. Fallback 2: Apify API
-    if transcript_text is None:
+    if transcript_text is None: # Fallback 2: Apify
         logger.info("[Fallback YT 2] Primary & Supadata failed or yielded no text. Trying Apify API...")
         if apify_token:
             transcript_text = await get_transcript_via_apify(video_url, apify_token)
             if transcript_text:
                 logger.info(f"[Fallback YT 2] Successfully fetched transcript via Apify for {video_url} (length: {len(transcript_text)})")
-                return transcript_text # Return immediately on success
-            else:
-                logger.warning(f"[Fallback YT 2] Apify API failed or returned no content for {video_url}.")
-                # transcript_text remains None
-        else:
-            logger.warning("[Fallback YT 2] Apify API token not available. Skipping.")
+                return transcript_text
+            else: logger.warning(f"[Fallback YT 2] Apify API failed or returned no content for {video_url}.")
+        else: logger.warning("[Fallback YT 2] Apify API token not available. Skipping.")
 
-    # If all methods failed
     if transcript_text is None:
         logger.error(f"All methods failed to fetch transcript for video ID: {video_id}")
         return None
+    return transcript_text # Should technically be unreachable if logic is correct
 
-    # This line should technically not be reached if logic is correct, but added for safety
-    return transcript_text
-
-# Website Content via Requests/BS4 (Primary Method for Simplified Bot)
+# Website Content via Requests/BS4
 async def get_website_content_via_requests(url):
-    """Attempts to scrape website content using requests/BeautifulSoup (Primary Method)."""
+    """Attempts to scrape website content using requests/BeautifulSoup."""
     if not url: logger.error("[Web Scraper - Requests/BS4] called with no URL"); return None
     logger.info(f"[Web Scraper - Requests/BS4] Fetching website content for: {url}")
     try:
-        # Standard headers to mimic a browser
-        headers = {
-             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
-             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
-             'Accept-Language': 'en-US,en;q=0.9',
-             'Connection': 'keep-alive',
-             'DNT': '1', # Do Not Track
-             'Upgrade-Insecure-Requests': '1'
-         }
+        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8','Accept-Language': 'en-US,en;q=0.9','Connection': 'keep-alive','DNT': '1','Upgrade-Insecure-Requests': '1'}
         logger.debug(f"[Web Scraper - Requests/BS4] Sending GET request to {url}")
-        # Run blocking requests call in thread
         response = await asyncio.to_thread(requests.get, url, headers=headers, timeout=25, allow_redirects=True)
-        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+        response.raise_for_status()
         logger.debug(f"[Web Scraper - Requests/BS4] Received response {response.status_code} from {url}")
-
         content_type = response.headers.get('content-type', '').lower()
         if 'html' not in content_type:
-            logger.warning(f"[Web Scraper - Requests/BS4] Non-HTML content type received from {url}: {content_type}. Skipping parsing.")
-            # Maybe return raw text if it's plain text? Or just None.
-            if 'text/plain' in content_type and response.text:
-                 logger.info(f"[Web Scraper - Requests/BS4] Returning plain text content for {url}")
-                 return response.text.strip()
+            logger.warning(f"[Web Scraper - Requests/BS4] Non-HTML content type received: {content_type}. Trying plain text.")
+            if 'text/plain' in content_type and response.text: return response.text.strip()
             return None
-
-        # Parse with BeautifulSoup
         soup = BeautifulSoup(response.text, 'html.parser')
-
-        # Remove common unwanted elements
-        for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "label", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio"]):
-            element.extract() # Remove the tag from the tree
-
-        # Try to find the main content area (add more selectors if needed)
-        main_content = (
-            soup.find('main') or
-            soup.find('article') or
-            soup.find(id='content') or
-            soup.find(class_='content') or
-            soup.find(id='main-content') or
-            soup.find(class_='main-content') or
-            soup.find(role='main')
-        )
-
-        # Fallback to body if no specific main area found
+        for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "label", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio"]): element.extract()
+        main_content = soup.find('main') or soup.find('article') or soup.find(id='content') or soup.find(class_='content') or soup.find(id='main-content') or soup.find(class_='main-content') or soup.find(role='main')
         target_element = main_content if main_content else soup.body
-
         if not target_element:
-            logger.warning(f"[Web Scraper - Requests/BS4] Could not find body or main content container for parsing {url}")
-            # Try getting text from the whole soup as a last resort? Could be messy.
-            # raw_text = soup.get_text(separator='\n', strip=True)
-            # if raw_text: return "\n".join(line.strip() for line in raw_text.splitlines() if line.strip())
-            return None # Return None if body itself is missing
-
-        # Extract text, clean up lines, and join
+            logger.warning(f"[Web Scraper - Requests/BS4] Could not find body or main content for {url}")
+            return None
         lines = [line.strip() for line in target_element.get_text(separator='\n', strip=True).splitlines() if line.strip()]
         text = "\n".join(lines)
-
-        # Check if extracted text is reasonably long
         MIN_TEXT_LENGTH = 50
         if not text or len(text) < MIN_TEXT_LENGTH:
-             logger.warning(f"[Web Scraper - Requests/BS4] Extracted text is very short (<{MIN_TEXT_LENGTH} chars) or empty after cleaning for {url} (Length: {len(text)})")
-             # Consider returning None if text is too short, might indicate failed extraction
-             # return None
-
+             logger.warning(f"[Web Scraper - Requests/BS4] Extracted text is very short (<{MIN_TEXT_LENGTH} chars) for {url} (Length: {len(text)})")
         logger.info(f"[Web Scraper - Requests/BS4] Successfully scraped content for {url} (final length: {len(text)})")
         return text
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - Requests/BS4] Timeout error scraping {url}"); return None
+    except requests.exceptions.TooManyRedirects: logger.error(f"[Web Scraper - Requests/BS4] Too many redirects for {url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - Requests/BS4] Request error scraping {url}: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - Requests/BS4] Error scraping or parsing {url}: {e}", exc_info=True); return None
 
-    except requests.exceptions.Timeout:
-        logger.error(f"[Web Scraper - Requests/BS4] Timeout error scraping website: {url}"); return None
-    except requests.exceptions.TooManyRedirects:
-        logger.error(f"[Web Scraper - Requests/BS4] Too many redirects error scraping website: {url}"); return None
-    except requests.exceptions.RequestException as e: # Catches HTTPError, ConnectionError etc.
-        logger.error(f"[Web Scraper - Requests/BS4] Request error scraping website {url}: {e}"); return None
-    except Exception as e: # Catch potential BS4 errors or others
-        logger.error(f"[Web Scraper - Requests/BS4] Error scraping or parsing website {url}: {e}", exc_info=True); return None
-
-
-# Website Content via URLToText API (Fallback Method)
+# Website Content via URLToText API
 async def get_website_content_via_urltotext_api(url: str, api_key: str):
-    """Fetches website content using the URLToText API (Fallback)."""
+    """Fetches website content using the URLToText API."""
     if not url: logger.error("[Web Scraper - URLToText API] called with no URL"); return None
     if not api_key: logger.error("[Web Scraper - URLToText API] API key is missing."); return None
-
-    logger.info(f"[Web Scraper - URLToText API] Attempting to fetch content for: {url}")
+    logger.info(f"[Web Scraper - URLToText API] Attempting fetch for: {url}")
     api_endpoint = "https://urltotext.com/api/v1/urltotext/"
-    # Ensure payload is correctly formatted JSON string
-    payload = json.dumps({
-        "url": url,
-        "output_format": "text",
-        "extract_main_content": True, # Use their main content extraction
-        "render_javascript": True,    # Important for dynamic sites
-        "residential_proxy": False    # Usually not needed unless specifically blocked
-    })
-    headers = {
-        "Authorization": f"Token {api_key}",
-        "Content-Type": "application/json"
-    }
-
+    payload = json.dumps({"url": url, "output_format": "text", "extract_main_content": True, "render_javascript": True, "residential_proxy": False})
+    headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
     try:
         logger.debug(f"[Web Scraper - URLToText API] Sending POST request for {url}")
-        # Run blocking requests call in thread
-        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=45) # Slightly longer timeout
+        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=45)
         logger.debug(f"[Web Scraper - URLToText API] Received status code {response.status_code} for {url}")
-
         if response.status_code == 200:
             try:
                 data = response.json()
-                content = data.get("data", {}).get("content") # Navigate nested structure
+                content = data.get("data", {}).get("content")
                 credits = data.get("credits_used", "N/A")
-                warning = data.get("data", {}).get("warning") # Check for warnings
-
-                if warning:
-                    logger.warning(f"[Web Scraper - URLToText API] Warning received for {url}: {warning}")
-
+                warning = data.get("data", {}).get("warning")
+                if warning: logger.warning(f"[Web Scraper - URLToText API] Warning for {url}: {warning}")
                 if content:
                     logger.info(f"[Web Scraper - URLToText API] Successfully fetched content via API for {url}. Length: {len(content)}. Credits: {credits}")
                     return content.strip()
                 else:
-                    logger.warning(f"[Web Scraper - URLToText API] API returned success (200) but content was empty for {url}. Response: {data}")
-                    return None # Return None if content is missing despite 200 OK
-
-            except json.JSONDecodeError:
-                logger.error(f"[Web Scraper - URLToText API] Failed to decode JSON response for {url}. Status: {response.status_code}. Response text: {response.text[:500]}...")
-                return None
-            except Exception as e:
-                logger.error(f"[Web Scraper - URLToText API] Error processing successful API response for {url}: {e}", exc_info=True)
-                return None
-
-        # Handle specific error codes from URLToText API docs
-        elif response.status_code == 400: # Bad Request (e.g., invalid URL format)
-            logger.error(f"[Web Scraper - URLToText API] Bad Request (400) from API for {url}. Check URL/payload. Response: {response.text[:200]}...")
-        elif response.status_code == 401: # Unauthorized (Invalid API Key)
-             logger.error(f"[Web Scraper - URLToText API] Unauthorized (401) from API for {url}. Check API Key. Response: {response.text[:200]}...")
-        elif response.status_code == 402: # Payment Required (Credits exhausted)
-             logger.error(f"[Web Scraper - URLToText API] Payment Required (402) from API for {url}. Check credits. Response: {response.text[:200]}...")
-        elif response.status_code == 422: # Unprocessable Entity (e.g., URL cannot be reached)
-             logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL (422) reported by API for {url}. Response: {response.text[:200]}...")
-        elif response.status_code == 500: # Internal Server Error on their end
-             logger.error(f"[Web Scraper - URLToText API] Internal Server Error (500) from API for {url}. Response: {response.text[:200]}...")
-        else: # Catch-all for other unexpected codes
-            logger.error(f"[Web Scraper - URLToText API] Unexpected status {response.status_code} from API for {url}. Response: {response.text[:200]}...")
-        return None # Return None for all error cases
-
-    except requests.exceptions.Timeout:
-        logger.error(f"[Web Scraper - URLToText API] Timeout error connecting to API for {url}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logger.error(f"[Web Scraper - URLToText API] Request error connecting to API for {url}: {e}")
-        return None
-    except Exception as e:
-        logger.error(f"[Web Scraper - URLToText API] Unexpected error during API call for {url}: {e}", exc_info=True)
+                    logger.warning(f"[Web Scraper - URLToText API] API success (200) but content empty for {url}. Response: {data}")
+                    return None
+            except json.JSONDecodeError: logger.error(f"[Web Scraper - URLToText API] Failed JSON decode for {url}. Status: {response.status_code}. Resp: {response.text[:500]}..."); return None
+            except Exception as e: logger.error(f"[Web Scraper - URLToText API] Error processing successful API response for {url}: {e}", exc_info=True); return None
+        elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400) for {url}. Resp: {response.text[:200]}...")
+        elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401) for {url}. Check Key. Resp: {response.text[:200]}...")
+        elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402) for {url}. Check credits. Resp: {response.text[:200]}...")
+        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL (422) for {url}. Resp: {response.text[:200]}...")
+        elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] Server Error ({response.status_code}) from API for {url}. Resp: {response.text[:200]}...")
+        else: logger.error(f"[Web Scraper - URLToText API] Unexpected status {response.status_code} from API for {url}. Resp: {response.text[:200]}...")
         return None
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout error connecting for {url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - URLToText API] Request error connecting for {url}: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error during API call for {url}: {e}", exc_info=True); return None
 
-# DeepSeek Summary Function (via OpenRouter)
+# DeepSeek Summary Function
 async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     """Generates summary using DeepSeek via OpenRouter API."""
-    logger.info(f"Generating '{summary_type}' summary using DeepSeek/OpenRouter. Input text length: {len(text)}")
-    if not api_key:
-        logger.error("OpenRouter API key was not provided.")
-        return "Error: AI model configuration key is missing."
-    if not text:
-        logger.warning("generate_summary called with empty text.")
-        return "Error: No content provided to summarize."
-
+    logger.info(f"Generating '{summary_type}' summary. Input length: {len(text)}")
+    if not api_key: logger.error("OpenRouter API key missing."); return "Error: AI config key missing."
+    if not text: logger.warning("generate_summary called with empty text."); return "Error: No content to summarize."
     openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
-    # Using the free DeepSeek model - be mindful of potential rate limits or changes
     model_name = "deepseek/deepseek-chat:free"
-
-    # Define prompts based on summary type
-    if summary_type == "paragraph":
-        prompt = "Please provide a concise, well-written paragraph summarizing the key information and main points of the following text. Focus on capturing the essence of the content accurately."
-    elif summary_type == "points":
-        prompt = "Please summarize the following text into clear, distinct bullet points. Each point should highlight a key piece of information, finding, or main topic discussed. Aim for clarity and conciseness."
-    else:
-        logger.error(f"Invalid summary_type '{summary_type}' passed to generate_summary.")
-        return f"Error: Invalid summary type requested ('{summary_type}')."
-
-    # Check and truncate input text if necessary
-    # Max context varies per model, DeepSeek Chat's is large, but setting a practical limit is wise.
-    # Let's use a large but reasonable limit to avoid huge API calls.
-    MAX_INPUT_LENGTH = 500000 # Approx 500k characters
-    if len(text) > MAX_INPUT_LENGTH:
-        logger.warning(f"Input text length ({len(text)}) exceeds maximum limit ({MAX_INPUT_LENGTH}). Truncating.")
-        text = text[:MAX_INPUT_LENGTH] + "... (Content truncated due to length)"
-
+    if summary_type == "paragraph": prompt = "Please provide a concise, well-written paragraph summarizing the key information and main points of the following text. Focus on capturing the essence of the content accurately."
+    elif summary_type == "points": prompt = "Please summarize the following text into clear, distinct bullet points. Each point should highlight a key piece of information, finding, or main topic discussed. Aim for clarity and conciseness."
+    else: logger.error(f"Invalid summary_type '{summary_type}'."); return f"Error: Invalid summary type ('{summary_type}')."
+    MAX_INPUT_LENGTH = 500000
+    if len(text) > MAX_INPUT_LENGTH: logger.warning(f"Input text ({len(text)}) > limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Truncated)"
     full_prompt = f"{prompt}\n\n--- Start of Text ---\n\n{text}\n\n--- End of Text ---"
-
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-        # Recommended headers for OpenRouter when calling from identifiable services
-        "HTTP-Referer": "https://huggingface.co/spaces/YOUR_SPACE_NAME", # TODO: Replace with your actual space name if possible
-        "X-Title": "Telegram URL Summarizer Bot (HF Space)" # Or your bot's name
-    }
-
-    payload = json.dumps({
-        "model": model_name,
-        "messages": [
-            {"role": "user", "content": full_prompt}
-        ],
-        # Optional parameters (adjust if needed):
-        # "temperature": 0.7, # Controls randomness (optional)
-        # "max_tokens": 1024, # Limit response length (optional)
-    })
-
+    # Try getting space host for referer header
+    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Default if env var not set
+    referer_url = f"https://{space_host}" if not space_host.startswith("http") else space_host
+    headers = {"Authorization": f"Bearer {api_key}","Content-Type": "application/json","HTTP-Referer": referer_url,"X-Title": "Telegram URL Summarizer Bot"}
+    payload = json.dumps({"model": model_name, "messages": [{"role": "user", "content": full_prompt}]})
     try:
         logger.debug(f"Sending request to OpenRouter (Model: {model_name})...")
-        # Run blocking requests call in thread
-        response = await asyncio.to_thread(requests.post,
-            openrouter_api_endpoint,
-            headers=headers,
-            data=payload,
-            timeout=90 # Increased timeout for potentially long generation
-        )
+        response = await asyncio.to_thread(requests.post, openrouter_api_endpoint, headers=headers, data=payload, timeout=90)
         logger.debug(f"Received status code {response.status_code} from OpenRouter.")
-
         if response.status_code == 200:
             try:
                 data = response.json()
-                # Check the response structure carefully
                 if data.get("choices") and isinstance(data["choices"], list) and len(data["choices"]) > 0:
                     message = data["choices"][0].get("message")
                     if message and message.get("content"):
                         summary = message["content"].strip()
-                        # Basic check for empty or placeholder summary
-                        if summary:
-                           logger.info(f"Successfully generated summary via OpenRouter. Length: {len(summary)}")
-                           return summary
-                        else:
-                           logger.warning(f"OpenRouter returned success (200) but summary content is empty. Response: {data}")
-                           return "Sorry, the AI model returned an empty summary."
-                    else:
-                        logger.warning(f"OpenRouter success (200) but response structure missing expected content. Response: {data}")
-                        return "Sorry, could not parse the AI model's response (missing content)."
-                # Handle cases where 'choices' might be missing or empty, or if there's an error object
-                elif data.get("error"):
-                    error_details = data["error"]
-                    logger.error(f"OpenRouter API Error ({response.status_code}): {error_details}")
-                    return f"Sorry, the AI service reported an error: {error_details.get('message', 'Unknown error')}"
-                else:
-                    logger.error(f"OpenRouter success (200) but unexpected response structure (no choices/error). Response: {data}")
-                    return "Sorry, could not parse the AI model's response (unexpected structure)."
-
-            except json.JSONDecodeError:
-                logger.error(f"Failed to decode JSON response from OpenRouter. Status: {response.status_code}. Response: {response.text[:500]}...")
-                return "Sorry, failed to understand the AI model's response format."
-            except Exception as e:
-                logger.error(f"Error processing successful OpenRouter response: {e}", exc_info=True)
-                return "Sorry, an error occurred while processing the AI model's response."
-
-        # Handle specific HTTP error codes
-        elif response.status_code == 401: # Unauthorized
-            logger.error("OpenRouter API key is invalid or unauthorized (401). Check the key in HF Secrets.")
-            return "Error: AI model configuration key is invalid."
-        elif response.status_code == 402: # Payment Required / Quota Exceeded
-            logger.error("OpenRouter Payment Required / Quota Exceeded (402). Check OpenRouter account status and limits.")
-            return "Sorry, there's an issue with the AI service account (limits or payment)."
-        elif response.status_code == 429: # Rate Limit Exceeded
-            logger.warning("OpenRouter Rate Limit Exceeded (429). Need to wait or slow down requests.")
-            return "Sorry, the AI model service is busy right now. Please try again in a moment."
-        elif response.status_code >= 500: # Server Error on OpenRouter's side
-            logger.error(f"OpenRouter Internal Server Error ({response.status_code}). Response: {response.text[:500]}...")
-            return "Sorry, the AI model service encountered an internal error. Please try again later."
-        else: # Catch-all for other client-side or unexpected errors
-             logger.error(f"Unexpected status code {response.status_code} received from OpenRouter. Response: {response.text[:500]}...")
-             try:
-                 # Try to parse error message from response if possible
-                 error_data = response.json()
-                 error_msg = error_data.get("error", {}).get("message", response.text[:100])
-                 return f"Sorry, the AI service returned an error ({response.status_code}): {error_msg}"
-             except:
-                 # Fallback if response is not JSON or doesn't have expected error structure
-                 return f"Sorry, the AI service returned an unexpected status code ({response.status_code})."
-
-    except requests.exceptions.Timeout:
-        logger.error("Timeout occurred while connecting to OpenRouter.")
-        return "Sorry, the request to the AI model timed out. Please try again."
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Network error connecting to OpenRouter: {e}")
-        return "Sorry, there was a network error connecting to the AI model service."
-    except Exception as e:
-        logger.error(f"Unexpected error occurred in generate_summary function: {e}", exc_info=True)
-        return "Sorry, an unexpected internal error occurred while generating the summary."
+                        if summary: logger.info(f"Success generating summary. Len: {len(summary)}"); return summary
+                        else: logger.warning(f"OpenRouter success but empty content. Resp: {data}"); return "Sorry, AI model returned empty summary."
+                    else: logger.warning(f"OpenRouter success but missing content field. Resp: {data}"); return "Sorry, could not parse AI response (content)."
+                elif data.get("error"): logger.error(f"OpenRouter API Error: {data['error']}"); return f"Sorry, AI service error: {data['error'].get('message', 'Unknown')}"
+                else: logger.error(f"Unexpected OpenRouter choices structure. Resp: {data}"); return "Sorry, could not parse AI response (choices)."
+            except json.JSONDecodeError: logger.error(f"Failed JSON decode from OpenRouter. Status: {response.status_code}. Resp: {response.text[:500]}..."); return "Sorry, failed to understand AI response format."
+            except Exception as e: logger.error(f"Error processing OpenRouter success resp: {e}", exc_info=True); return "Sorry, error processing AI response."
+        elif response.status_code == 401: logger.error("OpenRouter API key invalid (401)."); return "Error: AI model config key invalid."
+        elif response.status_code == 402: logger.error("OpenRouter Payment Required (402)."); return "Sorry, issue with AI service limits/payment."
+        elif response.status_code == 429: logger.warning("OpenRouter Rate Limit (429)."); return "Sorry, AI model busy. Try again."
+        elif response.status_code >= 500: logger.error(f"OpenRouter Internal Error ({response.status_code}). Resp: {response.text[:500]}..."); return "Sorry, AI model service error. Try again later."
+        else:
+             logger.error(f"Unexpected status {response.status_code} from OpenRouter. Resp: {response.text[:500]}...")
+             try: error_data = response.json(); error_msg = error_data.get("error", {}).get("message", response.text[:100]); return f"Sorry, AI service error ({response.status_code}): {error_msg}"
+             except: return f"Sorry, AI service returned status {response.status_code}."
+    except requests.exceptions.Timeout: logger.error("Timeout connecting to OpenRouter."); return "Sorry, request to AI model timed out."
+    except requests.exceptions.RequestException as e: logger.error(f"Request error connecting to OpenRouter: {e}"); return "Sorry, error connecting to AI model service."
+    except Exception as e: logger.error(f"Unexpected error in generate_summary: {e}", exc_info=True); return "Sorry, unexpected error generating summary."
 
 
 # --- Telegram Bot Handlers ---
@@ -629,361 +431,196 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles the /start command."""
     user = update.effective_user
-    if not user: return # Should not happen but good practice
+    if not user: return
     logger.info(f"User {user.id} ({user.username or 'NoUsername'}) triggered /start.")
-    # Use mention_html for a clickable link if username exists, otherwise just first name
     mention = user.mention_html() if user.username else user.first_name
-    await update.message.reply_html(
-        f"👋 Hello {mention}! I can summarize YouTube links or website URLs.\n\n"
-        "Just send me a valid link (starting with http:// or https://) and I'll ask you how you want it summarized."
-    )
+    await update.message.reply_html(f"👋 Hello {mention}! Send a YouTube or website URL to summarize.")
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles the /help command."""
     user = update.effective_user
     logger.info(f"User {user.id if user else 'Unknown'} triggered /help.")
-    help_text = (
-        "**How I Work:**\n\n"
-        "1. Send me a full URL (starting with `http://` or `https://`).\n"
-        "2. I'll detect if it's a YouTube video link or a general website URL.\n"
-        "3. I'll ask if you want a **Paragraph** summary or **Points** summary.\n"
-        "4. Choose your preferred format by clicking the button.\n"
-        "5. I'll fetch the content (transcript for YouTube, text for websites) and use an AI model (via OpenRouter) to generate the summary.\n\n"
-        "**Troubleshooting:**\n"
-        "- **YouTube:** Sometimes transcripts aren't available (private video, no captions, disabled). I use multiple methods (library, Supadata, Apify) to try and get them.\n"
-        "- **Websites:** Complex websites with lots of JavaScript might be difficult to scrape accurately. I use a primary scraping method and a fallback API (URLToText) if needed.\n"
-        "- **AI Errors:** Occasionally, the AI model might be busy or encounter an error. You can try again later.\n\n"
-        "Just send a link to get started!"
-    )
+    help_text = ( "**How I Work:**\n\n" # ... (keep your detailed help text) ...
+        "1. Send URL.\n2. Choose format (Paragraph/Points).\n3. Get summary!\n\n"
+        "**Troubleshooting:**\n- YT transcripts might fail.\n- Complex websites hard to scrape.\n- AI errors possible.\n\nSend link to start!" )
     await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
 
 async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles messages containing potential URLs."""
-    if not update.message or not update.message.text:
-        return # Ignore empty messages
-
-    message_text = update.message.text.strip()
-    user = update.effective_user
+    if not update.message or not update.message.text: return
+    message_text = update.message.text.strip(); user = update.effective_user;
     if not user: return
-
-    # Simple check for potential URLs - refine if needed
-    # Looks for http:// or https:// followed by some characters and a dot.
-    url_pattern = r'https?://[^\s/$.?#].[^\s]*'
-    match = re.search(url_pattern, message_text)
-
+    url_pattern = r'https?://[^\s/$.?#].[^\s]*'; match = re.search(url_pattern, message_text)
     if match:
-        url = match.group(0) # Extract the first matched URL
-        logger.info(f"User {user.id} ({user.username or 'NoUsername'}) sent potential URL: {url}")
-
-        # Store the URL in user_data, associated with the user ID
-        context.user_data['url_to_summarize'] = url
-        logger.debug(f"Stored URL '{url}' in user_data for user {user.id}")
-
-        # Define the inline keyboard buttons
-        keyboard = [
-            [
-                InlineKeyboardButton("Paragraph Summary", callback_data="paragraph"),
-                InlineKeyboardButton("Points Summary", callback_data="points")
-            ]
-        ]
+        url = match.group(0); logger.info(f"User {user.id} sent potential URL: {url}")
+        context.user_data['url_to_summarize'] = url; logger.debug(f"Stored URL '{url}' for user {user.id}")
+        keyboard = [[ InlineKeyboardButton("Paragraph", callback_data="paragraph"), InlineKeyboardButton("Points", callback_data="points")]]
         reply_markup = InlineKeyboardMarkup(keyboard)
-
-        # Reply to the user, asking for the summary type
-        await update.message.reply_text(
-            f"Okay, I see this link:\n{url}\n\nHow would you like it summarized?",
-            reply_markup=reply_markup,
-            # disable_web_page_preview=True # Good practice to avoid double previews
-            link_preview_options={'is_disabled': True} # Updated way for PTB v20+
-        )
-    else:
-        # If the message doesn't look like a URL, optionally reply or just ignore
-        logger.debug(f"Ignoring non-URL message from user {user.id}: {message_text[:100]}")
-        # Optional: Reply if you want to guide the user
-        # await update.message.reply_text("Please send me a valid URL starting with http:// or https://")
-
+        await update.message.reply_text(f"Link detected:\n{url}\n\nChoose summary type:", reply_markup=reply_markup, link_preview_options={'is_disabled': True})
+    else: logger.debug(f"Ignoring non-URL message from {user.id}: {message_text[:100]}")
 
 async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles button presses for choosing the summary type."""
-    query = update.callback_query
-    if not query: return
-    user = query.from_user # Get user from the callback query
-
-    # --- 1. Answer the callback query ---
-    # It's crucial to answer quickly to remove the "loading" state on the button.
-    try:
-        await query.answer()
-        logger.debug(f"Answered callback query {query.id}")
-    except Exception as e:
-        # This can happen if the query is too old, but log it.
-        logger.error(f"Failed to answer callback query {query.id}: {e}")
-        # Don't stop processing, but be aware the button might stay loading for the user.
-
-    # --- 2. Get data and context ---
-    summary_type = query.data # e.g., "paragraph" or "points"
-    # Retrieve the URL stored earlier for this user
-    url = context.user_data.get('url_to_summarize')
-
-    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) chose '{summary_type}' summary. Checking for URL '{url}' in context.")
-
+    query = update.callback_query; user = query.from_user
+    try: await query.answer(); logger.debug(f"Answered callback query {query.id}")
+    except Exception as e: logger.error(f"Failed to answer callback query {query.id}: {e}")
+    summary_type = query.data; url = context.user_data.get('url_to_summarize')
+    logger.info(f"User {user.id} chose '{summary_type}'. URL in context: '{url}'.")
     if not url:
-        logger.warning(f"User {user.id} pressed button, but NO URL was found in user_data context. Query data: {summary_type}")
-        # Edit the original message to inform the user
-        try:
-            await query.edit_message_text(text="Sorry, I seem to have lost the context. 🤔 Please send the link again.")
-        except Exception as edit_err:
-            logger.error(f"Failed to edit message after lost context error: {edit_err}")
-        return # Stop processing
-
-    # Clear the URL from context once we start processing it
-    context.user_data.pop('url_to_summarize', None)
-    logger.debug(f"Retrieved and cleared URL {url} from user_data for user {user.id}")
-
-    # --- 3. Check for required API keys ---
-    # Re-fetch keys inside handler in case they were updated (less critical here, but good practice)
-    current_openrouter_key = os.environ.get('OPENROUTER_API_KEY')
-    current_urltotext_key = os.environ.get('URLTOTEXT_API_KEY')
-    current_supadata_key = os.environ.get('SUPADATA_API_KEY')
-    current_apify_token = os.environ.get('APIFY_API_TOKEN')
-
-    logger.debug(f"Reading API keys from environment variables within handler...")
-    logger.debug(f"Keys read: OpenRouter={'Yes' if current_openrouter_key else 'No'}, "
-                 f"URLToText={'Yes' if current_urltotext_key else 'No'}, "
-                 f"Supadata={'Yes' if current_supadata_key else 'No'}, "
-                 f"Apify={'Yes' if current_apify_token else 'No'}")
-
-
+        logger.warning(f"User {user.id} pressed button, NO URL in context.");
+        try: await query.edit_message_text(text="Context lost. Send link again.")
+        except Exception as edit_err: logger.error(f"Failed edit on lost context: {edit_err}")
+        return
+    context.user_data.pop('url_to_summarize', None); logger.debug(f"Cleared URL {url} for user {user.id}")
+    current_openrouter_key = os.environ.get('OPENROUTER_API_KEY'); current_urltotext_key = os.environ.get('URLTOTEXT_API_KEY')
+    current_supadata_key = os.environ.get('SUPADATA_API_KEY'); current_apify_token = os.environ.get('APIFY_API_TOKEN')
+    logger.debug(f"Keys read: OR={'Y' if current_openrouter_key else 'N'}, UTT={'Y' if current_urltotext_key else 'N'}, SD={'Y' if current_supadata_key else 'N'}, AP={'Y' if current_apify_token else 'N'}")
     if not current_openrouter_key:
-        logger.error("OpenRouter API key is missing in environment variables. Cannot generate summary.")
-        try:
-            await query.edit_message_text(text="⚠️ Error: The AI summarization service is not configured correctly (missing API key). Please contact the bot admin.")
-        except Exception as edit_err:
-            logger.error(f"Failed to edit message about missing OpenRouter key: {edit_err}")
+        logger.error("OpenRouter key missing.");
+        try: await query.edit_message_text(text="⚠️ AI service config error (key missing). Contact admin.")
+        except Exception as edit_err: logger.error(f"Failed edit on missing OR key: {edit_err}")
         return
-
-    # --- 4. Edit message to show "Processing..." ---
-    processing_message_text = f"Got it! Generating '{summary_type}' summary for:\n{url}\n\nThis might take a moment..."
-    message_to_delete_later_id = None
-    try:
-        # Edit the original message where the buttons were
-        await query.edit_message_text(text=processing_message_text)
-        logger.debug(f"Edited message for query {query.id} to show processing status.")
+    processing_message_text = f"Working on '{summary_type}' summary for:\n{url}\n..."; message_to_delete_later_id = None
+    try: await query.edit_message_text(text=processing_message_text); logger.debug(f"Edited message query {query.id}")
     except Exception as e:
-        # If editing fails (e.g., message too old, deleted), send a new message
-        logger.warning(f"Could not edit original message {query.message.message_id if query.message else 'N/A'} (query {query.id}): {e}. Sending a new status message.")
-        try:
-            status_message = await context.bot.send_message(chat_id=user.id, text=processing_message_text)
-            message_to_delete_later_id = status_message.message_id
-            logger.debug(f"Sent new status message {message_to_delete_later_id}")
-        except Exception as send_err:
-            logger.error(f"Failed even to send a new status message: {send_err}")
-            # Can't easily inform the user now, just log.
-
-    # --- 5. Fetch Content (YouTube or Website) ---
-    content = None
-    user_feedback_message = None # Store potential error messages for the user
-    success = False # Track overall success
-
+        logger.warning(f"Could not edit message {query.message.message_id if query.message else 'N/A'}: {e}. Sending new.");
+        try: status_message = await context.bot.send_message(chat_id=user.id, text=processing_message_text); message_to_delete_later_id = status_message.message_id; logger.debug(f"Sent new status message {message_to_delete_later_id}")
+        except Exception as send_err: logger.error(f"Failed sending new status message: {send_err}")
+    content = None; user_feedback_message = None; success = False
     try:
-        # Send "typing..." action to indicate activity
-        logger.debug(f"Sending 'typing' action for chat {user.id}")
-        await context.bot.send_chat_action(chat_id=user.id, action='typing')
-
-        is_yt = is_youtube_url(url)
-        logger.debug(f"URL determined to be YouTube: {is_yt}")
-
+        logger.debug(f"Sending 'typing' action for chat {user.id}"); await context.bot.send_chat_action(chat_id=user.id, action='typing')
+        is_yt = is_youtube_url(url); logger.debug(f"URL is YouTube: {is_yt}")
         if is_yt:
             video_id = extract_youtube_id(url)
             if video_id:
-                logger.info(f"Fetching YouTube transcript for video_id: {video_id}")
-                content = await get_youtube_transcript(video_id, url, current_supadata_key, current_apify_token)
-                if not content:
-                    # Provide a more informative error if all YT methods fail
-                    user_feedback_message = "Sorry, I couldn't get the transcript for that YouTube video using any available method (unavailable/private/no captions?)."
-                logger.info(f"YouTube transcript fetch completed. Content found: {bool(content)}")
-            else:
-                logger.warning(f"Failed to extract video ID from supposedly YouTube URL: {url}")
-                user_feedback_message = "Sorry, I couldn't properly identify the YouTube video ID from the link."
+                logger.info(f"Fetching YT transcript: {video_id}"); content = await get_youtube_transcript(video_id, url, current_supadata_key, current_apify_token)
+                if not content: user_feedback_message = "Sorry, couldn't get YT transcript (unavailable/private/no captions?)."
+                logger.info(f"YT transcript fetch done. Found: {bool(content)}")
+            else: logger.warning(f"Failed YT ID extraction: {url}"); user_feedback_message = "Sorry, couldn't parse YT video ID."
         else:
-            # Try fetching website content
-            logger.info(f"Attempting website scrape (Requests/BS4) for: {url}")
-            content = await get_website_content_via_requests(url)
-
-            if content:
-                logger.info("Website scrape (Requests/BS4) successful.")
-                user_feedback_message = None # Clear any previous potential message
+            logger.info(f"Scraping website (Requests/BS4): {url}"); content = await get_website_content_via_requests(url)
+            if content: logger.info("Website scrape (Requests/BS4) OK."); user_feedback_message = None
             else:
-                logger.warning(f"Primary website scrape (Requests/BS4) failed for {url}. Trying fallback API (URLToText)...")
+                logger.warning(f"Website scrape failed for {url}. Trying URLToText API.");
                 if current_urltotext_key:
-                    # Send typing action again before potentially long API call
-                    await context.bot.send_chat_action(chat_id=user.id, action='typing')
-                    content = await get_website_content_via_urltotext_api(url, current_urltotext_key)
-                    if content:
-                        logger.info("Website scrape fallback (URLToText API) successful.")
-                        user_feedback_message = None
-                    else:
-                        logger.warning(f"Fallback website scrape (URLToText API) also failed for {url}.")
-                        user_feedback_message = "Sorry, I couldn't fetch the content from that website using either the standard method or the fallback API."
-                else:
-                    logger.warning("URLToText API key is not configured. Cannot use fallback.")
-                    user_feedback_message = "Sorry, I couldn't fetch the content from that website (primary method failed, and fallback is not configured)."
-
-        # --- 6. Generate Summary if Content Exists ---
+                    await context.bot.send_chat_action(chat_id=user.id, action='typing'); content = await get_website_content_via_urltotext_api(url, current_urltotext_key)
+                    if content: logger.info("URLToText API scrape OK."); user_feedback_message = None
+                    else: logger.warning(f"URLToText scrape failed for {url}."); user_feedback_message = "Sorry, couldn't fetch web content (both methods)."
+                else: logger.warning("URLToText key not configured."); user_feedback_message = "Sorry, couldn't fetch web content (fallback not configured)."
         if content:
-            logger.info("Content retrieved successfully. Proceeding to generate summary.")
-            # Send typing action again before AI call
-            await context.bot.send_chat_action(chat_id=user.id, action='typing')
-
+            logger.info("Content found, generating summary."); await context.bot.send_chat_action(chat_id=user.id, action='typing')
             summary = await generate_summary(content, summary_type, current_openrouter_key)
-
-            # Check if the summary generation itself returned an error message
-            if summary.startswith("Error:") or summary.startswith("Sorry,"):
-                user_feedback_message = summary # Use the error from generate_summary
-                logger.warning(f"Summary generation failed or returned an error message: {summary}")
-            else:
-                # Success! Send the summary.
-                logger.info("Summary generated successfully. Sending to user.")
-                await context.bot.send_message(
-                    chat_id=user.id,
-                    text=summary,
-                    parse_mode=ParseMode.MARKDOWN, # Assume summary might contain markdown
-                    # disable_web_page_preview=True
-                    link_preview_options={'is_disabled': True}
-                )
-                success = True # Mark as successful
-                user_feedback_message = None # Clear any potential previous error
-        elif not user_feedback_message:
-            # If content is None and no specific error message was set, provide a generic one
-            logger.error(f"Content fetching resulted in None, but no specific user feedback message was set for URL: {url}")
-            user_feedback_message = "Sorry, I was unable to retrieve any content from the provided link."
-
-        # --- 7. Send Final Feedback (if error occurred) ---
-        if user_feedback_message and not success:
-            logger.warning(f"Sending failure feedback message to user {user.id}: {user_feedback_message}")
-            await context.bot.send_message(
-                chat_id=user.id,
-                text=user_feedback_message
-            )
-
-    except Exception as e:
-        # Catch any unexpected errors during the whole process
-        logger.error(f"An unexpected error occurred in handle_summary_type_callback for user {user.id}, URL {url}: {e}", exc_info=True)
-        try:
-            # Try to inform the user about the internal error
-             await context.bot.send_message(chat_id=user.id, text=" माफी माग्छु ! An unexpected internal error occurred while processing your request. The developers have been notified.") # माफी माग्छु = Oops!
-        except Exception as final_err:
-             logger.error(f"Failed to even send the final error message to user {user.id}: {final_err}")
-
+            if summary.startswith("Error:") or summary.startswith("Sorry,"): user_feedback_message = summary; logger.warning(f"Summary generation failed: {summary}")
+            else: logger.info("Summary generated OK. Sending."); await context.bot.send_message(chat_id=user.id, text=summary, parse_mode=ParseMode.MARKDOWN, link_preview_options={'is_disabled': True}); success = True; user_feedback_message = None
+        elif not user_feedback_message: user_feedback_message = "Sorry, couldn't retrieve content from link."
+        if user_feedback_message and not success: logger.warning(f"Sending failure feedback: {user_feedback_message}"); await context.bot.send_message(chat_id=user.id, text=user_feedback_message)
+    except Exception as e: logger.error(f"Unexpected error in callback processing: {e}", exc_info=True);
+    try: await context.bot.send_message(chat_id=user.id, text="Oops! Internal error processing request.")
+    except Exception as final_err: logger.error(f"Failed sending final error message: {final_err}")
     finally:
-        # --- 8. Clean up the "Processing..." message ---
-        # This runs whether success or failure, unless an error prevented it
-        logger.debug("Callback handler finished. Cleaning up status message (if possible)...")
+        logger.debug("Cleaning up status message...");
         try:
-            if message_to_delete_later_id:
-                # If we sent a separate status message, delete it
-                await context.bot.delete_message(chat_id=user.id, message_id=message_to_delete_later_id)
-                logger.debug(f"Deleted separate status message {message_to_delete_later_id}.")
-            elif query.message:
-                 # If we successfully edited the original message, delete it now that we're done
-                 # (or you could edit it to "Summary complete!" or the error message)
-                 # Deleting is cleaner usually.
-                 await query.delete_message()
-                 logger.debug(f"Deleted original message (via query {query.id}, message_id {query.message.message_id}).")
-        except Exception as del_err:
-            # Log if deletion fails, but don't crash
-            logger.warning(f"Could not delete status/button message: {del_err}")
-
+             if message_to_delete_later_id: await context.bot.delete_message(chat_id=user.id, message_id=message_to_delete_later_id); logger.debug("Deleted separate status msg.")
+             elif query.message: await query.delete_message(); logger.debug(f"Deleted original message query {query.id}.")
+        except Exception as del_e: logger.warning(f"Could not delete status/button message: {del_e}")
 
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Log Errors caused by Updates."""
     logger.error(f"Exception while handling an update: {context.error}", exc_info=context.error)
 
-    # Optional: Inform user about generic errors (be cautious with this)
-    # try:
-    #     if isinstance(update, Update) and update.effective_chat:
-    #         await context.bot.send_message(
-    #             chat_id=update.effective_chat.id,
-    #             text="Sorry, something went wrong processing your request."
-    #         )
-    # except Exception as e:
-    #     logger.error(f"Failed to send error message to chat: {e}")
-
-
-# --- Bot Application Setup Function ---
-# Make setup_bot an async function as Application.initialize() is async
-async def setup_bot():
-    """Initializes and configures the Telegram Bot Application."""
-    logger.info("Setting up Telegram Application...")
+# --- Bot Setup Function (Configure Only) ---
+async def setup_bot_config() -> Application:
+    """Configures the PTB Application but does NOT initialize or start it."""
+    logger.info("Configuring Telegram Application...")
     if not TELEGRAM_TOKEN:
-        logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable not found. Bot cannot start.")
-        return None
-
-    # Use Application.builder() for setup
+        logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable not found.")
+        raise ValueError("TELEGRAM_TOKEN environment variable not set.")
     application = Application.builder().token(TELEGRAM_TOKEN).build()
-
-    # --- Register Handlers ---
-    # Command Handlers
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
-
-    # Message Handler for URLs (ensure it doesn't catch commands)
-    # Using filters.TEXT & ~filters.COMMAND & filters.Entity("url") | filters.Entity("text_link") might be more precise
-    # But a simple text check + regex inside the handler is often robust enough.
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
-
-    # Callback Query Handler for button presses
     application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
-
-    # Error Handler (registers the function defined above)
     application.add_error_handler(error_handler)
-
-    logger.info("Telegram handlers registered.")
-
-    # Initialize the application (fetches bot info, etc.)
-    # This is now done automatically when application runs, but explicit call ensures it happens early
-    try:
-        logger.info("Running application.initialize()...")
-        await application.initialize()
-        logger.info("Finished application.initialize(). Bot details: %s", application.bot.username)
-    except Exception as e:
-        logger.critical(f"Failed to initialize Telegram application: {e}", exc_info=True)
-        return None # Indicate failure
-
+    logger.info("Telegram handlers configured.")
     return application
 
-# --- Global Application Instance ---
-# Run setup_bot once at startup
-logger.info("Running bot setup at startup...")
-# Use asyncio.get_event_loop().run_until_complete() if running outside an existing async context
-# In newer Python versions, asyncio.run() is preferred but might cause issues if nested.
-# Since this is top-level before Flask/Gunicorn starts its loop, it should be okay.
-ptb_app: Application | None = asyncio.run(setup_bot())
-logger.info(f"Bot setup finished. Application instance: {'OK' if ptb_app else 'FAILED'}")
+# --- ASGI Lifespan Context Manager ---
+@contextlib.asynccontextmanager
+async def lifespan(app: Starlette): # app argument is the Starlette instance
+    """Handles PTB startup and shutdown during ASGI lifespan."""
+    global ptb_app
+    logger.info("ASGI Lifespan: Startup commencing...")
+    loop = asyncio.get_running_loop()
 
+    try:
+        ptb_app = await setup_bot_config()
+        logger.info("PTB App configured. Initializing...")
+        await ptb_app.initialize()
+        logger.info("PTB App initialized. Starting background tasks...")
+        await ptb_app.start()
+        logger.info(f"PTB App started. Bot details: {ptb_app.bot.username}")
+
+        # Set webhook after start
+        WEBHOOK_URL_BASE = os.environ.get("SPACE_HOST")
+        if WEBHOOK_URL_BASE:
+            if not WEBHOOK_URL_BASE.startswith("https://"): WEBHOOK_URL_BASE = f"https://{WEBHOOK_URL_BASE}"
+            webhook_path = "/webhook" # Matches Flask route
+            full_webhook_url = f"{WEBHOOK_URL_BASE.rstrip('/')}{webhook_path}"
+            logger.info(f"Attempting to set webhook to: {full_webhook_url}")
+            try:
+                await ptb_app.bot.set_webhook(url=full_webhook_url, allowed_updates=Update.ALL_TYPES)
+                webhook_info = await ptb_app.bot.get_webhook_info()
+                logger.info(f"Webhook set successfully! Info: {webhook_info}")
+            except Exception as e: logger.error(f"Failed to set webhook: {e}", exc_info=True)
+        else: logger.warning("SPACE_HOST env variable not found. Skipping webhook setup.")
+
+        logger.info("ASGI Lifespan: Startup complete. Application ready.")
+        yield # Application runs here
+
+    except Exception as startup_err:
+        logger.critical(f"CRITICAL ERROR during ASGI startup: {startup_err}", exc_info=True)
+        # Optionally re-raise or handle to prevent server from potentially running in bad state
+        raise
+    finally:
+        # --- Shutdown ---
+        logger.info("ASGI Lifespan: Shutdown commencing...")
+        if ptb_app and ptb_app.is_running:
+            try:
+                logger.info("Stopping PTB App...")
+                await ptb_app.stop()
+                logger.info("Shutting down PTB App...")
+                await ptb_app.shutdown()
+                logger.info("PTB App shut down successfully.")
+            except Exception as shutdown_err:
+                logger.error(f"Error during PTB shutdown: {shutdown_err}", exc_info=True)
+        elif ptb_app:
+             logger.warning("PTB App instance exists but was not running at shutdown.")
+        else:
+            logger.warning("No PTB App instance found at shutdown.")
+        logger.info("ASGI Lifespan: Shutdown complete.")
 
-# --- Flask App Setup (for Webhook) ---
-# Import the WSGI-to-ASGI bridge
-from asgiref.wsgi import WsgiToAsgi
-
-logger.info("Flask app setup initiating...")
 
-# Create the core Flask app instance (give it a distinct name)
-flask_app = Flask(__name__)
-logger.info("Core Flask app instance created.")
+# --- Flask App Setup (for Routes) ---
+flask_core_app = Flask(__name__)
+logger.info("Core Flask app instance created (for routing via Starlette).")
 
-# --- Define Flask Routes on flask_app ---
-@flask_app.route('/')
+# --- Define Flask Routes on flask_core_app ---
+@flask_core_app.route('/')
 def index():
     """Basic health check endpoint."""
     logger.debug("Health check '/' accessed.")
-    bot_status = "Initialized" if ptb_app and ptb_app.bot else "Initialization FAILED"
-    return f"Telegram Bot Webhook Listener ({bot_status}) is running."
+    bot_status = "UNKNOWN"
+    if ptb_app: bot_status = "Running" if ptb_app.is_running else "Initialized/Stopped/Starting/Error"
+    else: bot_status = "Not Initialized"
+    return f"Telegram Bot Webhook Listener ({bot_status}) running via Starlette."
 
-@flask_app.route('/webhook', methods=['POST'])
+@flask_core_app.route('/webhook', methods=['POST'])
 async def webhook() -> Response:
     """Webhook endpoint for Telegram updates."""
-    if not ptb_app:
-        logger.error("Webhook triggered, but Telegram Application (ptb_app) is not initialized.")
-        return Response('Bot not configured correctly.', status=500)
+    if not ptb_app or not ptb_app.is_running:
+        status = "Not Initialized" if not ptb_app else "Not Running"
+        logger.error(f"Webhook triggered, but PTB Application is {status}.")
+        return Response('Bot service not ready.', status=503)
 
     logger.debug("Webhook request received (POST)...")
     if request.is_json:
@@ -991,35 +628,31 @@ async def webhook() -> Response:
             update_data = request.get_json()
             update = Update.de_json(update_data, ptb_app.bot)
             logger.debug(f"Processing update ID: {update.update_id} via webhook")
-            await ptb_app.process_update(update)
+            await ptb_app.process_update(update) # Queue/process the update
             logger.debug(f"Finished processing update ID: {update.update_id}")
-            return Response('ok', status=200) # Acknowledge receipt to Telegram
-
-        except json.JSONDecodeError:
-            logger.error("Failed to decode JSON from Telegram webhook request.")
-            return Response('Bad Request: Invalid JSON', status=400)
-        except Exception as e:
-            logger.error(f"Error processing update in webhook: {e}", exc_info=True)
-            return Response('Internal Server Error processing update.', status=500)
-    else:
-        logger.warning("Received non-JSON request to webhook endpoint.")
-        return Response('Bad Request: Expected JSON', status=400)
-
-# --- Wrap the Flask WSGI app into an ASGI app ---
-# Gunicorn/Uvicorn will look for this 'app' object by default (main:app)
-app = WsgiToAsgi(flask_app)
-logger.info("Flask WSGI app wrapped with WsgiToAsgi for ASGI compatibility.")
+            return Response('ok', status=200)
+        except json.JSONDecodeError: logger.error("Failed JSON decode from Telegram."); return Response('Bad Request: Invalid JSON', status=400)
+        except Exception as e: logger.error(f"Error processing update in webhook handler: {e}", exc_info=True); return Response('Internal Server Error processing update.', status=500)
+    else: logger.warning("Received non-JSON request to webhook."); return Response('Bad Request: Expected JSON', status=400)
+
+
+# --- Create Starlette App with Lifespan & Mount Flask ---
+app = Starlette(
+    lifespan=lifespan,
+    routes=[
+        Mount("/", app=WSGIMiddleware(flask_core_app))
+    ]
+)
+logger.info("Starlette application created with lifespan and Flask app mounted at '/'.")
 
 
 # --- Main Execution Block (for local testing ONLY) ---
 if __name__ == '__main__':
-    # This block remains the same, but note it runs the core flask_app
-    # using Flask's development server, NOT the wrapped ASGI app.
-    logger.warning("Running Flask development server directly (for local testing only).")
-    if not ptb_app:
-        logger.critical("Aborting local Flask start: Telegram App (ptb_app) failed initialization.")
+    logger.warning("Running Flask development server directly (LOCAL TESTING ONLY).")
+    logger.warning("NOTE: This mode does NOT initialize PTB via ASGI lifespan.")
+    logger.warning("Use 'uvicorn main:app --reload --port 8080' for proper local ASGI testing.")
+    if not TELEGRAM_TOKEN: logger.critical("Aborting local Flask start: TELEGRAM_TOKEN missing.")
     else:
         local_port = int(os.environ.get('PORT', 8080))
         logger.info(f"Flask dev server starting on http://0.0.0.0:{local_port}")
-        # Run the original Flask app for local dev server
-        flask_app.run(host='0.0.0.0', port=local_port, debug=True)
+        flask_core_app.run(host='0.0.0.0', port=local_port, debug=True)