Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Revised: Correct HTTPXRequest init + Starlette Lifespan + Updated Prompts)
+# main.py (Revised: Increased Pool/Timeouts + Robust Callback Handling)
 import os
 import re
 import logging
@@ -24,11 +24,11 @@ from telegram.ext import (
     CallbackQueryHandler,
 )
 from telegram.constants import ParseMode
-from telegram.error import NetworkError, RetryAfter # Import RetryAfter
+from telegram.error import NetworkError, RetryAfter, TimedOut # Import TimedOut
 from telegram.request import HTTPXRequest # Import the request class
 
 # --- Other Libraries ---
-# import httpx # No longer needed for direct import
+import httpx # <<<--- ADDED IMPORT for httpx.Limits
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
@@ -43,6 +43,7 @@ logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     level=logging.DEBUG
 )
+# Reduce log spam from libraries
 logging.getLogger("httpx").setLevel(logging.WARNING)
 if ApifyClient: logging.getLogger("apify_client").setLevel(logging.WARNING)
 logging.getLogger("telegram.ext").setLevel(logging.INFO)
@@ -51,6 +52,7 @@ logging.getLogger("urllib3").setLevel(logging.INFO)
 logging.getLogger('gunicorn.error').setLevel(logging.INFO)
 logging.getLogger('uvicorn').setLevel(logging.INFO)
 logging.getLogger('starlette').setLevel(logging.INFO)
+# Keep our app logger at DEBUG
 logger = logging.getLogger(__name__)
 logger.info("Logging configured.")
 
@@ -60,7 +62,7 @@ ptb_app: Application | None = None
 # --- Environment Variable Loading ---
 logger.info("Attempting to load secrets...")
 def get_secret(secret_name):
-    logger.debug(f"Attempting to read secret: {secret_name}")
+    # logger.debug(f"Attempting to read secret: {secret_name}") # Optional: Less verbose startup
     value = os.environ.get(secret_name)
     if value: logger.info(f"Secret '{secret_name}': Found (Value length: {len(value)})")
     else: logger.warning(f"Secret '{secret_name}': Not Found")
@@ -79,7 +81,6 @@ logger.info("Secret loading attempt finished.")
 #  get_transcript_via_supadata, get_transcript_via_apify,
 #  get_youtube_transcript, get_website_content_via_requests,
 #  get_website_content_via_urltotext_api, generate_summary)
-# Ensure the generate_summary has the updated prompts from previous response
 
 # Helper Functions
 def is_youtube_url(url):
@@ -111,7 +112,8 @@ 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:
-        logger.warning("[Supadata] Making request with verify=False (Attempting to bypass SSL verification)")
+        # Consider removing verify=False if possible, or manage certificates properly
+        logger.warning("[Supadata] Making request with verify=False (Attempting to bypass SSL verification - Potential Security Risk)")
         response = await asyncio.to_thread(requests.get, api_endpoint, headers=headers, params=params, timeout=30, verify=False)
         logger.debug(f"[Supadata] Received status code {response.status_code} for {video_id}")
         if response.status_code == 200:
@@ -253,268 +255,625 @@ async def get_youtube_transcript(video_id: str, video_url: str, supadata_key: st
     except Exception as e:
         logger.warning(f"[Primary YT] Error via library: {type(e).__name__} - {e}")
         if "YouTube is blocking requests" in str(e) or "HTTP Error 429" in str(e): logger.warning("[Primary YT] IP likely blocked.")
-        elif "No transcript found" in str(e): logger.warning("[Primary YT] No transcript in languages.")
-        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e): logger.warning("[Primary YT] Transcripts disabled.")
-        transcript_text = None
+        elif "No transcript found" in str(e): logger.warning("[Primary YT] No transcript in specified languages.")
+        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e): logger.warning("[Primary YT] Transcripts disabled for this video.")
+        transcript_text = None # Ensure it's None on error
 
     if transcript_text is None: # Fallback 1: Supadata
         logger.info("[Fallback YT 1] 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] Success via Supadata. Length: {len(transcript_text)}"); return transcript_text
-            else: logger.warning("[Fallback YT 1] Supadata failed or no content.")
-        else: logger.warning("[Fallback YT 1] Supadata key not available.")
+            else: logger.warning("[Fallback YT 1] Supadata failed or no content found.")
+        else: logger.warning("[Fallback YT 1] Supadata key not available, skipping.")
 
     if transcript_text is None: # Fallback 2: Apify
         logger.info("[Fallback YT 2] 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] Success via Apify. Length: {len(transcript_text)}"); return transcript_text
-            else: logger.warning("[Fallback YT 2] Apify failed or no content.")
-        else: logger.warning("[Fallback YT 2] Apify token not available.")
+            else: logger.warning("[Fallback YT 2] Apify failed or no content found.")
+        else: logger.warning("[Fallback YT 2] Apify token not available, skipping.")
 
-    if transcript_text is None: logger.error(f"All methods failed for video ID: {video_id}")
+    if transcript_text is None: logger.error(f"All methods failed to fetch transcript for video ID: {video_id}")
     return transcript_text
 
 # Website Content via Requests/BS4
 async def get_website_content_via_requests(url):
     """Attempts to scrape website content using requests/BeautifulSoup."""
-    if not url: logger.error("[Web Scraper - Requests/BS4] no URL"); return None
-    logger.info(f"[Web Scraper - Requests/BS4] Fetching: {url}")
+    if not url: logger.error("[Web Scraper - Requests/BS4] get_website_content_via_requests called with no URL"); return None
+    logger.info(f"[Web Scraper - Requests/BS4] Attempting fetch: {url}")
     try:
-        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'}
+        # Standard headers, avoid overly aggressive scraping patterns
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36', # Updated UA
+            '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 header
+            'Upgrade-Insecure-Requests': '1'
+        }
         response = await asyncio.to_thread(requests.get, url, headers=headers, timeout=25, allow_redirects=True)
-        response.raise_for_status()
+        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
         logger.debug(f"[Web Scraper - Requests/BS4] Status {response.status_code} for {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}. Plain text?")
-            if 'text/plain' in content_type and response.text: return response.text.strip()
+            logger.warning(f"[Web Scraper - Requests/BS4] Non-HTML content type received: {content_type}. Attempting plain text extraction.")
+            # Allow plain text only if explicitly text/plain
+            if 'text/plain' in content_type and response.text:
+                 logger.info(f"[Web Scraper - Requests/BS4] Extracted plain text content. Length: {len(response.text.strip())}")
+                 return response.text.strip()
+            logger.warning(f"[Web Scraper - Requests/BS4] Content type '{content_type}' not suitable for parsing. Aborting.")
             return None
+
         soup = BeautifulSoup(response.text, 'html.parser')
-        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')
+
+        # Remove common non-content tags more aggressively
+        tags_to_remove = ["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "label", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio", "picture", "source"]
+        # Also remove elements often used for ads or menus by class/id
+        selectors_to_remove = ['.ad', '#ad', '.ads', '#ads', '.advertisement', '#advertisement', '.banner', '#banner', '.menu', '#menu', '.navigation', '#navigation', '.sidebar', '#sidebar', '.social', '#social', '.share', '#share', '.related', '#related', '.comments', '#comments', '.cookie-consent', '#cookie-consent']
+
+        for tag in soup(tags_to_remove): tag.decompose()
+        for selector in selectors_to_remove:
+            for element in soup.select(selector): element.decompose()
+
+        # Try to find semantic main content areas first
+        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] No body/main content for {url}"); return None
+        if not target_element:
+            logger.warning(f"[Web Scraper - Requests/BS4] Could not find a suitable target element (main, article, body) for {url}");
+            return None
+
+        # Extract text, attempting to preserve paragraphs better
         lines = [line.strip() for line in target_element.get_text(separator='\n', strip=True).splitlines() if line.strip()]
