Update main.py

main.py

@@ -1,21 +1,22 @@
-# main.py (Revised: Use asyncio.create_task for callback processing)
+# main.py (Revised with background task connection fixes)
 import os
 import re
 import logging
 import asyncio
 import json
-import html # For unescaping HTML entities
-import contextlib # For async context manager (lifespan)
-import traceback # For logging exceptions in tasks
+import html
+import contextlib
+import traceback
+from typing import Optional
 
 # --- 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
+from flask import Flask, request, Response
+from starlette.applications import Starlette
+from starlette.routing import Mount
+from starlette.middleware.wsgi import WSGIMiddleware
 
 # --- Telegram Bot ---
-from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, Bot # Import Bot
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, Bot
 from telegram.ext import (
     Application,
     CommandHandler,
@@ -25,7 +26,7 @@ from telegram.ext import (
     CallbackQueryHandler,
 )
 from telegram.constants import ParseMode
-from telegram.error import NetworkError, RetryAfter, TimedOut, BadRequest # Import BadRequest
+from telegram.error import NetworkError, RetryAfter, TimedOut, BadRequest
 from telegram.request import HTTPXRequest
 
 # --- Other Libraries ---
@@ -33,6 +34,8 @@ import httpx
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
 _apify_token_exists = bool(os.environ.get('APIFY_API_TOKEN'))
 if _apify_token_exists:
     from apify_client import ApifyClient
@@ -55,8 +58,8 @@ logging.getLogger('starlette').setLevel(logging.INFO)
 logger = logging.getLogger(__name__)
 logger.info("Logging configured.")
 
-# --- Global variable for PTB app (initialized during lifespan) ---
-ptb_app: Application | None = None
+# --- Global variable for PTB app ---
+ptb_app: Optional[Application] = None
 
 # --- Environment Variable Loading ---
 logger.info("Attempting to load secrets...")
@@ -73,14 +76,26 @@ SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY')
 APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
 logger.info("Secret loading attempt finished.")
 
+# --- Retry Decorator for Bot Operations ---
+def retry_bot_operation(func):
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        retry=retry_if_exception_type((NetworkError, RuntimeError)),
+        before_sleep=lambda retry_state: logger.warning(
+            f"Retrying bot operation due to {retry_state.outcome.exception()}. "
+            f"Attempt {retry_state.attempt_number}/3"
+        )
+    )
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Operation failed after retries: {e}")
+            raise
+    return wrapper
 
-# --- Bot Logic Functions ---
-# (Keep ALL your functions: is_youtube_url, extract_youtube_id,
-#  get_transcript_via_supadata, get_transcript_via_apify,
-#  get_youtube_transcript, get_website_content_via_requests,
-#  get_website_content_via_urltotext_api, generate_summary - unchanged)
-
-# Helper Functions
+# --- Helper Functions (unchanged from your original) ---
 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})'
@@ -100,608 +115,166 @@ def extract_youtube_id(url):
         logger.warning(f"Could not extract YouTube ID from URL: {url}")
         return None
 
