Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Revised: Removed query.answer() call to avoid connection issue)
+# main.py (Revised: Use asyncio.create_task for callback processing)
 import os
 import re
 import logging
@@ -6,6 +6,7 @@ import asyncio
 import json
 import html # For unescaping HTML entities
 import contextlib # For async context manager (lifespan)
+import traceback # For logging exceptions in tasks
 
 # --- Frameworks ---
 from flask import Flask, request, Response # Core web routes
@@ -14,7 +15,7 @@ from starlette.routing import Mount # Mount Flask within Starlette
 from starlette.middleware.wsgi import WSGIMiddleware # Wrap Flask for Starlette
 
 # --- Telegram Bot ---
-from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, Bot # Import Bot
 from telegram.ext import (
     Application,
     CommandHandler,
@@ -24,11 +25,11 @@ from telegram.ext import (
     CallbackQueryHandler,
 )
 from telegram.constants import ParseMode
-from telegram.error import NetworkError, RetryAfter, TimedOut # Import TimedOut
-from telegram.request import HTTPXRequest # Import the request class
+from telegram.error import NetworkError, RetryAfter, TimedOut, BadRequest # Import BadRequest
+from telegram.request import HTTPXRequest
 
 # --- Other Libraries ---
-import httpx # Keep import, might be useful elsewhere or if upgrading PTB later
+import httpx
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
@@ -43,7 +44,6 @@ 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)
@@ -52,7 +52,6 @@ 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.")
 
@@ -79,7 +78,7 @@ logger.info("Secret loading attempt finished.")
 # (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 from previous version)
+#  get_website_content_via_urltotext_api, generate_summary - unchanged)
 
 # Helper Functions
 def is_youtube_url(url):
@@ -501,302 +500,349 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     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:
-    """Handles the /start command."""
-    user = update.effective_user
-    if not user: return
-    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) initiated /start.")
-    mention = user.mention_html() if user.username else user.first_name
-    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:
-    """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!"
-    )
-    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?://(?:[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 potential URL: {url}")
-        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 received:\n`{url}`\n\nChoose your desired summary format:",
-            reply_markup=reply_markup,
-            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.")
+# --- 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
+) -> 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}'")
 
-async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """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
-    user = query.from_user
-
-    # --- REMOVED/COMMENTED OUT query.answer() ---
-    # logger.debug(f"Attempting to answer callback query {query.id} for user {user.id}")
-    # try:
-    #     await query.answer()
-    #     logger.debug(f"Successfully answered callback query {query.id} for user {user.id}")
-    # except TimedOut:
-    #     logger.warning(f"Timeout answering callback query {query.id} for user {user.id}. Processing continues.")
-    # except Exception as e:
-    #     logger.error(f"Error answering callback query {query.id} for user {user.id}: {e!r}", exc_info=True)
-    # --- END REMOVAL ---
-
-    summary_type = query.data
-    url = context.user_data.get('url_to_summarize')
-    # Add log here since answer is removed
-    logger.info(f"User {user.id} chose summary type '{summary_type}'. Checking for stored URL (query_id: {query.id}).")
-
-
-    if not url:
-        logger.warning(f"User {user.id} pressed button '{summary_type}', but NO URL found in user_data context.")
-        try:
-            # Try to edit the original message even if we didn't answer the query
-            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:
-            logger.error(f"Failed to edit message for lost context for user {user.id}: {edit_err}")
-        return
-
-    logger.info(f"Processing URL '{url}' for user {user.id} with type '{summary_type}'.")
-    context.user_data.pop('url_to_summarize', None)
-    logger.debug(f"Cleared URL from user_data for user {user.id}")
-
+    # 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"API Key check for user {user.id} request: {keys_present}")
+    logger.debug(f"[Task {task_id}] API Key check: {keys_present}")
 
     if not current_openrouter_key:
-        logger.error(f"CRITICAL: OpenRouter API key is missing. Cannot generate summary for user {user.id}.")
+        logger.error(f"[Task {task_id}] CRITICAL: OpenRouter API key is missing. Cannot generate summary.")
         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.")
+            # 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"Failed to edit message for missing AI key for user {user.id}: {edit_err}")
-        return
+             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)_"
-    message_to_edit = query.message
-    status_message_sent = None
+    status_message_sent_id = None # Track if we sent a separate message
 
-    # Now, attempt to edit the message (this is the call that previously timed out)
     try:
-        if message_to_edit:
-            await query.edit_message_text(text=processing_message_text)
-            logger.debug(f"Successfully edited original message {message_to_edit.message_id} to show 'Working...' status for query {query.id} (after skipping answer).")
-        else:
-             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
-    except TimedOut as e:
-        # If this STILL times out even without query.answer(), the pool issue might be deeper
-        logger.error(f"POOL TIMEOUT occurred on edit_message_text even after skipping query.answer(). Query {query.id}. Error: {e!r}. Pool might still be blocked.")
-        message_to_edit = None
-        # Try sending a new message, but expect it might also fail
+        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_sent = await context.bot.send_message(chat_id=user.id, text=f"{processing_message_text}\n_(Experiencing delays)_")
-            logger.debug(f"Sent new status message {status_message_sent.message_id} to user {user.id} after edit timeout.")
-        except TimedOut:
-            logger.error(f"Timeout sending NEW 'Working...' status message to user {user.id} after edit also timed out.")
+            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"Failed sending NEW 'Working...' status message to user {user.id} after edit also timed out: {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:
-        # Handle other errors during edit_message_text
-        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
-        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} after edit failed.")
-        except Exception as send_err:
-            logger.error(f"Failed sending NEW 'Working...' status message to user {user.id} after edit failed: {send_err}")
+        # 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
 
-    # --- Main processing logic (unchanged) ---
     try:
+        # 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}")
+            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}")
 
+        # --- Determine Content Type and Fetch ---
         is_yt = is_youtube_url(url)
-        logger.debug(f"URL ({url}) is YouTube: {is_yt} (User: {user.id})")
+        logger.debug(f"[Task {task_id}] URL ({url}) is YouTube: {is_yt}")
 
         if is_yt:
             video_id = extract_youtube_id(url)
             if video_id:
-                logger.info(f"Fetching YouTube transcript for video ID: {video_id} (User: {user.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"Failed to get YouTube transcript for {video_id} (User: {user.id}).")
+                    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"Successfully fetched YouTube transcript for {video_id}. Length: {len(content)} (User: {user.id})")
+                     logger.info(f"[Task {task_id}] Successfully fetched YouTube transcript for {video_id}. Length: {len(content)}")
             else:
-                logger.warning(f"Failed to extract YouTube video ID from URL: {url} (User: {user.id})")
+                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:
-            logger.info(f"Attempting website scrape (Requests/BS4) for URL: {url} (User: {user.id})")
+            # --- Website Scraping ---
+            logger.info(f"[Task {task_id}] Attempting website scrape (Requests/BS4) for URL: {url}")
             content = await get_website_content_via_requests(url)
             if content:
-                logger.info(f"Website scrape successful (Requests/BS4). Length: {len(content)} (User: {user.id})")
+                logger.info(f"[Task {task_id}] Website scrape successful (Requests/BS4). Length: {len(content)}")
             else:
-                logger.warning(f"Primary website scrape failed for {url} (User: {user.id}). Trying fallback API.")
+                logger.warning(f"[Task {task_id}] Primary website scrape failed for {url}. Trying fallback API.")
                 if current_urltotext_key:
-                    try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before fallback scrape.")
+                    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"Attempting website scrape via URLToText API for: {url} (User: {user.id})")
+                    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"Website scrape successful via URLToText API. Length: {len(content)} (User: {user.id})")
+                        logger.info(f"[Task {task_id}] Website scrape successful via URLToText API. Length: {len(content)}")
                     else:
-                        logger.warning(f"Fallback website scrape (URLToText API) also failed for {url} (User: {user.id}).")
+                        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."
                 else:
-                    logger.warning(f"Primary scrape failed and URLToText API key not configured. Cannot fallback for {url} (User: {user.id}).")
+                    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"Content fetched (Length: {len(content)}). Generating '{summary_type}' summary for user {user.id}.")
-            try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before AI summary generation.")
+            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"AI summary generation failed for user {user.id}. Reason: {summary}")
+                logger.warning(f"[Task {task_id}] AI summary generation failed. Reason: {summary}")
                 user_feedback_message = f"⚠️ {summary}"
             else:
-                logger.info(f"Summary generated successfully for user {user.id}. Length: {len(summary)}. Sending result.")
+                # --- Summary Success - Send to User ---
+                logger.info(f"[Task {task_id}] Summary generated successfully. Length: {len(summary)}. Sending result.")
                 try:
-                    await context.bot.send_message(
-                        chat_id=user.id,
+                    await bot.send_message(
+                        chat_id=chat_id,
                         text=summary,
                         parse_mode=ParseMode.MARKDOWN,
                         link_preview_options={'is_disabled': True}
                     )
                     success = True
                     user_feedback_message = None
-                    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
+                    logger.info(f"[Task {task_id}] Successfully sent summary to chat {chat_id}.")
                 except Exception as send_final_err:
-                    logger.error(f"Failed sending final summary to user {user.id}: {send_final_err}", exc_info=True)
+                    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"Content retrieval resulted in None, but no specific user feedback message was set. URL: {url} (User: {user.id})")
+             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."
 
+        # --- 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}")
+            logger.warning(f"[Task {task_id}] Processing failed or summary sending failed. 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}.")
+                await bot.send_message(chat_id=chat_id, text=user_feedback_message)
             except Exception as send_feedback_err:
-                 logger.error(f"Failed sending final FAILURE feedback message to user {user.id}: {send_feedback_err}")
+                 logger.error(f"[Task {task_id}] Failed sending final FAILURE feedback message to chat {chat_id}: {send_feedback_err}")
 
     except Exception as e:
-        logger.error(f"Unexpected critical error during callback processing for user {user.id}, URL {url}: {e}", exc_info=True)
+        # 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)
         try:
-            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}.")
+            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"Failed sending CRITICAL internal error feedback message to user {user.id}: {final_err}")
+            logger.error(f"[Task {task_id}] Failed sending CRITICAL internal error feedback message to chat {chat_id}: {final_err}")
         success = False
 
     finally:
-        logger.debug(f"Cleaning up status message(s) for user {user.id}, query {query.id}. Success={success}")
+        # --- Clean up Status Message(s) ---
+        logger.debug(f"[Task {task_id}] Cleaning up status message(s). Success={success}")
         try:
-            if status_message_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 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:
-                    await query.delete_message()
-                    logger.debug(f"Processing succeeded. Deleted original (edited) message {message_to_edit.message_id} for query {query.id}.")
+                    # 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:
-                    logger.debug(f"Processing failed. Leaving edited message {message_to_edit.message_id} in place for query {query.id}.")
+                    # 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 TimedOut:
-            logger.warning(f"Timeout attempting to delete status/button message for user {user.id}, query {query.id}.")
         except Exception as del_e:
-            logger.warning(f"Could not delete status/button message for user {user.id}, query {query.id}: {del_e!r}")
+            logger.warning(f"[Task {task_id}] Could not delete status/button message during cleanup: {del_e!r}")
 
-        logger.info(f"Finished handling callback query {query.id} for user {user.id}. Overall Success: {success}")
+        logger.info(f"[Task {task_id}] Finished task processing for user {user_id}. Overall 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.")
+    mention = user.mention_html() if user.username else user.first_name
+    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:
+    """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!"
+    )
+    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?://(?:[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 potential URL: {url}")
+        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 received:\n`{url}`\n\nChoose your desired summary format:",
+            reply_markup=reply_markup,
+            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.")
+
+
+async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Handles button presses: gets data, clears context, schedules background task."""
+    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
+        return
+    user = query.from_user
+
+    # We skip query.answer() here to avoid potential connection issues.
+    # The button might stay loading visually for the user.
+
+    summary_type = query.data
+    url = context.user_data.get('url_to_summarize')
+    query_id = query.id # For logging
+
+    logger.info(f"User {user.id} chose summary type '{summary_type}'. Query ID: {query_id}. Checking for stored URL.")
+
+    if not url:
+        logger.warning(f"User {user.id} (Query {query_id}) pressed button '{summary_type}', but NO URL found in user_data context.")
+        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
+        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
+    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
+    asyncio.create_task(
+        process_summary_task(
+            user_id=user_id,
+            chat_id=chat_id,
+            message_id_to_edit=message_id_to_edit,
+            url=url,
+            summary_type=summary_type,
+            bot=bot_instance
+        ),
+        name=f"SummaryTask-{user_id}-{message_id_to_edit}" # Optional: name the task
+    )
+
+    # 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."""
-    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}")
-
-# --- Bot Setup Function (Corrected: Removed invalid 'limits' param for PTB v20) ---
+    """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."""
     logger.info("Configuring Telegram Application...")
@@ -824,13 +870,12 @@ async def setup_bot_config() -> Application:
 
     application_builder = Application.builder().token(TELEGRAM_TOKEN)
     application_builder.request(custom_request)
-
     application = application_builder.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))
+    application.add_handler(CallbackQueryHandler(handle_summary_type_callback)) # This handler now just schedules the task
     application.add_error_handler(error_handler)
 
     logger.info("Telegram application handlers configured.")
@@ -850,8 +895,6 @@ async def lifespan(app: Starlette):
         logger.info("PTB Application initialized. Starting background tasks (e.g., job queue)...")
         await ptb_app.start() # Starts dispatcher, job queue, etc. but NOT polling
 
-        # Removed updater.stop() call here as it caused RuntimeError
-
         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}")
@@ -868,6 +911,7 @@ async def lifespan(app: Starlette):
                 await bot_instance.set_webhook(
                     url=full_webhook_url,
                     allowed_updates=Update.ALL_TYPES,
+                    # drop_pending_updates=True # Consider adding this if startup issues persist
                 )
                 webhook_info = await bot_instance.get_webhook_info()
                 if webhook_info and webhook_info.url == full_webhook_url:
@@ -894,6 +938,8 @@ async def lifespan(app: Starlette):
 
     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()
         raise
     finally:
         # --- Shutdown Sequence ---
@@ -954,7 +1000,6 @@ async def webhook() -> Response:
 
     logger.debug("Webhook endpoint received POST request from Telegram.")
     try:
-        # Use Flask's synchronous get_json within the async route via WSGIMiddleware
         update_data = request.get_json()
         if not update_data:
             logger.warning("Received empty or non-JSON data on webhook.")
@@ -964,10 +1009,13 @@ async def webhook() -> Response:
         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}")
-        return Response('ok', status=200) # Acknowledge receipt to Telegram
+        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)