-        text = "\n".join(lines)
-        MIN_TEXT_LENGTH = 50
-        if not text or len(text) < MIN_TEXT_LENGTH: logger.warning(f"[Web Scraper - Requests/BS4] Text too short (<{MIN_TEXT_LENGTH} chars) for {url} (Len: {len(text)})")
-        logger.info(f"[Web Scraper - Requests/BS4] Success scraping {url} (Len: {len(text)})")
+        text = "\n\n".join(lines) # Join lines with double newline for paragraph separation
+
+        MIN_TEXT_LENGTH = 100 # Increased minimum length
+        if not text or len(text) < MIN_TEXT_LENGTH:
+             logger.warning(f"[Web Scraper - Requests/BS4] Extracted text is too short (<{MIN_TEXT_LENGTH} chars) after cleaning for {url}. Length: {len(text)}. Content might be JS-rendered or blocked.")
+             # Optional: Log the short text for debugging: logger.debug(f"Short text: {text[:500]}")
+             return None # Treat very short text as failure
+
+        logger.info(f"[Web Scraper - Requests/BS4] Successfully scraped and cleaned content from {url}. Final Length: {len(text)}")
         return text
-    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - Requests/BS4] Timeout: {url}"); return None
-    except requests.exceptions.TooManyRedirects: logger.error(f"[Web Scraper - Requests/BS4] Redirects: {url}"); return None
-    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - Requests/BS4] Request error {url}: {e}"); return None
-    except Exception as e: logger.error(f"[Web Scraper - Requests/BS4] Parsing error {url}: {e}", exc_info=True); return None
+
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - Requests/BS4] Timeout error fetching {url}"); return None
+    except requests.exceptions.TooManyRedirects: logger.error(f"[Web Scraper - Requests/BS4] Too many redirects error for {url}"); return None
+    except requests.exceptions.HTTPError as e: logger.error(f"[Web Scraper - Requests/BS4] HTTP error {e.response.status_code} for {url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - Requests/BS4] General request error for {url}: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - Requests/BS4] Error during parsing or processing {url}: {e}", exc_info=True); return None
 
 # 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."""
-    if not url: logger.error("[Web Scraper - URLToText API] no URL"); return None
-    if not api_key: logger.error("[Web Scraper - URLToText API] API key missing."); return None
-    logger.info(f"[Web Scraper - URLToText API] Attempting fetch: {url}")
+    if not url: logger.error("[Web Scraper - URLToText API] get_website_content_via_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 fetch via API: {url}")
     api_endpoint = "https://urltotext.com/api/v1/urltotext/"
-    payload = json.dumps({"url": url, "output_format": "text", "extract_main_content": True, "render_javascript": True, "residential_proxy": False})
+    # Ensure payload includes options beneficial for scraping modern sites
+    payload = json.dumps({
+        "url": url,
+        "output_format": "text",
+        "extract_main_content": True, # Try to get just the core article/content
+        "render_javascript": True,   # Crucial for JS-heavy sites
+        "residential_proxy": False,  # Set to True if facing blocks, requires appropriate plan
+        "timeout_render": 20000,     # Increase JS render timeout (in ms)
+    })
     headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
     try:
-        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=45)
-        logger.debug(f"[Web Scraper - URLToText API] Status {response.status_code} for {url}")
+        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=60) # Increased overall timeout
+        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"); credits = data.get("credits_used", "N/A"); 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] Success via API. Length: {len(content)}. Credits: {credits}"); return content.strip()
-                else: logger.warning(f"[Web Scraper - URLToText API] API success (200) but content empty. Resp: {data}"); return None
-            except json.JSONDecodeError: logger.error(f"[Web Scraper - URLToText API] Failed JSON decode. Status: {response.status_code}. Resp: {response.text[:500]}..."); return None
-            except Exception as e: logger.error(f"[Web Scraper - URLToText API] Error processing API response: {e}", exc_info=True); return None
-        elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400). Resp: {response.text[:200]}...")
-        elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401). Check Key. Resp: {response.text[:200]}...")
-        elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402). Check credits. Resp: {response.text[:200]}...")
-        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL (422). Resp: {response.text[:200]}...")
-        elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] Server Error ({response.status_code}). Resp: {response.text[:200]}...")
-        else: logger.error(f"[Web Scraper - URLToText API] Unexpected status {response.status_code}. Resp: {response.text[:200]}...")
-        return None
-    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout: {url}"); return None
-    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - URLToText API] Request error: {e}"); return None
-    except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error: {e}", exc_info=True); return None
+                content_data = data.get("data", {})
+                content = content_data.get("content")
+                credits = data.get("credits_used", "N/A")
+                warning = content_data.get("warning")
+                error_msg = content_data.get("error") # Check for specific error in response data
+
+                if warning: logger.warning(f"[Web Scraper - URLToText API] API Warning for {url}: {warning}")
+                if error_msg: logger.error(f"[Web Scraper - URLToText API] API Error reported for {url}: {error_msg}"); return None # Treat API error as failure
+
+                if content and isinstance(content, str):
+                    logger.info(f"[Web Scraper - URLToText API] Successfully fetched content via API. Length: {len(content.strip())}. Credits Used: {credits}");
+                    return content.strip()
+                else:
+                    logger.warning(f"[Web Scraper - URLToText API] API returned status 200 but content is empty or invalid for {url}. Response: {data}");
+                    return None
+            except json.JSONDecodeError: logger.error(f"[Web Scraper - URLToText API] Failed to decode JSON response from API. 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: {e}", exc_info=True); return None
+        elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400) to API. Check payload/URL. Response: {response.text[:200]}...")
+        elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401). Check API Key. Response: {response.text[:200]}...")
+        elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402). Check API credits/plan. Response: {response.text[:200]}...")
+        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL / Fetch Error (422) reported by API for {url}. Response: {response.text[:200]}...") # Might mean the site blocked the API
+        elif response.status_code == 429: logger.warning(f"[Web Scraper - URLToText API] Rate Limit Hit (429). Response: {response.text[:200]}...")
+        elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] API Server Error ({response.status_code}). Response: {response.text[:200]}...")
+        else: logger.error(f"[Web Scraper - URLToText API] Unexpected status code {response.status_code} from API. Response: {response.text[:200]}...")
+        return None # Return None for all non-200 responses after logging
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout 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: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error during API call: {e}", exc_info=True); return None
 
 # DeepSeek Summary Function (with updated prompts)
 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. 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"; model_name = "deepseek/deepseek-chat:free"
+    if not api_key: logger.error("OpenRouter API key missing."); return "Error: AI service configuration key is missing."
+    if not text or not text.strip(): logger.warning("generate_summary called with empty or whitespace-only text."); return "Error: No content was provided to summarize."
+
+    openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
+    # Consider using a non-free model if rate limits are hit or quality needed
+    model_name = "deepseek/deepseek-chat:free"
+    # model_name = "openai/gpt-3.5-turbo" # Example alternative
 
     # --- UPDATED PROMPTS ---
     if summary_type == "paragraph":