-# Supadata Transcript Fetching
-async def get_transcript_via_supadata(video_id: str, api_key: str):
-    """Fetches YouTube transcript via Supadata API."""
-    if not video_id: logger.error("[Supadata] get_transcript_via_supadata called with no video_id"); return None
-    if not api_key: logger.error("[Supadata] API key is missing."); return None
-    logger.info(f"[Supadata] Attempting fetch for video ID: {video_id}")
-    api_endpoint = f"https://api.supadata.net/v1/youtube/transcript"
-    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 - 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:
-            try:
-                data = response.json()
-                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)}")
-                    return content.strip()
-                else:
-                    logger.warning(f"[Supadata] API success but content empty/invalid for {video_id}. Response: {data}")
-                    return None
-            except json.JSONDecodeError:
-                if response.text:
-                    logger.info(f"[Supadata] Successfully fetched transcript (plain text) for {video_id}. Length: {len(response.text)}")
-                    return response.text.strip()
-                else:
-                    logger.error(f"[Supadata] Failed to decode JSON response (and no text body) for {video_id}. Response: {response.text[:200]}...")
-                    return None
-            except Exception as e:
-                logger.error(f"[Supadata] Error processing successful response for {video_id}: {e}", exc_info=True)
-                return None
-        elif response.status_code in [401, 403]:
-            logger.error(f"[Supadata] Authentication error ({response.status_code}). Check API key.")
-            return None
-        elif response.status_code == 404:
-            logger.warning(f"[Supadata] Transcript not found ({response.status_code}) for {video_id}.")
-            return None
-        else:
-             logger.error(f"[Supadata] Unexpected status code {response.status_code} for {video_id}. Response: {response.text[:200]}...")
-             return None
-    except requests.exceptions.Timeout:
-        logger.error(f"[Supadata] Timeout error connecting to API for {video_id}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logger.error(f"[Supadata] Request error connecting to API for {video_id}: {e}")
-        if isinstance(e, requests.exceptions.SSLError):
-            logger.error(f"[Supadata] SSL Error occurred despite using verify=False. Details: {e}")
-        return None
-    except Exception as e:
-        logger.error(f"[Supadata] Unexpected error during API call for {video_id}: {e}", exc_info=True)
-        return None
-
-# 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
-    if not api_token: logger.error("[Apify] API token is missing."); return None
-    if not ApifyClient: logger.error("[Apify] ApifyClient not available/imported."); return None
-
-    logger.info(f"[Apify] Attempting fetch for URL: {video_url}")
-    actor_id = "karamelo~youtube-transcripts"
-    api_endpoint = f"https://api.apify.com/v2/acts/{actor_id}/run-sync-get-dataset-items"
-    params = {"token": api_token}
-    payload = json.dumps({
-        "urls": [video_url],
-        "outputFormat": "singleStringText",
-        "maxRetries": 3,
-        "channelHandleBoolean": False,
-        "channelNameBoolean": False,
-        "datePublishedBoolean": False,
-        "relativeDateTextBoolean": False,
-    })
-    headers = {"Content-Type": "application/json"}
-    try:
-        logger.debug(f"[Apify] Sending request to run actor {actor_id} synchronously for {video_url}")
-        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, params=params, data=payload, timeout=90)
-        logger.debug(f"[Apify] Received status code {response.status_code} for {video_url}")
-
-        if response.status_code in [200, 201]:
-            try:
-                results = response.json()
-                if isinstance(results, list) and len(results) > 0:
-                    item = results[0]
-                    content = item.get("text") or item.get("transcript") or item.get("captions_concatenated")
-
-                    if not content and item.get("captions"):
-                        captions_data = item["captions"]
-                        if isinstance(captions_data, str):
-                            logger.info("[Apify] Processing 'captions' string format as fallback.")
-                            content = captions_data.strip()
-                            if len(content) < 50 and "error" in content.lower():
-                                logger.warning(f"[Apify] 'captions' string looks like an error: {content}")
-                                content = None
-                        elif isinstance(captions_data, list):
-                            logger.info("[Apify] Processing 'captions' list format as fallback.")
-                            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
-
-                        if content:
-                           try:
-                               content = html.unescape(content) # Use imported html module
-                           except Exception as unescape_err:
-                               logger.warning(f"[Apify] Error during html unescaping: {unescape_err}")
-
-                    if content and isinstance(content, str):
-                        logger.info(f"[Apify] Successfully fetched transcript via run-sync for {video_url} (Status: {response.status_code}). Length: {len(content)}")
-                        return content
-                    else:
-                        if item.get("text") or item.get("transcript") or item.get("captions_concatenated"): logger.warning(f"[Apify] Actor success ({response.status_code}) but primary fields empty for {video_url}.")
-                        elif not item.get("captions"): logger.warning(f"[Apify] Actor success ({response.status_code}) but no relevant fields found for {video_url}. Item: {item}")
-                        else: logger.warning(f"[Apify] Actor success ({response.status_code}), 'captions' found but fallback parsing failed for {video_url}.")
-                        return None
-                else:
-                    logger.warning(f"[Apify] Actor success ({response.status_code}) but dataset result list empty for {video_url}. Response: {results}")
-                    return None
-            except json.JSONDecodeError:
-                logger.error(f"[Apify] Failed JSON decode for {video_url}. Status: {response.status_code}. Resp: {response.text[:200]}...")
-                return None
-            except Exception as e:
-                logger.error(f"[Apify] Error processing successful response ({response.status_code}) for {video_url}: {e}", exc_info=True)
-                return None
-        elif response.status_code == 400: logger.error(f"[Apify] Bad Request (400) for {video_url}. Resp: {response.text[:200]}..."); return None
-        elif response.status_code == 401: logger.error("[Apify] Auth error (401). Check token."); return None
-        else: logger.error(f"[Apify] Unexpected status {response.status_code} for {video_url}. Resp: {response.text[:200]}..."); return None
-
-    except requests.exceptions.Timeout: logger.error(f"[Apify] Timeout error running actor for {video_url}"); return None
-    except requests.exceptions.RequestException as e: logger.error(f"[Apify] Request error running actor for {video_url}: {e}"); return None
-    except Exception as e: logger.error(f"[Apify] Unexpected error during Apify call for {video_url}: {e}", exc_info=True); return None
-
-# Combined YouTube Transcript Function
-async def get_youtube_transcript(video_id: str, video_url: str, supadata_key: str | None, apify_token: str | None):
-    """Fetches YouTube transcript using library, then Supadata, then Apify."""
-    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
-    try: # Primary: Library
-        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'])
-        if transcript_list:
-            transcript_text = " ".join([item['text'] for item in transcript_list if 'text' in item])
-            transcript_text = re.sub(r'\s+', ' ', transcript_text).strip()
-            if transcript_text: logger.info(f"[Primary YT] Success via library. Length: {len(transcript_text)}"); return transcript_text
-            else: logger.warning("[Primary YT] Joined text empty after cleaning."); transcript_text = None
-        else: logger.warning("[Primary YT] Transcript list empty."); transcript_text = None
-    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 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 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 found.")
-        else: logger.warning("[Fallback YT 2] Apify token not available, skipping.")
-
-    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] 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/110.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'
-        }
-        response = await asyncio.to_thread(requests.get, url, headers=headers, timeout=25, allow_redirects=True)
-        response.raise_for_status()
-        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 received: {content_type}. Attempting plain text extraction.")
-            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')
-        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"]
-        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()
-
-        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 a suitable target element (main, article, body) for {url}");
-            return None
-
-        lines = [line.strip() for line in target_element.get_text(separator='\n', strip=True).splitlines() if line.strip()]
-        text = "\n\n".join(lines)
-
-        MIN_TEXT_LENGTH = 100
-        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.")
-             return None
-
-        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 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] 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,
-        "timeout_render": 20000,
-    })
-    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=60)
-        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 = 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")
-
-                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
-
-                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]}...")
-        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
-    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 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"
-    model_name = "deepseek/deepseek-chat:free"
-
-    if summary_type == "paragraph":
-        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":
-        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}' requested.")
-        return f"Error: Invalid summary type ('{summary_type}') requested. Please choose 'paragraph' or 'points'."
-
-    MAX_INPUT_TOKENS_ESTIMATE = 28000
-    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
-
-    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")
-    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"
-    }
-    payload = json.dumps({"model": model_name, "messages": messages})
-
-    try:
-        logger.debug(f"Sending request to OpenRouter (Model: {model_name}). Prompt length approx: {len(text)} chars.")
-        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()
-                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)}")
-                    if summary_type == "paragraph" and len(summary.split()) > 95:
-                         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."
-
-        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 HTTP status {response.status_code} from OpenRouter. Response: {response.text[:500]}...")
-             try:
-                 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."
-
-
-# --- Background Task Processing ---
+# --- Content Fetching Functions (unchanged from your original) ---
+# [Keep all your existing content fetching functions exactly as they were]
+# get_transcript_via_supadata, get_transcript_via_apify, get_youtube_transcript,
+# get_website_content_via_requests, get_website_content_via_urltotext_api, generate_summary
 