-        prompt = (
-            "You are an AI model designed to provide concise summaries using British English spellings. "
-            "Your output should be:\n"
-            "• Clear and simple, use a level of language and vocabulary such that someone who isn’t familiar with the topic mentioned would still be able to understand, keeping British spellings throughout.\n"
-            "• Use straightforward and understandable language. Avoid overly complex or advanced vocabulary.\n"
-            "• Presented in one paragraph.\n"
-            "• A summary that is no more than 85 words; ensure it remains concise.\n"
-            "• Consider the entire text’s content, not just the beginning or a few topics: give equal attention to all parts.\n"
-            "• Do not use em dash (– or —) symbols; use semicolons instead.\n\n"
-            "Now, please summarize the following text according to these rules:"
+        system_message = (
+            "You are an expert summarization AI. Your goal is to provide a concise, easy-to-understand summary of the provided text. "
+            "Follow these instructions precisely:\n"
+            "1.  **Language and Spelling:** Use simple British English. Ensure all spellings conform to British English (e.g., 'summarise', 'centre', 'realise').\n"
+            "2.  **Clarity:** Write clearly so someone unfamiliar with the topic can understand.\n"
+            "3.  **Format:** Output a single paragraph only.\n"
+            "4.  **Conciseness:** The summary must be **no more than 85 words** long.\n"
+            "5.  **Completeness:** Cover the main points from the entire text, not just the start.\n"
+            "6.  **Punctuation:** Do NOT use em dashes (– or —). Use semicolons (;) if needed for complex sentence structure, but prefer simpler sentences.\n"
+            "7.  **Tone:** Maintain a neutral and informative tone.\n"
+            "8.  **Focus:** Extract factual information and key topics. Do not add opinions or information not present in the text."
         )
+        user_prompt_instruction = "Summarize the following text into a single paragraph adhering strictly to the rules outlined in the system message:"
+
     elif summary_type == "points":
-        prompt = (
-            "You are an AI model designed to provide concise summaries using British English spellings.\n"
-            "Your output should be:\n"
-            "• Clear and simple, use a level of language and vocabulary such that someone who isn’t familiar with the topic mentioned would still be able to understand, keeping British spellings throughout.\n"
-            "• Use straightforward and understandable language. Avoid overly complex or advanced vocabulary.\n"
-            "• Presented as clear, distinct bullet points (using '*' or '-' at the start of each point).\n"
-            "• Each point should highlight a key piece of information, finding, or main topic discussed.\n"
-            "• Consider the entire text’s content, not just the beginning or a few topics: give equal attention to all parts.\n"
-            "• Do not use em dash (– or —) symbols; use semicolons instead.\n\n"
-            "Now, please summarize the following text into bullet points according to these rules:"
+        system_message = (
+            "You are an expert summarization AI. Your goal is to extract the key points from the provided text and present them as a bulleted list. "
+            "Follow these instructions precisely:\n"
+            "1.  **Language and Spelling:** Use simple British English. Ensure all spellings conform to British English (e.g., 'summarise', 'centre', 'realise').\n"
+            "2.  **Clarity:** Write clearly so someone unfamiliar with the topic can understand.\n"
+            "3.  **Format:** Output as a bulleted list. Start each point with a standard bullet character ('*' or '-'). Each point should be distinct and on a new line.\n"
+            "4.  **Content:** Each bullet point should represent a single key finding, main topic, or significant piece of information from the text.\n"
+            "5.  **Conciseness:** Keep each bullet point brief and to the point.\n"
+            "6.  **Completeness:** Cover the main points from the entire text, not just the start.\n"
+            "7.  **Punctuation:** Do NOT use em dashes (– or —) within bullet points.\n"
+            "8.  **Tone:** Maintain a neutral and informative tone.\n"
+            "9.  **Focus:** Extract factual information and key topics. Do not add opinions or information not present in the text."
         )
+        user_prompt_instruction = "Summarize the following text into a bulleted list adhering strictly to the rules outlined in the system message:"
     else:
-        logger.error(f"Invalid summary_type '{summary_type}'.");
-        return f"Error: Invalid summary type ('{summary_type}')."
+        logger.error(f"Invalid summary_type '{summary_type}' requested.")
+        return f"Error: Invalid summary type ('{summary_type}') requested. Please choose 'paragraph' or 'points'."
     # --- END UPDATED PROMPTS ---
 
-    MAX_INPUT_LENGTH = 500000 # Keep practical limit
-    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 ---"
+    # Practical limit for API context window / cost control
+    # Deepseek context might be larger, but set a reasonable app limit
+    MAX_INPUT_TOKENS_ESTIMATE = 28000 # Rough estimate for deepseek-chat's context limit (aim lower than max)
+    # Simple character length heuristic (adjust based on typical content)
+    AVG_CHARS_PER_TOKEN = 4
+    MAX_INPUT_LENGTH = MAX_INPUT_TOKENS_ESTIMATE * AVG_CHARS_PER_TOKEN
+
+    if len(text) > MAX_INPUT_LENGTH:
+        logger.warning(f"Input text length ({len(text)} chars) exceeds estimated limit ({MAX_INPUT_LENGTH}). Truncating.")
+        truncation_marker = "\n\n[... Text truncated due to length ...]"
+        text = text[:MAX_INPUT_LENGTH - len(truncation_marker)] + truncation_marker
+
+    # Construct the messages payload for the API
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": f"{user_prompt_instruction}\n\n--- TEXT TO SUMMARIZE ---\n\n{text}\n\n--- END OF TEXT ---"}
+    ]
 
-    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Replace with actual space if needed
-    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}]})
+    # Referer and Title for OpenRouter identification
+    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Replace default if needed
+    referer_url = f"https://{space_host}" if space_host and not space_host.startswith("http") else space_host or "https://huggingface.co"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": referer_url,
+        "X-Title": "Telegram URL Summarizer Bot" # Or your bot's name
+    }
+    payload = json.dumps({"model": model_name, "messages": messages})
 
     try:
-        logger.debug(f"Sending request to OpenRouter (Model: {model_name})...")
-        response = await asyncio.to_thread(requests.post, openrouter_api_endpoint, headers=headers, data=payload, timeout=90)
+        logger.debug(f"Sending request to OpenRouter (Model: {model_name}). Prompt length approx: {len(text)} chars.")
+        # Increased timeout for potentially long AI generation
+        response = await asyncio.to_thread(requests.post, openrouter_api_endpoint, headers=headers, data=payload, timeout=120)
         logger.debug(f"Received status {response.status_code} from OpenRouter.")
+
         if response.status_code == 200:
             try:
                 data = response.json()