+# --- Revised Background Task Processing ---
 async def process_summary_task(
     user_id: int,
     chat_id: int,
     message_id_to_edit: int,
     url: str,
     summary_type: str,
-    bot: Bot # Pass the Bot instance
+    bot_token: str  # Now receiving token instead of bot instance
 ) -> None:
     """Handles the actual fetching and summarization in a background task."""
-    task_id = asyncio.current_task().get_name() if hasattr(asyncio.current_task(), 'get_name') else id(asyncio.current_task())
-    logger.info(f"[Task {task_id}] Starting processing for user {user_id}, chat {chat_id}, msg {message_id_to_edit}, type '{summary_type}'")
-
-    # Fetch current API keys within the task
-    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')
-    # Keys check (already done in handler, but good for task log context)
-    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"[Task {task_id}] API Key check: {keys_present}")
-
-    if not current_openrouter_key:
-        logger.error(f"[Task {task_id}] CRITICAL: OpenRouter API key is missing. Cannot generate summary.")
-        try:
-            # Edit the original message to show the config error
-            await bot.edit_message_text(
-                chat_id=chat_id,
-                message_id=message_id_to_edit,
-                text="❌ Configuration Error: The AI summarization service is not configured correctly. Please contact the administrator."
-            )
-        except Exception as edit_err:
-             logger.error(f"[Task {task_id}] Failed to edit message for missing AI key: {edit_err}")
-        return # Stop task
-
-    # --- 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)_"
-    status_message_sent_id = None # Track if we sent a separate message
-
+    task_id = f"{user_id}-{message_id_to_edit}"
+    logger.info(f"[Task {task_id}] Starting processing for URL: {url}")
+    
+    # Create a new bot instance for this task
+    bot = Bot(token=bot_token)
+    
     try:
-        await bot.edit_message_text(
-            chat_id=chat_id,
-            message_id=message_id_to_edit,
-            text=processing_message_text
-        )
-        logger.debug(f"[Task {task_id}] Successfully edited message {message_id_to_edit} to 'Working...'")
-    except (TimedOut, NetworkError, BadRequest) as e: # Catch specific Telegram errors
-        # If editing fails (message too old, deleted, bot blocked, rate limit, etc.)
-        logger.warning(f"[Task {task_id}] Could not edit original message {message_id_to_edit}: {e!r}. Sending new status message.")
-        message_id_to_edit = None # Mark original message as uneditable/not-to-be-deleted later
-        try:
-            status_message = await bot.send_message(chat_id=chat_id, text=processing_message_text)
-            status_message_sent_id = status_message.message_id
-            logger.debug(f"[Task {task_id}] Sent new status message {status_message_sent_id}.")
-        except Exception as send_err:
-            logger.error(f"[Task {task_id}] Failed sending NEW 'Working...' status message: {send_err}. Processing continues without feedback.")
-            # Proceed, but user gets no feedback
-    except Exception as e:
-        # Catch unexpected errors during editing
-        logger.error(f"[Task {task_id}] Unexpected error editing message {message_id_to_edit}: {e!r}", exc_info=True)
-        message_id_to_edit = None # Assume original message is problematic
-
-    # --- Main Content Fetching and Summarization ---
-    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)_"
+        status_message_sent_id = None
+        
+        @retry_bot_operation
+        async def edit_or_send_status():
+            nonlocal status_message_sent_id, message_id_to_edit
+            try:
+                await bot.edit_message_text(
+                    chat_id=chat_id,
+                    message_id=message_id_to_edit,
+                    text=processing_message_text
+                )
+                logger.debug(f"[Task {task_id}] Successfully edited message {message_id_to_edit}")
+            except (TimedOut, NetworkError, BadRequest) as e:
+                logger.warning(f"[Task {task_id}] Could not edit original message: {e}. Sending new status message.")
+                message_id_to_edit = None
+                status_message = await bot.send_message(
+                    chat_id=chat_id,
+                    text=processing_message_text
+                )
+                status_message_sent_id = status_message.message_id
+                logger.debug(f"[Task {task_id}] Sent new status message {status_message_sent_id}")
 