-                if data.get("choices") and isinstance(data["choices"], list) and len(data["choices"]) > 0:
-                    message = data["choices"][0].get("message")
-                    if message and message.get("content"):
-                        summary = message["content"].strip()
-                        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 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."
+                # Check for response structure variations
+                choice = data.get("choices", [{}])[0]
+                message = choice.get("message", {})
+                summary = message.get("content")
+                finish_reason = choice.get("finish_reason")
+
+                if summary and isinstance(summary, str) and summary.strip():
+                    summary = summary.strip()
+                    logger.info(f"Successfully generated summary. Finish Reason: {finish_reason}. Length: {len(summary)}")
+                    # Optional: Add post-processing checks (e.g., length for paragraph)
+                    if summary_type == "paragraph" and len(summary.split()) > 95: # Allow slight overrun from 85 words
+                         logger.warning(f"Generated paragraph summary slightly longer than target word count ({len(summary.split())} words).")
+                    return summary
+                else:
+                    logger.warning(f"OpenRouter returned status 200 but summary content is missing or empty. Response data: {data}")
+                    return "Sorry, the AI model returned an empty summary. The content might have been unsuitable."
+
+            except (json.JSONDecodeError, IndexError, KeyError, AttributeError) as e:
+                logger.error(f"Failed to parse successful (200) response from OpenRouter. Error: {e}. Response Text: {response.text[:500]}...", exc_info=True)
+                return "Sorry, there was an issue parsing the response from the AI service."
+            except Exception as e:
+                logger.error(f"Unexpected error processing OpenRouter success response: {e}", exc_info=True)
+                return "Sorry, an unexpected error occurred while processing the AI response."
+
+        # Handle specific HTTP error codes from OpenRouter
+        elif response.status_code == 401: logger.error("OpenRouter API key is invalid (Unauthorized - 401)."); return "Error: AI service authentication failed. Please check the configuration."
+        elif response.status_code == 402: logger.error("OpenRouter Payment Required (402). Check credits/limits."); return "Sorry, there's an issue with the AI service account limits or payment."
+        elif response.status_code == 429: logger.warning("OpenRouter Rate Limit Hit (429)."); return "Sorry, the AI model is currently busy due to high demand. Please try again in a moment."
+        elif response.status_code == 400: logger.error(f"OpenRouter Bad Request (400). Likely prompt issue. Response: {response.text[:500]}..."); return "Sorry, the request to the AI service was invalid (possibly due to the content or prompt)."
+        elif response.status_code >= 500: logger.error(f"OpenRouter Server Error ({response.status_code}). Response: {response.text[:500]}..."); return "Sorry, the AI service is experiencing internal issues. Please 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."
+             # Handle other unexpected errors
+             logger.error(f"Unexpected HTTP status {response.status_code} from OpenRouter. Response: {response.text[:500]}...")
+             try: # Try to extract an error message from the response body
+                 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 json.JSONDecodeError:
+                 return f"Sorry, the AI service returned an unexpected error (Status: {response.status_code})."
+
+    except requests.exceptions.Timeout: logger.error("Timeout connecting to OpenRouter API."); return "Sorry, the request to the AI model timed out. Please try again."
+    except requests.exceptions.RequestException as e: logger.error(f"Request error connecting to OpenRouter API: {e}"); return "Sorry, there was a network error connecting to the AI model service."
+    except Exception as e: logger.error(f"Unexpected error occurred within generate_summary function: {e}", exc_info=True); return "Sorry, an unexpected internal error occurred while generating the summary."
 
 
 # --- Telegram Bot Handlers ---
 
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    user = update.effective_user;
-    if not user: return
-    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) /start.")
+    """Handles the /start command."""
+    user = update.effective_user
+    if not user: return # Should not happen with a command
+    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) initiated /start.")
+    # Use mention_html for linking username if available, otherwise just first name
     mention = user.mention_html() if user.username else user.first_name
-    await update.message.reply_html(f"👋 Hello {mention}! Send a URL to summarize.")
+    start_message = (
+        f"👋 Hello {mention}!\n\n"
+        "I can summarise YouTube videos or web articles for you.\n\n"
+        "Just send me a link (URL) and I'll ask you whether you want the summary as a paragraph or bullet points.\n\n"
+        "Type /help for more details."
+    )
+    await update.message.reply_html(start_message)
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    user = update.effective_user; logger.info(f"User {user.id if user else '?'} /help.")
-    help_text = ("**How:**\n1. Send URL.\n2. Choose Paragraph/Points.\n3. Get summary!\n\n"
-                 "**Notes:**\n- YT transcripts can fail.\n- Complex sites hard to scrape.\n- AI errors possible.")
+    """Handles the /help command."""
+    user = update.effective_user
+    logger.info(f"User {user.id if user else '?'} requested /help.")
+    help_text = (
+        "**How to Use Me:**\n"
+        "1.  Send me a direct link (URL) to a YouTube video or a web article.\n"
+        "2.  I will ask you to choose the summary format: `Paragraph` or `Points`.\n"
+        "3.  Click the button for your preferred format.\n"
+        "4.  I'll fetch the content, summarise it using AI, and send it back to you!\n\n"
+        "**Important Notes:**\n"
+        "- **YouTube:** Getting transcripts can sometimes fail if they are disabled, unavailable for the video's language, or if YouTube temporarily blocks requests.\n"
+        "- **Websites:** I do my best to extract the main article content, but complex websites (especially those heavily reliant on JavaScript or with strong anti-scraping measures) might not work perfectly. I have a fallback service to help with tricky sites.\n"
+        "- **AI Summaries:** The AI tries its best to be accurate and follow the requested format, but errors or unexpected outputs are possible.\n"
+        "- **Length:** Very long articles or videos might be truncated before summarization to fit within processing limits.\n\n"
+        "Just send a link to get started!"
+    )
+    # Use MarkdownV2 for better formatting control if needed, but MARKDOWN is simpler
     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
-    message_text = update.message.text.strip(); user = update.effective_user;
-    if not user: return
-    url_pattern = r'https?://[^\s/$.?#].[^\s]*'; match = re.search(url_pattern, message_text)
+    message_text = update.message.text.strip()
+    user = update.effective_user
+    if not user: return # Should not happen with a message
+
+    # More robust URL regex (handles various protocols, domains, paths, queries)
+    # Still simple, not aiming for perfect RFC 3986 validation
+    url_pattern = r'https?://(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}(?:/[^\s]*)?'
+    match = re.search(url_pattern, message_text)
+
     if match:
-        url = match.group(0); logger.info(f"User {user.id} sent 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")]]
+        url = match.group(0)
+        logger.info(f"User {user.id} sent potential URL: {url}")
+
+        # Store 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}")
+
+        keyboard = [
+            [
+                InlineKeyboardButton("📜 Paragraph Summary", callback_data="paragraph"),
+                InlineKeyboardButton("🔹 Bullet Points", callback_data="points")
+            ]
+        ]
         reply_markup = InlineKeyboardMarkup(keyboard)
-        await update.message.reply_text(f"Link:\n{url}\n\nChoose summary type:", reply_markup=reply_markup, link_preview_options={'is_disabled': True})
-    else: logger.debug(f"Ignoring non-URL from {user.id}: {message_text[:100]}")
+
+        # Send message asking for summary type
+        await update.message.reply_text(
+            f"✅ Link received:\n`{url}`\n\nChoose your desired summary format:",
+            reply_markup=reply_markup,
+            parse_mode=ParseMode.MARKDOWN,
+            link_preview_options={'is_disabled': True} # Disable link preview for this message
+        )
+    else:
+        # If it doesn't look like a URL, maybe provide guidance?
+        # logger.debug(f"Ignoring non-URL message from {user.id}: {message_text[:100]}")
+        # Optional: Reply if it's not a command and not a URL
+        if not message_text.startswith('/'):
+             await update.message.reply_text("Please send me a valid URL (starting with http:// or https://) to summarize.")
+
 
 async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    query = update.callback_query; user = query.from_user
-    try: await query.answer(); logger.debug(f"Answered query {query.id}")
-    except Exception as e: logger.error(f"Failed answer 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: '{url}'.")
+    """Handles button presses for choosing summary type."""
+    query = update.callback_query
+    if not query or not query.from_user:
+        logger.warning("Callback query or user missing in update.")
+        return # Can't proceed without query/user
+    user = query.from_user
+
+    # --- Answer Callback Query Immediately ---
+    try:
+        await query.answer() # Acknowledge the button press
+        logger.debug(f"Answered callback query {query.id} for user {user.id}")
+    except TimedOut:
+        # Log timeout but proceed; the button loading indicator might just hang for the user
+        logger.warning(f"Timeout answering callback query {query.id} for user {user.id}. Processing continues.")
+    except Exception as e:
+        # Log other errors but proceed cautiously. The button might remain "loading".
+        logger.error(f"Error answering callback query {query.id} for user {user.id}: {e!r}", exc_info=True)
+
+    summary_type = query.data # 'paragraph' or 'points'
+    # Retrieve URL stored earlier for this user
+    url = context.user_data.get('url_to_summarize')
+    logger.info(f"User {user.id} chose summary type '{summary_type}'. Checking for stored URL.")
+
     if not url:
-        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: 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'}")
+        logger.warning(f"User {user.id} pressed button '{summary_type}', but NO URL found in user_data context.")
+        try:
+            # Inform user context was lost (e.g., bot restarted, long delay)
+            await query.edit_message_text(text="⚠️ Oops! I lost the context for that link. Please send the link again.")
+        except TimedOut:
+             logger.error(f"Timeout trying to edit message to inform user {user.id} about lost context.")
+        except Exception as edit_err:
+            # Log error if editing fails (message might already be gone, or other Telegram issue)
+            logger.error(f"Failed to edit message for lost context for user {user.id}: {edit_err}")
+        return # Stop processing if URL is missing
+
+    # --- URL Found - Proceed with Processing ---
+    logger.info(f"Processing URL '{url}' for user {user.id} with type '{summary_type}'.")
+    # Clear the URL from context now that we're processing it
+    context.user_data.pop('url_to_summarize', None)
+    logger.debug(f"Cleared URL from user_data for user {user.id}")
+
+    # Fetch current API keys (allows for potential runtime changes, though unlikely here)
+    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')
+    # Simple check log
+    keys_present = f"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'}"
+    logger.debug(f"API Key check for user {user.id} request: {keys_present}")
+
+    # Critical dependency check: AI key
     if not current_openrouter_key:
-        logger.error("OpenRouter key missing.");
-        try: await query.edit_message_text(text="⚠️ AI service config error (key missing).")
-        except Exception as edit_err: logger.error(f"Failed edit on missing OR key: {edit_err}")
+        logger.error(f"CRITICAL: OpenRouter API key is missing. Cannot generate summary for user {user.id}.")
+        try:
+            await query.edit_message_text(text="❌ Configuration Error: The AI summarization service is not configured correctly. Please contact the administrator.")
+        except TimedOut:
+             logger.error(f"Timeout editing message to inform user {user.id} about missing AI key.")
+        except Exception as edit_err:
+            logger.error(f"Failed to edit message for missing AI key for user {user.id}: {edit_err}")
         return
-    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:
-        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
+
+    # --- Inform User Processing Has Started ---
+    processing_message_text = f"⏳ Working on your '{summary_type}' summary for the link...\n_(This might take up to a minute depending on the content)_"
+    message_to_edit = query.message # The message with the buttons
+    status_message_sent = None      # Will hold msg ID if we send a new status message
+
+    try:
+        if message_to_edit:
+            await query.edit_message_text(text=processing_message_text)
+            logger.debug(f"Edited original message {message_to_edit.message_id} to show 'Working...' status for query {query.id}")
+        else:
+             # This case should be rare if query.message exists, but handle defensively
+             logger.warning(f"Original message (query.message) not found for query {query.id}. Cannot edit, will send new status message.")
+             raise ValueError("Original message object missing") # Force fallback to sending new message
+    except (TimedOut, Exception) as e:
+        # If editing fails (e.g., message too old, deleted, rate limit), try sending a new message
+        logger.warning(f"Could not edit original message {message_to_edit.message_id if message_to_edit else 'N/A'} for query {query.id}: {e!r}. Attempting to send a new status message.")
+        message_to_edit = None # Ensure we don't try to delete this later if editing failed
+        try:
+            status_message_sent = await context.bot.send_message(chat_id=user.id, text=processing_message_text)
+            logger.debug(f"Sent new status message {status_message_sent.message_id} to user {user.id}.")
+        except TimedOut:
+            logger.error(f"Timeout sending NEW 'Working...' status message to user {user.id}. Processing continues without feedback.")
+            # User won't know bot is working - proceed anyway, hope for the best.
+        except Exception as send_err:
+            logger.error(f"Failed sending NEW 'Working...' status message to user {user.id}: {send_err}. Processing continues without feedback.")
+            # As above.
+
+    # --- Main Content Fetching and Summarization ---
+    content = None
+    user_feedback_message = None # Holds error/status messages for the user
+    success = False              # Tracks if we successfully sent a summary
+
     try:
-        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}")
+        # Send 'typing' action to indicate activity
+        try:
+            logger.debug(f"Sending 'typing' chat action to chat {user.id}")
+            await context.bot.send_chat_action(chat_id=user.id, action='typing')
+        except TimedOut: logger.warning(f"Timeout sending 'typing' action for user {user.id}.")
+        except Exception as ca_err: logger.warning(f"Failed sending 'typing' action for user {user.id}: {ca_err}")
+
+        # --- Determine Content Type and Fetch ---
+        is_yt = is_youtube_url(url)
+        logger.debug(f"URL ({url}) is YouTube: {is_yt} (User: {user.id})")
+
         if is_yt:
             video_id = extract_youtube_id(url)
             if video_id:
-                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."
+                logger.info(f"Fetching YouTube transcript for video ID: {video_id} (User: {user.id})")
+                content = await get_youtube_transcript(video_id, url, current_supadata_key, current_apify_token)
+                if not content:
+                    logger.warning(f"Failed to get YouTube transcript for {video_id} (User: {user.id}).")
+                    user_feedback_message = "⚠️ Sorry, I couldn't retrieve the transcript for that YouTube video. It might be unavailable, private, have captions disabled, or an error occurred."
+                else:
+                     logger.info(f"Successfully fetched YouTube transcript for {video_id}. Length: {len(content)} (User: {user.id})")
+            else:
+                logger.warning(f"Failed to extract YouTube video ID from URL: {url} (User: {user.id})")
+                user_feedback_message = "⚠️ Sorry, I couldn't identify a valid YouTube video ID in the link you provided."
         else:
-            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
+            # --- Website Scraping ---
+            logger.info(f"Attempting website scrape (Requests/BS4) for URL: {url} (User: {user.id})")
+            content = await get_website_content_via_requests(url)
+            if content:
+                logger.info(f"Website scrape successful (Requests/BS4). Length: {len(content)} (User: {user.id})")
+                # Content found, no need for feedback message yet
             else:
-                logger.warning(f"Website scrape failed for {url}. Trying URLToText API.");
+                logger.warning(f"Primary website scrape failed for {url} (User: {user.id}). Trying fallback API.")
                 if current_urltotext_key:
-                    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)."
+                    # Send typing again if first scrape failed and we try another method
+                    try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before fallback scrape.")
+                    except: pass # Ignore if fails
+
+                    logger.info(f"Attempting website scrape via URLToText API for: {url} (User: {user.id})")
+                    content = await get_website_content_via_urltotext_api(url, current_urltotext_key)
+                    if content:
+                        logger.info(f"Website scrape successful via URLToText API. Length: {len(content)} (User: {user.id})")
+                    else:
+                        logger.warning(f"Fallback website scrape (URLToText API) also failed for {url} (User: {user.id}).")
+                        user_feedback_message = "⚠️ Sorry, I couldn't fetch the content from that website using available methods. It might be protected or structured in a way I can't parse."
+                else:
+                    # Fallback key missing
+                    logger.warning(f"Primary scrape failed and URLToText API key not configured. Cannot fallback for {url} (User: {user.id}).")
+                    user_feedback_message = "⚠️ Sorry, I couldn't fetch the content from that website, and the fallback service isn't configured."
+
+        # --- Generate Summary if Content Was Fetched ---
         if content:
-            logger.info("Content found, generating summary."); await context.bot.send_chat_action(chat_id=user.id, action='typing')
+            logger.info(f"Content fetched (Length: {len(content)}). Generating '{summary_type}' summary for user {user.id}.")
+            # Send typing before potentially long AI call
+            try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before AI summary generation.")
+            except: pass
+
             summary = await generate_summary(content, summary_type, current_openrouter_key)
-            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)
+
+            # Check if summary generation returned an error message
+            if summary.startswith("Error:") or summary.startswith("Sorry,"):
+                logger.warning(f"AI summary generation failed for user {user.id}. Reason: {summary}")
+                user_feedback_message = f"⚠️ {summary}" # Use the error message from generate_summary
+            else:
+                # --- Summary Success - Send to User ---
+                logger.info(f"Summary generated successfully for user {user.id}. Length: {len(summary)}. Sending result.")
+                try:
+                    await context.bot.send_message(
+                        chat_id=user.id,
+                        text=summary,
+                        parse_mode=ParseMode.MARKDOWN, # Assuming AI generates markdown for points
+                        link_preview_options={'is_disabled': True}
+                    )
+                    success = True
+                    user_feedback_message = None # Clear any previous fetching error message
+                    logger.info(f"Successfully sent summary to user {user.id}.")
+                except TimedOut:
+                    logger.error(f"Timeout sending final summary message to user {user.id}.")
+                    user_feedback_message = "⚠️ Sorry, there was a timeout while trying to send you the final summary."
+                    success = False # Mark as failed if sending timed out
+                except Exception as send_final_err:
+                    logger.error(f"Failed sending final summary to user {user.id}: {send_final_err}", exc_info=True)
+                    user_feedback_message = "⚠️ Sorry, an unexpected error occurred while sending the final summary."
+                    success = False # Mark as failed
+
+        elif not user_feedback_message:
+             # If content is None, but no specific error message was set above, set a generic one.
+             logger.warning(f"Content retrieval resulted in None, but no specific user feedback message was set. URL: {url} (User: {user.id})")
+             user_feedback_message = "⚠️ Sorry, I couldn't retrieve any usable content from the link provided."
+
+        # --- Send Final Feedback Message if Processing Failed ---
+        if user_feedback_message and not success:
+            logger.warning(f"Processing failed or summary sending failed for user {user.id}. Sending feedback: {user_feedback_message}")
+            try:
+                await context.bot.send_message(chat_id=user.id, text=user_feedback_message)
+            except TimedOut:
+                logger.error(f"Timeout sending final FAILURE feedback message to user {user.id}.")
+            except Exception as send_feedback_err:
+                 logger.error(f"Failed sending final FAILURE feedback message to user {user.id}: {send_feedback_err}")
+
     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}")
+        # Catch-all for unexpected errors during the main processing block
+        logger.error(f"Unexpected critical error during callback processing for user {user.id}, URL {url}: {e}", exc_info=True)
+        try:
+            # Send a generic error message to the user
+            await context.bot.send_message(chat_id=user.id, text="❌ Oops! An unexpected internal error occurred while processing your request. The issue has been logged.")
+        except TimedOut:
+            logger.error(f"Timeout sending CRITICAL internal error feedback message to user {user.id}.")
+        except Exception as final_err:
+            # If even sending the error message fails, log it.
+            logger.error(f"Failed sending CRITICAL internal error feedback message to user {user.id}: {final_err}")
+        # Ensure success is False if we hit this block
+        success = False
+
     finally:
-        logger.debug("Cleaning up status message...");
+        # --- Clean up Status Message(s) ---
+        logger.debug(f"Cleaning up status message(s) for user {user.id}, query {query.id}. Success={success}")
         try:
-             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}")
+            if status_message_sent:
+                # If we sent a separate "Working..." message, delete it regardless of success/failure
+                # as the final result or error message has been (or attempted to be) sent.
+                await context.bot.delete_message(chat_id=user.id, message_id=status_message_sent.message_id)
+                logger.debug(f"Deleted separate status message {status_message_sent.message_id} for user {user.id}.")
+            elif message_to_edit:
+                # If we edited the original message with the buttons...
+                if success:
+                    # If processing succeeded, delete the "Working..." message.
+                    await query.delete_message()
+                    logger.debug(f"Processing succeeded. Deleted original (edited) message {message_to_edit.message_id} for query {query.id}.")
+                else:
+                    # If processing failed, *don't* delete the message.
+                    # It either still shows "Working..." (if sending final error failed)
+                    # or it might show an error message if edit_message_text was used for that.
+                    # Let's try to edit it one last time to show a generic failure if no specific feedback was sent.
+                    # This is complex, maybe just leave it as is for simplicity.
+                    logger.debug(f"Processing failed. Leaving edited message {message_to_edit.message_id} in place for query {query.id}.")
+                    # Optional: Try one last edit to show failure if needed, but might be overkill
+                    # if not user_feedback_message: # Only if no other error was sent
+                    #    try: await query.edit_message_text("❌ Processing failed.")
+                    #    except: pass # Ignore errors here
+
+            # If message_to_edit was None (original edit failed) and status_message_sent was None (sending new status failed), there's nothing to delete here.
+
+        except TimedOut:
+            logger.warning(f"Timeout attempting to delete status/button message for user {user.id}, query {query.id}.")
+        except Exception as del_e:
+            # Log deletion errors as warnings, not critical if cleanup fails.
+            # Common error: message already deleted or trying to delete too late.
+            logger.warning(f"Could not delete status/button message for user {user.id}, query {query.id}: {del_e!r}")
+
+        # Log the completion of the callback handling
+        logger.info(f"Finished handling callback query {query.id} for user {user.id}. Overall Success: {success}")
+
 
 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)
+    # Add specific error type handling if needed (e.g., NetworkError, TimedOut)
+    if isinstance(context.error, TimedOut):
+        logger.warning("A timeout error occurred in PTB communication.")
+    elif isinstance(context.error, NetworkError):
+        logger.warning(f"A network error occurred: {context.error}")
+    # Consider notifying admin or user for specific critical errors if appropriate
 
-# --- Bot Setup Function (Modified: Configure HTTPX Client) ---
+# --- Bot Setup Function (Modified: Increased Pool/Timeouts) ---
 async def setup_bot_config() -> Application:
     """Configures the PTB Application with custom HTTPX settings."""
     logger.info("Configuring Telegram Application...")
@@ -522,44 +881,58 @@ async def setup_bot_config() -> Application:
         logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable not found.")
         raise ValueError("TELEGRAM_TOKEN environment variable not set.")
 
-    # --- Configure HTTPX client settings via individual parameters ---
-    # Increased read/pool timeouts slightly, connect timeout standard.
-    # No direct way to set keepalive_expiry via HTTPXRequest in PTB v20.
-    connect_timeout = 5.0
-    read_timeout = 15.0  # Slightly increased
-    write_timeout = 15.0 # Matching read timeout
-    pool_timeout = 15.0  # Slightly increased pool timeout
+    # --- Configure HTTPX client settings ---
+    connect_timeout = 10.0 # Slightly higher connect timeout
+    # --- INCREASED TIMEOUTS AND POOL SIZE ---
+    read_timeout = 30.0  # Increased timeout for reading response
+    write_timeout = 30.0 # Increased timeout for sending request
+    pool_timeout = 30.0  # Increased timeout for getting connection from pool
+    connection_pool_size = 50 # Significantly increased pool size
 