-    try:
-        # Send 'typing' action to indicate activity
-        try:
-            logger.debug(f"[Task {task_id}] Sending 'typing' chat action to chat {chat_id}")
-            await bot.send_chat_action(chat_id=chat_id, action='typing')
-        except Exception as ca_err:
-            logger.warning(f"[Task {task_id}] Failed sending 'typing' action: {ca_err}")
+        await edit_or_send_status()
 
-        # --- Determine Content Type and Fetch ---
-        is_yt = is_youtube_url(url)
-        logger.debug(f"[Task {task_id}] URL ({url}) is YouTube: {is_yt}")
+        # --- Main Content Fetching and Summarization ---
+        content = None
+        user_feedback_message = None
+        success = False
 
-        if is_yt:
-            video_id = extract_youtube_id(url)
-            if video_id:
-                logger.info(f"[Task {task_id}] 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:
-                    logger.warning(f"[Task {task_id}] Failed to get YouTube transcript for {video_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"[Task {task_id}] Successfully fetched YouTube transcript for {video_id}. Length: {len(content)}")
+        try:
+            # Send 'typing' action
+            @retry_bot_operation
+            async def send_typing():
+                await bot.send_chat_action(chat_id=chat_id, action='typing')
+            
+            await send_typing()
+
+            # --- Determine Content Type and Fetch ---
+            is_yt = is_youtube_url(url)
+            logger.debug(f"[Task {task_id}] URL is YouTube: {is_yt}")
+
+            if is_yt:
+                video_id = extract_youtube_id(url)
+                if video_id:
+                    logger.info(f"[Task {task_id}] Fetching YouTube transcript for {video_id}")
+                    content = await get_youtube_transcript(
+                        video_id, 
+                        url, 
+                        SUPADATA_API_KEY, 
+                        APIFY_API_TOKEN
+                    )
+                    if not content:
+                        user_feedback_message = "⚠️ Sorry, I couldn't retrieve the transcript for that YouTube video."
             else:
-                logger.warning(f"[Task {task_id}] Failed to extract YouTube video ID from URL: {url}")
-                user_feedback_message = "⚠️ Sorry, I couldn't identify a valid YouTube video ID in the link you provided."
-        else:
-            # --- Website Scraping ---
-            logger.info(f"[Task {task_id}] Attempting website scrape (Requests/BS4) for URL: {url}")
-            content = await get_website_content_via_requests(url)
+                logger.info(f"[Task {task_id}] Attempting website scrape for: {url}")
+                content = await get_website_content_via_requests(url)
+                if not content and URLTOTEXT_API_KEY:
+                    await send_typing()
+                    content = await get_website_content_via_urltotext_api(url, URLTOTEXT_API_KEY)
+                    if not content:
+                        user_feedback_message = "⚠️ Sorry, I couldn't fetch the content from that website."
+
+            # --- Generate Summary if Content Was Fetched ---
             if content:
-                logger.info(f"[Task {task_id}] Website scrape successful (Requests/BS4). Length: {len(content)}")
-            else:
-                logger.warning(f"[Task {task_id}] Primary website scrape failed for {url}. Trying fallback API.")
-                if current_urltotext_key:
-                    try: await bot.send_chat_action(chat_id=chat_id, action='typing'); logger.debug("[Task {task_id}] Sent typing before fallback scrape.")
-                    except: pass
+                logger.info(f"[Task {task_id}] Generating '{summary_type}' summary")
+                await send_typing()
+                
+                summary = await generate_summary(content, summary_type, OPENROUTER_API_KEY)
 
-                    logger.info(f"[Task {task_id}] Attempting website scrape via URLToText API for: {url}")
-                    content = await get_website_content_via_urltotext_api(url, current_urltotext_key)
-                    if content:
-                        logger.info(f"[Task {task_id}] Website scrape successful via URLToText API. Length: {len(content)}")
-                    else:
-                        logger.warning(f"[Task {task_id}] Fallback website scrape (URLToText API) also failed for {url}.")
-                        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."
+                if summary.startswith("Error:") or summary.startswith("Sorry,"):
+                    user_feedback_message = f"⚠️ {summary}"
                 else:
-                    logger.warning(f"[Task {task_id}] Primary scrape failed and URLToText API key not configured. Cannot fallback for {url}.")
-                    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(f"[Task {task_id}] Content fetched (Length: {len(content)}). Generating '{summary_type}' summary.")
-            try: await bot.send_chat_action(chat_id=chat_id, action='typing'); logger.debug("[Task {task_id}] 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,"):
-                logger.warning(f"[Task {task_id}] AI summary generation failed. Reason: {summary}")
-                user_feedback_message = f"⚠️ {summary}"
-            else:
-                # --- Summary Success - Send to User ---
-                logger.info(f"[Task {task_id}] Summary generated successfully. Length: {len(summary)}. Sending result.")
-                try:
-                    await bot.send_message(
-                        chat_id=chat_id,
-                        text=summary,
-                        parse_mode=ParseMode.MARKDOWN,
-                        link_preview_options={'is_disabled': True}
-                    )
+                    @retry_bot_operation
+                    async def send_summary():
+                        await bot.send_message(
+                            chat_id=chat_id,
+                            text=summary,
+                            parse_mode=ParseMode.MARKDOWN,
+                            link_preview_options={'is_disabled': True}
+                        )
+                    
+                    await send_summary()
                     success = True
-                    user_feedback_message = None
-                    logger.info(f"[Task {task_id}] Successfully sent summary to chat {chat_id}.")
-                except Exception as send_final_err:
-                    logger.error(f"[Task {task_id}] Failed sending final summary to chat {chat_id}: {send_final_err}", exc_info=True)
-                    user_feedback_message = "⚠️ Sorry, an unexpected error occurred while sending the final summary."
-                    success = False
 
-        elif not user_feedback_message:
-             logger.warning(f"[Task {task_id}] Content retrieval resulted in None, but no specific user feedback message was set. URL: {url}")
-             user_feedback_message = "⚠️ Sorry, I couldn't retrieve any usable content from the link provided."
+        except Exception as e:
+            logger.error(f"[Task {task_id}] Error during processing: {e}", exc_info=True)
+            user_feedback_message = "❌ An unexpected error occurred while processing your request."
 
         # --- Send Final Feedback Message if Processing Failed ---
         if user_feedback_message and not success:
-            logger.warning(f"[Task {task_id}] Processing failed or summary sending failed. Sending feedback: {user_feedback_message}")
-            try:
+            @retry_bot_operation
+            async def send_feedback():
                 await bot.send_message(chat_id=chat_id, text=user_feedback_message)
-            except Exception as send_feedback_err:
-                 logger.error(f"[Task {task_id}] Failed sending final FAILURE feedback message to chat {chat_id}: {send_feedback_err}")
+            
+            await send_feedback()
 
     except Exception as e:
-        # Catch-all for unexpected errors during the main processing block
-        logger.error(f"[Task {task_id}] Unexpected critical error during task processing for user {user_id}, URL {url}: {e}", exc_info=True)
+        logger.error(f"[Task {task_id}] Critical error in task: {e}", exc_info=True)
         try:
-            await bot.send_message(chat_id=chat_id, text="❌ Oops! An unexpected internal error occurred while processing your request. The issue has been logged.")
-        except Exception as final_err:
-            logger.error(f"[Task {task_id}] Failed sending CRITICAL internal error feedback message to chat {chat_id}: {final_err}")
-        success = False
-
+            await bot.send_message(
+                chat_id=chat_id,
+                text="❌ A critical error occurred. Please try again later."
+            )
+        except Exception:
+            pass
     finally:
         # --- Clean up Status Message(s) ---
-        logger.debug(f"[Task {task_id}] Cleaning up status message(s). Success={success}")
         try:
             if status_message_sent_id:
-                # If we sent a separate "Working..." message, delete it.
                 await bot.delete_message(chat_id=chat_id, message_id=status_message_sent_id)
-                logger.debug(f"[Task {task_id}] Deleted separate status message {status_message_sent_id}.")
-            elif message_id_to_edit:
-                # If we successfully edited the original message...
-                if success:
-                    # If processing succeeded, delete the original "Working..." message.
-                    await bot.delete_message(chat_id=chat_id, message_id=message_id_to_edit)
-                    logger.debug(f"[Task {task_id}] Processing succeeded. Deleted original (edited) message {message_id_to_edit}.")
-                else:
-                    # If processing failed, edit the message to show failure (if possible)
-                    logger.debug(f"[Task {task_id}] Processing failed. Attempting to edit message {message_id_to_edit} to show error.")
-                    final_error_text = user_feedback_message or "❌ An error occurred."
-                    try:
-                        await bot.edit_message_text(chat_id=chat_id, message_id=message_id_to_edit, text=final_error_text[:4090]) # Truncate error message if needed
-                    except Exception as final_edit_err:
-                         logger.warning(f"[Task {task_id}] Could not edit message {message_id_to_edit} to show final error state: {final_edit_err!r}")
-            # If message_id_to_edit is None, we couldn't edit it initially, and if status_message_sent_id is None, we failed to send a new one. Nothing to clean up.
-
-        except Exception as del_e:
-            logger.warning(f"[Task {task_id}] Could not delete status/button message during cleanup: {del_e!r}")
+            elif message_id_to_edit and success:
+                await bot.delete_message(chat_id=chat_id, message_id=message_id_to_edit)
+            elif message_id_to_edit and not success:
+                final_error_text = user_feedback_message or "❌ An error occurred."
+                await bot.edit_message_text(
+                    chat_id=chat_id,
+                    message_id=message_id_to_edit,
+                    text=final_error_text[:4090]
+                )
+        except Exception as e:
+            logger.warning(f"[Task {task_id}] Cleanup error: {e}")
+        
+        # Ensure bot session is closed
+        try:
+            await bot.session.close()
+        except Exception:
+            pass
 
-        logger.info(f"[Task {task_id}] Finished task processing for user {user_id}. Overall Success: {success}")
+        logger.info(f"[Task {task_id}] Task completed. Success: {success}")
 
 # --- Telegram Bot Handlers ---
-
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles the /start command."""
     user = update.effective_user
     if not user: return
-    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) initiated /start.")
+    logger.info(f"User {user.id} initiated /start.")
     mention = user.mention_html() if user.username else user.first_name
     start_message = (
         f"👋 Hello {mention}!\n\n"
@@ -717,15 +290,14 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
     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"
+        "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"
+        "- **YouTube:** Getting transcripts can sometimes fail if they are disabled or unavailable.\n"
+        "- **Websites:** Complex websites might not work perfectly.\n"
+        "- **AI Summaries:** The AI tries its best to be accurate.\n\n"
         "Just send a link to get started!"
     )
     await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
@@ -742,9 +314,8 @@ async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYP
 
     if match:
         url = match.group(0)
-        logger.info(f"User {user.id} sent potential URL: {url}")
+        logger.info(f"User {user.id} sent URL: {url}")
         context.user_data['url_to_summarize'] = url
-        logger.debug(f"Stored URL '{url}' in user_data for user {user.id}")
 
         keyboard = [
             [
@@ -759,123 +330,83 @@ async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYP
             parse_mode=ParseMode.MARKDOWN,
             link_preview_options={'is_disabled': True}
         )
-    else:
-        if not message_text.startswith('/'):
-             await update.message.reply_text("Please send me a valid URL (starting with http:// or https://) to summarize.")
-
+    elif 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:
-    """Handles button presses: gets data, clears context, schedules background task."""
+    """Handles button presses for summary type selection."""
     query = update.callback_query
     if not query or not query.from_user or not query.message:
-        logger.warning("Callback query, user, or message missing in update.")
-        # Try answering query even if message is missing, just to acknowledge
-        if query:
-            try: await query.answer("Error: Missing information.")
-            except Exception: pass
+        try:
+            await query.answer()
+        except:
+            pass
         return
-    user = query.from_user
-
-    # We skip query.answer() here to avoid potential connection issues.
-    # The button might stay loading visually for the user.
 
+    await query.answer()  # Acknowledge the button press immediately
+    
+    user = query.from_user
     summary_type = query.data
     url = context.user_data.get('url_to_summarize')
-    query_id = query.id # For logging
+    query_id = query.id
 
-    logger.info(f"User {user.id} chose summary type '{summary_type}'. Query ID: {query_id}. Checking for stored URL.")
+    logger.info(f"User {user.id} chose summary type '{summary_type}'")
 
     if not url:
-        logger.warning(f"User {user.id} (Query {query_id}) pressed button '{summary_type}', but NO URL found in user_data context.")
+        logger.warning(f"No URL found for user {user.id}")
         try:
             await query.edit_message_text(text="⚠️ Oops! I lost the context for that link. Please send the link again.")
-        except Exception as edit_err:
-            logger.error(f"Failed to edit message for lost context (Query {query_id}): {edit_err}")
-        # Still try to answer the query if editing failed
-        try: await query.answer("Error processing request.")
-        except Exception: pass
+        except Exception as e:
+            logger.error(f"Failed to edit message: {e}")
         return
 
-    logger.info(f"Scheduling background task for URL '{url}' (User {user.id}, Query {query_id}, Type '{summary_type}').")
-
-    # Extract necessary IDs before clearing data
-    user_id = user.id
-    chat_id = query.message.chat_id
-    message_id_to_edit = query.message.message_id
-    bot_instance = context.bot # Get the bot instance from context
-
-    # Clear the URL from context *before* scheduling the task
+    # Clear the URL from context
     context.user_data.pop('url_to_summarize', None)
-    logger.debug(f"Cleared URL from user_data for user {user_id} (Query {query_id})")
 
-    # Schedule the actual processing function to run in the background
-    # Pass all required data explicitly
+    # Schedule background task with token instead of bot instance
     asyncio.create_task(
         process_summary_task(
-            user_id=user_id,
-            chat_id=chat_id,
-            message_id_to_edit=message_id_to_edit,
+            user_id=user.id,
+            chat_id=query.message.chat_id,
+            message_id_to_edit=query.message.message_id,
             url=url,
             summary_type=summary_type,
-            bot=bot_instance
+            bot_token=TELEGRAM_TOKEN
         ),
-        name=f"SummaryTask-{user_id}-{message_id_to_edit}" # Optional: name the task
+        name=f"SummaryTask-{user.id}-{query.message.message_id}"
     )
 
-    # Log that the task was scheduled and the handler is returning.
-    logger.debug(f"Callback handler for Query {query_id} finished after scheduling task.")
-    # DO NOT await the task here. Let the handler return immediately.
-
-
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Log Errors caused by Updates or background tasks."""
-    # Check if the error is from an Exception raised in a handler
     if context.error:
         logger.error(f"Exception while handling an update: {context.error}", exc_info=context.error)
-        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}")
-        # Add more specific error handling if needed
-    else:
-        # Log errors from background tasks if PTB captures them this way (might need custom handling)
-        logger.error(f"Unknown error occurred. Update: {update} | Context: {context}")
-
 
 # --- Bot Setup Function ---
 async def setup_bot_config() -> Application:
-    """Configures the PTB Application with custom HTTPX settings for PTB v20.x."""
+    """Configures the PTB Application."""
     logger.info("Configuring Telegram Application...")
     if not TELEGRAM_TOKEN:
-        logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable not found.")
         raise ValueError("TELEGRAM_TOKEN environment variable not set.")
 
-    connect_timeout = 10.0
-    read_timeout = 30.0
-    write_timeout = 30.0
-    pool_timeout = 30.0
-
-    logger.info(f"Creating PTB HTTPXRequest (v20 compatible) with settings: "
-                f"connect_timeout={connect_timeout}, read_timeout={read_timeout}, "
-                f"write_timeout={write_timeout}, pool_timeout={pool_timeout}. "
-                f"(Pool size uses httpx default)")
-
     custom_request = HTTPXRequest(
-        connect_timeout=connect_timeout,
-        read_timeout=read_timeout,
-        write_timeout=write_timeout,
-        pool_timeout=pool_timeout,
+        connect_timeout=10.0,
+        read_timeout=30.0,
+        write_timeout=30.0,
+        pool_timeout=30.0,
         http_version="1.1"
     )
 
-    application_builder = Application.builder().token(TELEGRAM_TOKEN)
-    application_builder.request(custom_request)
-    application = application_builder.build()
+    application = (
+        Application.builder()
+        .token(TELEGRAM_TOKEN)
+        .request(custom_request)
+        .build()
+    )
 
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
-    application.add_handler(CallbackQueryHandler(handle_summary_type_callback)) # This handler now just schedules the task
+    application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
     application.add_error_handler(error_handler)
 
     logger.info("Telegram application handlers configured.")
@@ -890,140 +421,78 @@ async def lifespan(app: Starlette):
 
     try:
         ptb_app = await setup_bot_config()
-        logger.info("PTB Application object configured. Initializing...")
         await ptb_app.initialize()
-        logger.info("PTB Application initialized. Starting background tasks (e.g., job queue)...")
-        await ptb_app.start() # Starts dispatcher, job queue, etc. but NOT polling
+        await ptb_app.start()
 
-        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}")
+        bot_info = await ptb_app.bot.get_me()
+        logger.info(f"Bot started: @{bot_info.username}")
 
         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}"