-    logger.info(f"Creating PTB HTTPXRequest with timeouts: "
-                f"connect={connect_timeout}, read={read_timeout}, "
-                f"write={write_timeout}, pool={pool_timeout}")
+    logger.info(f"Creating PTB HTTPXRequest with settings: "
+                f"connect_timeout={connect_timeout}, read_timeout={read_timeout}, "
+                f"write_timeout={write_timeout}, pool_timeout={pool_timeout}, "
+                f"pool_size={connection_pool_size}")
+
+    # Create httpx.Limits object
+    custom_limits = httpx.Limits(
+        max_connections=connection_pool_size,
+        max_keepalive_connections=connection_pool_size # Keepalive same as max
+        # keepalive_expiry=60.0 # Optional: Keep idle connections open longer (seconds)
+    )
 
     # Create a custom request object with these settings
-    # connection_pool_size default is 10, which is usually fine.
     custom_request = HTTPXRequest(
         connect_timeout=connect_timeout,
         read_timeout=read_timeout,
-        write_timeout=write_timeout, # Added write_timeout
+        write_timeout=write_timeout,
         pool_timeout=pool_timeout,
-        http_version="1.1"
+        limits=custom_limits, # Use the Limits object here
+        http_version="1.1" # HTTP/1.1 is usually fine, HTTP/2 might be slightly faster if supported end-to-end
     )
 
     # Use Application.builder() and pass the custom request object
     application_builder = Application.builder().token(TELEGRAM_TOKEN)
     application_builder.request(custom_request)
-    application_builder.get_updates_request(custom_request) # Apply same settings for getUpdates if used
+    # Also apply to get_updates if you were using polling (webhook doesn't use this heavily)
+    # application_builder.get_updates_request(custom_request)
+    # Apply connection pool settings globally if needed (less common now with direct request object)
+    # application_builder.pool_timeout(pool_timeout) # This might be redundant if set in HTTPXRequest
 
     # Build the application instance
     application = application_builder.build()
 
-    # --- Register Handlers (same as before) ---
+    # --- Register Handlers ---
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
+    # Handles non-command text messages that might contain a URL
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
+    # Handles the button clicks ('paragraph' or 'points')
     application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
+    # Global error handler
     application.add_error_handler(error_handler)
 
-    logger.info("Telegram handlers configured.")
+    logger.info("Telegram application handlers configured.")
     return application
 
 # --- ASGI Lifespan Context Manager ---
@@ -567,111 +940,198 @@ async def setup_bot_config() -> Application:
 async def lifespan(app: Starlette):
     """Handles PTB startup and shutdown during ASGI lifespan."""
     global ptb_app
-    logger.info("ASGI Lifespan: Startup commencing...")
-    loop = asyncio.get_running_loop()
+    logger.info("ASGI Lifespan: Startup sequence initiated...")
+    # loop = asyncio.get_running_loop() # Not usually needed directly
 
     try:
+        # --- Setup and Initialize PTB Application ---
         ptb_app = await setup_bot_config()
-        logger.info("PTB App configured. Initializing...")
-        await ptb_app.initialize()
-        logger.info("PTB App initialized. Starting background tasks...")
+        logger.info("PTB Application object configured. Initializing...")
+        await ptb_app.initialize() # Initialize application components (e.g., bot instance)
+        logger.info("PTB Application initialized. Starting background tasks (e.g., job queue)...")
+        # Start PTB's internal tasks but not polling (we use webhook)
         await ptb_app.start()
-        logger.info(f"PTB App started. Bot details: {ptb_app.bot.username}")
+        if ptb_app.updater: ptb_app.updater.stop() # Ensure polling is stopped if accidentally started
+        bot_instance = ptb_app.bot
+        bot_info = await bot_instance.get_me()
+        logger.info(f"PTB Application started successfully. Bot ID: {bot_info.id}, Username: @{bot_info.username}")
 
+        # --- Set Webhook ---
+        # Ensure SPACE_HOST is correctly set in Hugging Face Space secrets
         WEBHOOK_URL_BASE = os.environ.get("SPACE_HOST")
         if WEBHOOK_URL_BASE:
+            # Ensure it's a proper HTTPS URL
             if not WEBHOOK_URL_BASE.startswith("https://"): WEBHOOK_URL_BASE = f"https://{WEBHOOK_URL_BASE}"
-            webhook_path = "/webhook"
+            webhook_path = "/webhook" # Must match the route defined later
             full_webhook_url = f"{WEBHOOK_URL_BASE.rstrip('/')}{webhook_path}"
-            logger.info(f"Attempting to set webhook to: {full_webhook_url}")
+
+            logger.info(f"Attempting to set Telegram webhook to: {full_webhook_url}")
+            # Short delay can sometimes help prevent race conditions on startup
+            await asyncio.sleep(2.0)
             try:
-                await asyncio.sleep(1.5) # Small delay before setting webhook
-                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}")
+                # Set the webhook, specifying allowed updates can reduce load
+                await bot_instance.set_webhook(
+                    url=full_webhook_url,
+                    allowed_updates=Update.ALL_TYPES, # Or specify like [Update.MESSAGE, Update.CALLBACK_QUERY]
+                    # secret_token="YOUR_SECRET_TOKEN" # Recommended for security if possible
+                    # drop_pending_updates=True # Optional: Ignore updates sent while bot was down
+                )
+                # Verify webhook setup
+                webhook_info = await bot_instance.get_webhook_info()
+                if webhook_info.url == full_webhook_url:
+                    logger.info(f"Telegram webhook set successfully! Current info: {webhook_info}")
+                else:
+                    logger.error(f"Webhook URL mismatch after setting! Expected '{full_webhook_url}', Got: {webhook_info.url}. Info: {webhook_info}")
             except RetryAfter as e:
-                 logger.warning(f"Webhook set failed due to rate limit (RetryAfter: {e.retry_after}s). Another worker likely succeeded.")
+                 # This can happen if multiple workers try to set the webhook simultaneously
+                 logger.warning(f"Webhook setting throttled by Telegram (RetryAfter: {e.retry_after}s). Another instance likely succeeded or try again later.")
+                 # Optionally check info again after delay
+                 await asyncio.sleep(e.retry_after or 2)
+                 webhook_info = await bot_instance.get_webhook_info()
+                 logger.info(f"Webhook info after RetryAfter delay: {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.error(f"Failed to set Telegram webhook to {full_webhook_url}: {e}", exc_info=True)
+        else:
+            logger.warning("SPACE_HOST environment variable not found. Cannot set webhook automatically. Bot will not receive updates via webhook.")
 
-        logger.info("ASGI Lifespan: Startup complete. Application ready.")
-        yield # Application runs here
+        logger.info("ASGI Lifespan: Startup complete. Application is ready to yield.")
+        yield # --- Application runs here ---
 
     except Exception as startup_err:
-        logger.critical(f"CRITICAL ERROR during ASGI startup: {startup_err}", exc_info=True)
+        logger.critical(f"CRITICAL ERROR during ASGI application startup: {startup_err}", exc_info=True)
+        # Re-raise the exception to potentially stop the ASGI server from starting improperly
         raise
     finally:
-        logger.info("ASGI Lifespan: Shutdown commencing...")
-        if ptb_app and ptb_app._running: # Use _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.")
+        # --- Shutdown Sequence ---
+        logger.info("ASGI Lifespan: Shutdown sequence initiated...")
+        if ptb_app:
+            bot_username = ptb_app.bot.username if ptb_app.bot else "N/A"
+            logger.info(f"PTB App instance found for @{bot_username}. Checking if running...")
+            # Check internal state if available (e.g., ptb_app.running might exist in future versions)
+            # Using _running is internal, but often the only way
+            is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
+            if is_running:
+                try:
+                    logger.info("Stopping PTB Application's background tasks...")
+                    await ptb_app.stop() # Stop internal tasks like JobQueue
+                    logger.info("Shutting down PTB Application connections and resources...")
+                    await ptb_app.shutdown() # Clean up resources (e.g., close HTTPX client)
+                    logger.info("PTB Application shut down gracefully.")
+                except Exception as shutdown_err:
+                    logger.error(f"Error during PTB Application shutdown: {shutdown_err}", exc_info=True)
+            else:
+                 logger.warning("PTB Application instance exists but was not marked as running at shutdown.")
+                 # Attempt shutdown anyway just in case resources need cleaning
+                 try: await ptb_app.shutdown()
+                 except Exception: logger.error("Error during shutdown of non-running PTB app.", exc_info=True)
+        else:
+            logger.warning("No PTB Application instance (ptb_app) found during ASGI shutdown.")
         logger.info("ASGI Lifespan: Shutdown complete.")
 
 
-# --- Flask App Setup (for Routes) ---
+# --- Flask App Setup (for Webhook Route) ---
+# We use Flask just for its familiarity in defining the route,
+# but it runs within Starlette's ASGI context via WSGIMiddleware.
 flask_core_app = Flask(__name__)
-logger.info("Core Flask app instance created (for routing via Starlette).")
+logger.info("Core Flask app instance created (used by Starlette for routing).")
 
-# --- Define Flask Routes on flask_core_app ---
+# --- Define Flask Routes ---
 @flask_core_app.route('/')
 def index():
     """Basic health check endpoint."""
-    logger.debug("Health check '/' accessed.")
-    bot_status = "UNKNOWN"
-    if ptb_app: bot_status = "Running" if ptb_app._running else "Initialized/Stopped/Starting/Error" # Use _running
-    else: bot_status = "Not Initialized"
-    return f"Telegram Bot Webhook Listener ({bot_status}) running via Starlette."
+    logger.debug("Health check endpoint '/' accessed.")
+    bot_status = "Unknown / Not Initialized"
+    if ptb_app and ptb_app.bot:
+        # Check internal state again (might have changed)
+        is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
+        bot_status = f"Running (@{ptb_app.bot.username})" if is_running else f"Initialized/Stopped (@{ptb_app.bot.username})"
+    return f"Telegram Bot Summarizer - Status: {bot_status} - Listening via Starlette/Uvicorn."
 
 @flask_core_app.route('/webhook', methods=['POST'])
 async def webhook() -> Response:
-    """Webhook endpoint for Telegram updates."""
+    """Webhook endpoint called by Telegram."""
+    global ptb_app # Ensure we're using the global instance initialized by lifespan
+
     if not ptb_app:
-        logger.error("Webhook triggered, but PTB Application instance (ptb_app) is None.")
-        return Response('Bot service not configured.', status=503)
-    if not ptb_app._running: # Use _running
-        logger.error("Webhook triggered, but PTB Application is Not Running.")
-        return Response('Bot service not ready.', status=503)
-
-    logger.debug("Webhook request received (POST)...")
-    if request.is_json:
-        try:
-            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)
-            logger.debug(f"Finished processing update ID: {update.update_id}")
-            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 ---
+        logger.error("Webhook triggered, but PTB Application instance (ptb_app) is None. Lifespan likely failed.")
+        # Return 503 Service Unavailable
+        return Response('Bot service is not configured or failed during startup.', status=503)
+
+    # Check internal state (safer than assuming ptb_app implies running)
+    is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
+    if not is_running:
+        logger.error("Webhook triggered, but PTB Application is not currently running.")
+        # Return 503 Service Unavailable
+        return Response('Bot service is initialized but not actively running.', status=503)
+
+    # Proceed with processing the update
+    logger.debug("Webhook endpoint received POST request from Telegram.")
+    try:
+        # Use Flask's request object to get JSON data
+        update_data = await request.get_json()
+        if not update_data:
+            logger.warning("Received empty or non-JSON data on webhook.")
+            return Response('Bad Request: Expected JSON payload.', status=400)
+
+        # Deserialize JSON into a Telegram Update object
+        update = Update.de_json(update_data, ptb_app.bot)
+        logger.debug(f"Processing update_id: {update.update_id} via webhook route.")
+
+        # Process the update using PTB's internal mechanisms
+        # This will dispatch it to the correct handler (CommandHandler, MessageHandler, etc.)
+        await ptb_app.process_update(update)
+
+        logger.debug(f"Finished processing update_id: {update.update_id}")
+        # Return 200 OK to Telegram to acknowledge receipt
+        return Response('ok', status=200)
+
+    except json.JSONDecodeError:
+        logger.error("Failed to decode JSON from Telegram webhook request.", exc_info=True)
+        return Response('Bad Request: Invalid JSON format.', status=400)
+    except Exception as e:
+        # Catch potential errors during Update.de_json or ptb_app.process_update
+        logger.error(f"Error processing update in webhook handler: {e}", exc_info=True)
+        # Return 500 Internal Server Error to Telegram
+        # Telegram will likely retry sending the update later
+        return Response('Internal Server Error processing update.', status=500)
+
+
+# --- Create Starlette ASGI Application ---
+# This is the main application object that Uvicorn/Gunicorn will run.
 app = Starlette(
-    lifespan=lifespan,
+    debug=False, # Set debug based on environment if needed, but generally False in prod
+    lifespan=lifespan, # Hook into the lifespan context manager for startup/shutdown
     routes=[
+        # Mount the Flask app under the root path. Starlette handles requests
+        # and forwards relevant ones ('/') and ('/webhook') to the Flask app.
         Mount("/", app=WSGIMiddleware(flask_core_app))
     ]
 )
-logger.info("Starlette application created with lifespan and Flask app mounted at '/'.")
+logger.info("Starlette ASGI application created, configured with lifespan and Flask app mounted at '/'.")
 
 
-# --- Main Execution Block (for local testing ONLY) ---
+# --- Development Server Execution Block ---
+# This block is ONLY for running the Flask app directly for basic testing
+# WITHOUT the proper ASGI lifespan management (PTB won't start correctly here).
+# DO NOT use this for deployment. Use `gunicorn main:app` or `uvicorn main:app`.
 if __name__ == '__main__':
-    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.")
+    logger.warning("=" * 50)
+    logger.warning(" RUNNING SCRIPT DIRECTLY (using __main__) ".center(50, "="))
+    logger.warning("=" * 50)
+    logger.warning("This mode starts the Flask development server.")
+    logger.warning("!!! IT DOES **NOT** RUN THE ASGI LIFESPAN !!!")
+    logger.warning("!!! The Telegram Bot (PTB Application) WILL NOT INITIALIZE OR RUN !!!")
+    logger.warning("This is suitable ONLY for verifying Flask routes locally.")
+    logger.warning("For proper testing/deployment, use: uvicorn main:app --reload --port 8080")
+    logger.warning("or via Gunicorn: gunicorn -c gunicorn.conf.py main:app")
+    logger.warning("=" * 50)
+
+    if not TELEGRAM_TOKEN:
+        logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable missing. Aborting direct Flask start.")
     else:
+        # Get port from environment or default to 8080 for local dev
         local_port = int(os.environ.get('PORT', 8080))
-        logger.info(f"Flask dev server starting on http://0.0.0.0:{local_port}")
-        flask_core_app.run(host='0.0.0.0', port=local_port, debug=True)
+        logger.info(f"Starting Flask development server on http://0.0.0.0:{local_port}")
+        # Run the Flask app directly (no Starlette, no lifespan, no PTB)
+        # use_reloader=False is important if debugging PTB setup elsewhere
+        flask_core_app.run(host='0.0.0.0', port=local_port, debug=True, use_reloader=False)