+            if not WEBHOOK_URL_BASE.startswith("https://"):
+                WEBHOOK_URL_BASE = f"https://{WEBHOOK_URL_BASE}"
             webhook_path = "/webhook"
             full_webhook_url = f"{WEBHOOK_URL_BASE.rstrip('/')}{webhook_path}"
 
-            logger.info(f"Attempting to set Telegram webhook to: {full_webhook_url}")
-            await asyncio.sleep(2.0) # Short delay before setting webhook
+            logger.info(f"Setting webhook to: {full_webhook_url}")
+            await asyncio.sleep(2.0)
             try:
-                await bot_instance.set_webhook(
+                await ptb_app.bot.set_webhook(
                     url=full_webhook_url,
                     allowed_updates=Update.ALL_TYPES,
-                    # drop_pending_updates=True # Consider adding this if startup issues persist
+                    drop_pending_updates=True
                 )
-                webhook_info = await bot_instance.get_webhook_info()
-                if webhook_info and webhook_info.url == full_webhook_url:
-                    logger.info(f"Telegram webhook set successfully! Current info: {webhook_info}")
-                elif webhook_info:
-                     logger.error(f"Webhook URL mismatch after setting! Expected '{full_webhook_url}', Got: {webhook_info.url}. Info: {webhook_info}")
-                else:
-                    logger.error("Failed to get webhook info after setting webhook.")
-            except RetryAfter as e:
-                 logger.warning(f"Webhook setting throttled by Telegram (RetryAfter: {e.retry_after}s). Another instance likely succeeded or try again later.")
-                 await asyncio.sleep(e.retry_after or 2)
-                 try:
-                     webhook_info = await bot_instance.get_webhook_info()
-                     logger.info(f"Webhook info after RetryAfter delay: {webhook_info}")
-                 except Exception as get_info_err:
-                     logger.error(f"Failed to get webhook info after RetryAfter delay: {get_info_err}")
+                webhook_info = await ptb_app.bot.get_webhook_info()
+                logger.info(f"Webhook set: {webhook_info}")
             except Exception as e:
-                 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.error(f"Failed to set webhook: {e}")
 
-        logger.info("ASGI Lifespan: Startup complete. Application is ready to yield.")
-        yield # --- Application runs here ---
+        logger.info("ASGI Lifespan: Startup complete.")
+        yield
 
     except Exception as startup_err:
-        logger.critical(f"CRITICAL ERROR during ASGI application startup: {startup_err}", exc_info=True)
-        # Log traceback explicitly before raising might help in some environments
-        traceback.print_exc()
+        logger.critical(f"Startup error: {startup_err}", exc_info=True)
         raise
     finally:
-        # --- Shutdown Sequence ---
         logger.info("ASGI Lifespan: Shutdown sequence initiated...")
         if ptb_app:
-            bot_username = ptb_app.bot.username if ptb_app.bot and ptb_app.bot.username else "N/A"
-            logger.info(f"PTB App instance found for @{bot_username}. Checking if running...")
-            is_running = getattr(ptb_app, '_running', False)
-            if is_running:
-                try:
-                    logger.info("Stopping PTB Application's background tasks...")
-                    await ptb_app.stop()
-                    logger.info("Shutting down PTB Application connections and resources...")
-                    await ptb_app.shutdown()
-                    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.")
-                 try:
-                     await ptb_app.shutdown()
-                     logger.info("Attempted shutdown of non-running PTB app completed.")
-                 except Exception as shutdown_err:
-                     logger.error(f"Error during shutdown of non-running PTB app: {shutdown_err}", exc_info=True)
-        else:
-            logger.warning("No PTB Application instance (ptb_app) found during ASGI shutdown.")
+            try:
+                await ptb_app.stop()
+                await ptb_app.shutdown()
+                logger.info("PTB Application shut down gracefully.")
+            except Exception as shutdown_err:
+                logger.error(f"Shutdown error: {shutdown_err}")
         logger.info("ASGI Lifespan: Shutdown complete.")
 
-
-# --- Flask App Setup (for Webhook Route) ---
+# --- Flask App Setup ---
 flask_core_app = Flask(__name__)
-logger.info("Core Flask app instance created (used by Starlette for routing).")
 
-# --- Define Flask Routes ---
 @flask_core_app.route('/')
 def index():
     """Basic health check endpoint."""
-    logger.debug("Health check endpoint '/' accessed.")
-    bot_status = "Unknown / Not Initialized"
+    bot_status = "Unknown"
     if ptb_app and ptb_app.bot:
-        is_running = 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."
+        bot_status = f"Running (@{ptb_app.bot.username})"
+    return f"Telegram Bot Summarizer - Status: {bot_status}"
 
 @flask_core_app.route('/webhook', methods=['POST'])
 async def webhook() -> Response:
     """Webhook endpoint called by Telegram."""
-    global ptb_app
-
     if not ptb_app:
-        logger.error("Webhook triggered, but PTB Application instance (ptb_app) is None. Lifespan likely failed.")
-        return Response('Bot service is not configured or failed during startup.', status=503)
+        return Response('Bot not initialized', status=503)
 
-    is_running = getattr(ptb_app, '_running', False)
-    if not is_running:
-        logger.error("Webhook triggered, but PTB Application is not currently running.")
-        return Response('Bot service is initialized but not actively running.', status=503)
-
-    logger.debug("Webhook endpoint received POST request from Telegram.")
     try:
         update_data = 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)
+            return Response('Bad Request', status=400)
 
         update = Update.de_json(update_data, ptb_app.bot)
-        logger.debug(f"Processing update_id: {update.update_id} via webhook route.")
-
-        # Let PTB's dispatcher handle the update asynchronously
-        # This will now call the appropriate handler (e.g., handle_summary_type_callback)
-        # which will *quickly* schedule the background task and return.
         await ptb_app.process_update(update)
-
-        logger.debug(f"Finished processing update_id: {update.update_id} in webhook handler (task scheduled).")
-        # Return 200 OK immediately to Telegram
         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:
-        logger.error(f"Error processing update in webhook handler: {e}", exc_info=True)
-        return Response('Internal Server Error processing update.', status=500)
-
+        logger.error(f"Webhook error: {e}")
+        return Response('Internal Server Error', status=500)
 
 # --- Create Starlette ASGI Application ---
 app = Starlette(
@@ -1033,25 +502,10 @@ app = Starlette(
         Mount("/", app=WSGIMiddleware(flask_core_app))
     ]
 )
-logger.info("Starlette ASGI application created, configured with lifespan and Flask app mounted at '/'.")
-
+logger.info("Starlette ASGI application created.")
 
 # --- Development Server Execution Block ---
 if __name__ == '__main__':
-    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:
-        local_port = int(os.environ.get('PORT', 8080))
-        logger.info(f"Starting Flask development server on http://0.0.0.0:{local_port}")
-        flask_core_app.run(host='0.0.0.0', port=local_port, debug=True, use_reloader=False)
+    logger.warning("Running in development mode (Flask server only)")
+    local_port = int(os.environ.get('PORT', 8080))
+    flask_core_app.run(host='0.0.0.0', port=local_port, debug=True, use_reloader=False)