Update main.py

main.py

@@ -53,6 +53,7 @@ except ImportError:
 # --- Google Gemini ---
 try:
     import google.generativeai as genai
+    # Import specific types needed, check library for exact names if errors occur
     from google.generativeai.types import HarmCategory, HarmBlockThreshold, GenerateContentResponse
     _gemini_available = True
 except ImportError:
@@ -112,8 +113,8 @@ GEMINI_API_KEY = get_secret('GEMINI_API_KEY')         # Primary Summarizer
 # Models (User can still configure via env vars)
 OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324:free") # Fallback Model
 APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts")
-GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-1.5-flash-latest") # Use the 1.5 flash model directly
-# Using gemini-1.5-flash-latest is generally recommended over gemini-2.0-flash-001
+# *** Reverted Model Name as requested ***
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash-001") # Primary Model
 
 # --- Configuration Checks ---
 if not TELEGRAM_TOKEN: logger.critical("❌ FATAL: TELEGRAM_TOKEN not found."); raise RuntimeError("Exiting: Telegram token missing.")
@@ -159,7 +160,10 @@ if _gemini_primary_enabled:
 
 # --- Constants ---
 MAX_SUMMARY_CHUNK_SIZE = 4000 # Max characters per Telegram message (allow buffer)
-MAX_INPUT_TOKEN_APPROX = 1000000 # Gemini 1.5 Flash context window (approx chars) - adjust if needed
+# Adjust based on gemini-2.0-flash context window if known, 1M was for 1.5 Flash
+# Let's use a more conservative estimate for 2.0 Flash, e.g., 128k tokens ~ 500k chars? Check Gemini docs.
+# Sticking with a large number for now, but be aware this might need adjustment.
+MAX_INPUT_TOKEN_APPROX = 500000
 
 # --- Retry Decorator ---
 # (Remains the same)
@@ -181,11 +185,16 @@ async def retry_bot_operation(func, *args, **kwargs):
         if any(err in str(e).lower() for err in ignore_errors):
             logger.warning(f"Ignoring non-critical BadRequest: {e}")
             return None
+        # Only raise if it's not an ignored error
         logger.error(f"Potentially critical BadRequest: {e}")
         raise
     except TelegramError as e:
-        logger.warning(f"TelegramError (will retry if applicable): {e}")
-        raise
+        # Log specific transient errors that might trigger retry
+        if isinstance(e, (TimedOut, NetworkError, RetryAfter)):
+            logger.warning(f"Telegram transient error (will retry): {e}")
+        else:
+            logger.error(f"Unhandled TelegramError: {e}") # Log other Telegram errors
+        raise # Reraise to allow tenacity to handle retry
     except Exception as e:
         logger.error(f"Unexpected error during bot operation: {e}", exc_info=True)
         raise
@@ -205,7 +214,7 @@ def extract_youtube_id(url):
 # --- Content Fetching Functions ---
 
 # - YouTube Transcript Fetching (get_transcript_via_supadata, get_transcript_via_apify, get_youtube_transcript) -
-# (These functions remain exactly the same as in your provided code)
+# (No changes needed in these functions)
 async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[str]:
     # ... (Keep existing implementation) ...
     if not video_id: logger.error("[Supadata] No video_id provided"); return None
@@ -295,20 +304,30 @@ async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]
     transcript_text = None
     logger.info("[Primary YT] Attempting youtube-transcript-api...")
     try:
-        transcript_list = await asyncio.to_thread( YouTubeTranscriptApi.get_transcript, video_id, languages=['en', 'en-GB', 'en-US'] )
+        # Run the blocking call in a separate thread
+        transcript_list = await asyncio.to_thread(
+            YouTubeTranscriptApi.list_transcripts(video_id).find_generated_transcript(['en', 'en-GB', 'en-US']).fetch
+        )
+        # transcript_list = await asyncio.to_thread( YouTubeTranscriptApi.get_transcript, video_id, languages=['en', 'en-GB', 'en-US'] ) # Old way
         if transcript_list: transcript_text = " ".join([item['text'] for item in transcript_list if 'text' in item])
-        if transcript_text: logger.info(f"[Primary YT] Success via lib for {video_id} (len: {len(transcript_text)})"); return transcript_text
+        if transcript_text: logger.info(f"[Primary YT] Success via lib for {video_id} (len: {len(transcript_text)})"); return transcript_text.strip()
         else: logger.warning(f"[Primary YT] Transcript list/text empty for {video_id}"); transcript_text = None
+    except TranscriptsDisabled:
+        logger.warning(f"[Primary YT] Transcripts are disabled for video {video_id}")
+        transcript_text = None
+    except NoTranscriptFound:
+         logger.warning(f"[Primary YT] No English transcript found for video {video_id}")
+         transcript_text = None
     except Exception as e:
         logger.warning(f"[Primary YT] Error via lib for {video_id}: {e}")
-        if isinstance(e, (NoTranscriptFound, TranscriptsDisabled)): logger.warning(f"[Primary YT] Known issue: {type(e).__name__}")
+        # if isinstance(e, (NoTranscriptFound, TranscriptsDisabled)): logger.warning(f"[Primary YT] Known issue: {type(e).__name__}") # Handled above
         transcript_text = None
 
     if transcript_text is None:
         logger.info("[Fallback YT 1] Trying Supadata API...")
         if SUPADATA_API_KEY:
             transcript_text = await get_transcript_via_supadata(video_id, SUPADATA_API_KEY)
-            if transcript_text: logger.info(f"[Fallback YT 1] Success via Supadata for {video_id}"); return transcript_text
+            if transcript_text: logger.info(f"[Fallback YT 1] Success via Supadata for {video_id}"); return transcript_text # Already stripped
             else: logger.warning(f"[Fallback YT 1] Supadata failed or no content for {video_id}.")
         else: logger.warning("[Fallback YT 1] Supadata API key unavailable. Skipping.")
 
@@ -316,7 +335,7 @@ async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]
         logger.info("[Fallback YT 2] Trying Apify REST API (SyncItems)...")
         if APIFY_API_TOKEN:
             transcript_text = await get_transcript_via_apify(video_url, APIFY_API_TOKEN)
-            if transcript_text: logger.info(f"[Fallback YT 2] Success via Apify SyncItems REST for {video_url}"); return transcript_text
+            if transcript_text: logger.info(f"[Fallback YT 2] Success via Apify SyncItems REST for {video_url}"); return transcript_text # Already stripped
             else: logger.warning(f"[Fallback YT 2] Apify SyncItems REST failed or no content for {video_url}.")
         else: logger.warning("[Fallback YT 2] Apify API token unavailable. Skipping.")
 
@@ -340,35 +359,21 @@ async def get_website_content_via_crawl4ai(url: str) -> Optional[str]:
 
     logger.info(f"[Crawl4AI Primary] Attempting to crawl URL: {url}")
     # Define a writable cache directory (use /tmp in container environments)
-    # Create the directory path beforehand to avoid potential race conditions or permission issues within the library
-    cache_dir_path = "/tmp/.crawl4ai" # CHANGED: Use /tmp
-    try:
-        os.makedirs(cache_dir_path, exist_ok=True)
-        logger.info(f"[Crawl4AI Primary] Ensured cache directory exists: {cache_dir_path}")
-    except OSError as e:
-        logger.error(f"[Crawl4AI Primary] Failed to create cache directory {cache_dir_path}: {e}. Crawl may fail.")
-        # Don't return here, let the crawler try anyway, it might handle it internally or use default
-    except Exception as e:
-         logger.error(f"[Crawl4AI Primary] Unexpected error creating cache directory {cache_dir_path}: {e}")
-
+    # No longer creating dir here, relying on HOME=/tmp from Dockerfile
+    # cache_dir_path = "/tmp/.crawl4ai"
+    # try:
+    #     os.makedirs(cache_dir_path, exist_ok=True)
+    #     logger.info(f"[Crawl4AI Primary] Ensured cache directory exists: {cache_dir_path}")
+    # except OSError as e:
+    #     logger.error(f"[Crawl4AI Primary] Failed to create cache directory {cache_dir_path}: {e}. Crawl may fail.")
+    # except Exception as e:
+    #      logger.error(f"[Crawl4AI Primary] Unexpected error creating cache directory {cache_dir_path}: {e}")
 
     try:
-        # Use AsyncWebCrawler context manager with explicit cache_dir
-        # NOTE: Pass cache_dir here if the library supports it via __init__ or a config object
-        # Checking crawl4ai docs/source, AsyncWebCrawler doesn't directly take cache_dir in __init__.
-        # It seems to rely on environment variables or default home resolution.
-        # The PermissionError happens in RobotsParser -> get_home_folder -> os.makedirs.
-        # WORKAROUND: We might need to adjust the environment or hope setting HOME=/app in Dockerfile is enough
-        # *if* the library correctly uses HOME. Let's test *without* explicit cache_dir first,
-        # relying on HOME=/app and the prior os.makedirs call. If it still fails, we need a different approach.
-
-        # UPDATE: The traceback shows it uses utils.get_home_folder(). Let's stick with HOME=/app for now
-        # and see if the permission error was transient or specific to the '.models' subdir.
-        # If it persists, we might need to fork/modify crawl4ai or find another way to configure its paths.
-
-        # Let's *try* passing cache_dir anyway, maybe it's an undocumented/newer feature
-        async with AsyncWebCrawler(cache_dir=cache_dir_path) as crawler: # TRY passing cache_dir
-            logger.info(f"[Crawl4AI Primary] Initialized with explicit cache_dir: {cache_dir_path}")
+        # Use AsyncWebCrawler context manager.
+        # Removed explicit cache_dir, relying on HOME=/tmp from Dockerfile
+        async with AsyncWebCrawler() as crawler:
+            logger.info(f"[Crawl4AI Primary] Initialized crawler (HOME should be /tmp).")
             # Use arun for a single URL crawl
             result = await crawler.arun(url=url, crawler_strategy="playwright", timeout=90) # 90 sec timeout
 
@@ -379,14 +384,20 @@ async def get_website_content_via_crawl4ai(url: str) -> Optional[str]:
                 return content
             else:
                 logger.warning(f"[Crawl4AI Primary] Crawl successful for {url}, but extracted markdown content is empty.")
-                return None
-        elif result and result.text: # Fallback to raw text if markdown is somehow empty
+                # Try result.text as a fallback within crawl4ai success
+                if result.text:
+                     content = result.text.strip()
+                     if content:
+                         logger.info(f"[Crawl4AI Primary] Using .text fallback after empty markdown. Length: {len(content)}")
+                         return content
+                return None # Return None if both markdown and text are empty
+        elif result and result.text: # Fallback to raw text if markdown is somehow missing entirely
              content = result.text.strip()
              if content:
-                 logger.info(f"[Crawl4AI Primary] Success crawling {url} (using .text). Length: {len(content)}")
+                 logger.info(f"[Crawl4AI Primary] Success crawling {url} (using .text, markdown missing). Length: {len(content)}")
                  return content
              else:
-                 logger.warning(f"[Crawl4AI Primary] Crawl successful for {url}, but extracted text content is empty.")
+                 logger.warning(f"[Crawl4AI Primary] Crawl successful for {url}, but extracted text content is empty (markdown missing).")
                  return None
         else:
             logger.warning(f"[Crawl4AI Primary] Crawl failed or returned no result/content for {url}.")
@@ -395,14 +406,12 @@ async def get_website_content_via_crawl4ai(url: str) -> Optional[str]:
         logger.error(f"[Crawl4AI Primary] Timeout occurred while crawling {url}")
         return None
     except PermissionError as e: # Catch the specific error
-        logger.error(f"[Crawl4AI Primary] Permission denied during crawl for {url}. Likely filesystem issue in container. Error: {e}", exc_info=True)
+        # Log more detail if possible
+        logger.error(f"[Crawl4AI Primary] Permission denied during crawl for {url}. Target path: '{e.filename}'. Likely filesystem issue or HOME=/tmp not effective. Error: {e}", exc_info=True)
         return None # Fail gracefully for this method
     except Exception as e:
-        # Log type error if cache_dir isn't accepted
-        if "unexpected keyword argument 'cache_dir'" in str(e):
-            logger.error(f"[Crawl4AI Primary] AsyncWebCrawler does not accept 'cache_dir'. Remove this argument. Error: {e}")
-        else:
-            logger.error(f"[Crawl4AI Primary] Unexpected error during crawl for {url}: {e}", exc_info=True)
+        logger.error(f"[Crawl4AI Primary] Unexpected error during crawl for {url}: {e}", exc_info=True)
+        # Log specific crawl4ai errors if they become apparent
         return None
 
 
@@ -445,11 +454,16 @@ async def get_website_content_bs4(url: str) -> Optional[str]:
             for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio"]):
                 element.extract()
             # Try to find main content areas more broadly
-            selectors = ['main', 'article', '[role="main"]', '#content', '.content', '#main-content', '.main-content', '#body', '.body', '#article-body', '.article-body']
+            selectors = ['main', 'article', '[role="main"]', '#content', '.content', '#main-content', '.main-content', '#body', '.body', '#article-body', '.article-body', '.post-content', '.entry-content'] # Added more common selectors
             target_element = None
             for selector in selectors:
-                target_element = soup.select_one(selector)
-                if target_element: break
+                try:
+                    target_element = soup.select_one(selector)
+                    if target_element: break
+                except Exception as sel_e: # Catch potential invalid CSS selectors from list
+                     logger.warning(f"[BS4 Fallback] Invalid selector '{selector}': {sel_e}")
+                     continue
+
 
             if not target_element: target_element = soup.body # Fallback to body
             if not target_element: logger.warning(f"[BS4 Fallback] Could not find body/main for parsing {url}"); return None
@@ -557,7 +571,7 @@ Key Bullet Points Summary:"""
     generation_config = genai.types.GenerationConfig(
         # candidate_count=1, # Default is 1
         # stop_sequences=["\n"],
-        max_output_tokens=2048, # Increased max tokens for potentially longer summaries from large inputs
+        max_output_tokens=2048, # Increased max tokens
         temperature=0.7, # Adjust creativity vs factualness
         # top_p=1.0, # Default
         # top_k=None # Default
@@ -569,44 +583,68 @@ Key Bullet Points Summary:"""
         response: GenerateContentResponse = await model.generate_content_async( # Use async version
             prompt,
             generation_config=generation_config,
-            safety_settings=safety_settings
+            safety_settings=safety_settings,
+            # request_options={"timeout": 100} # Optional: Add timeout for the API call itself
         )
-        logger.debug(f"[Gemini Primary] Received response. Finish reason: {response.candidates[0].finish_reason if response.candidates else 'N/A'}")
 
         # Check for safety blocks or other issues in response
         if not response.candidates:
-             block_reason = response.prompt_feedback.block_reason if hasattr(response, 'prompt_feedback') else 'Unknown'
+             block_reason = "Unknown"
+             if hasattr(response, 'prompt_feedback') and response.prompt_feedback:
+                  block_reason = response.prompt_feedback.block_reason or "Reason not specified"
              error_msg = f"Error: Gemini response blocked or empty. Reason: {block_reason}"
              logger.error(f"[Gemini Primary] {error_msg}")
              return None, error_msg
 
-        # Check finish reason (e.g., MAX_TOKENS, SAFETY)
-        finish_reason = response.candidates[0].finish_reason
-        if finish_reason != genai.types.FinishReason.STOP and finish_reason != genai.types.FinishReason.MAX_TOKENS:
+        # *** FIXED FinishReason Check ***
+        # Access finish_reason from the first candidate
+        finish_reason_val = response.candidates[0].finish_reason
+        logger.debug(f"[Gemini Primary] Received response. Finish reason value: {finish_reason_val}")
+
+        # Convert the finish reason (might be enum/int/string) to uppercase string for reliable comparison
+        finish_reason_str = str(finish_reason_val).upper()
+
+        # Check if it's NOT a successful or expected non-error finish
+        # Expected "good" finishes: STOP, MAX_TOKENS
+        # Problematic finishes: SAFETY, RECITATION, OTHER, etc.
+        if finish_reason_str not in ["STOP", "MAX_TOKENS"]:
              # Log safety ratings if available
              safety_ratings_str = "N/A"
-             if hasattr(response.candidates[0], 'safety_ratings'):
+             if hasattr(response.candidates[0], 'safety_ratings') and response.candidates[0].safety_ratings:
                  safety_ratings_str = ', '.join([f"{r.category.name}: {r.probability.name}" for r in response.candidates[0].safety_ratings])
-             error_msg = f"Error: Gemini generation finished unexpectedly. Reason: {finish_reason.name}. Safety: {safety_ratings_str}"
+
+             error_msg = f"Error: Gemini generation finished unexpectedly. Reason: {finish_reason_str}. Safety: {safety_ratings_str}"
              logger.error(f"[Gemini Primary] {error_msg}")
-             # Return partial text if available and finish reason is MAX_TOKENS? Maybe not, could be truncated badly.
-             # If SAFETY, definitely return error.
-             if finish_reason == genai.types.FinishReason.SAFETY:
-                  return None, error_msg # Return specific error for safety blocks
-             # For other reasons, maybe return partial, but safer to return error for now
-             # return response.text if hasattr(response, 'text') else None, error_msg # Optional: return partial text for RECITATION/OTHER
-             return None, f"Error: Gemini generation finished unexpectedly ({finish_reason.name})."
 
+             # Decide how to handle specific non-STOP reasons
+             if finish_reason_str == "SAFETY":
+                 return None, error_msg # Return specific error for safety blocks
+             # For RECITATION, OTHER, etc., it's safer to return an error than potentially broken output
+             return None, f"Error: Gemini generation finished unexpectedly ({finish_reason_str})."
+
+        # Extract text (use response.text shortcut if available and reliable)
+        summary_text = ""
+        try:
+            # response.text might combine parts automatically, safer if available
+            summary_text = response.text
+        except ValueError as e:
+            # Handle cases where .text might raise error (e.g., if blocked, but caught above ideally)
+            logger.warning(f"[Gemini Primary] Error accessing response.text: {e}. Trying parts manually.")
+            # Fallback to joining parts if .text fails (less common now)
+            if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+                summary_text = "".join(part.text for part in response.candidates[0].content.parts)
 
-        # Extract text
-        summary_text = response.text
         if not summary_text or not summary_text.strip():
             logger.warning("[Gemini Primary] Gemini returned an empty summary.")
             return None, "Error: AI generated an empty summary."
 
-        logger.info(f"[Gemini Primary] Summary generated successfully (len: {len(summary_text)}).")
+        logger.info(f"[Gemini Primary] Summary generated successfully (len: {len(summary_text)}). Finish: {finish_reason_str}")
         return summary_text.strip(), None
 
+    except AttributeError as e:
+         # Catch potential errors if response structure is different than expected
+         logger.error(f"[Gemini Primary] Attribute error accessing Gemini response: {e}. Response structure might have changed.", exc_info=True)
+         return None, f"Error: Failed to parse Gemini response. Details: {e}"
     except Exception as e:
         logger.error(f"[Gemini Primary] Error during API call to {GEMINI_MODEL}: {e}", exc_info=True)
         # Check for specific Google API errors if needed
@@ -617,14 +655,13 @@ Key Bullet Points Summary:"""
 
 async def _call_openrouter(text: str, summary_type: str) -> Tuple[Optional[str], Optional[str]]:
     """ Calls the OpenRouter API to generate a summary. """
+    # ... (Keep existing implementation - no changes needed here based on logs) ...
     global OPENROUTER_API_KEY, OPENROUTER_MODEL, _openrouter_fallback_enabled
     if not _openrouter_fallback_enabled:
         logger.error("[OpenRouter Fallback] Called but is disabled.");
         return None, "Error: Fallback AI service (OpenRouter) not configured/available."
 
-    # OpenRouter models might have smaller context windows, truncate more aggressively if needed
-    # Example: 32k tokens ~ 120k chars. Deepseek is large though. Check model specifics if issues arise.
-    max_input_len_openrouter = 100000 # Adjust based on OPENROUTER_MODEL limits if known
+    max_input_len_openrouter = 100000 # Adjust based on OPENROUTER_MODEL limits if known (Deepseek is large)
     if len(text) > max_input_len_openrouter:
         logger.warning(f"[OpenRouter Fallback] Input text length ({len(text)}) exceeds approx limit ({max_input_len_openrouter}) for {OPENROUTER_MODEL}. Truncating.")
         text = text[:max_input_len_openrouter]
@@ -682,11 +719,13 @@ Key Bullet Points Summary:"""
                 try:
                     data = response.json()
                     if data.get("choices") and len(data["choices"]) > 0:
-                        message = data["choices"][0].get("message")
+                        choice = data["choices"][0]
+                        message = choice.get("message")
+                        finish_reason = choice.get("finish_reason", "N/A") # Get finish reason
+
                         if message and message.get("content"):
                             summary_text = message["content"].strip()
                             if summary_text:
-                                finish_reason = data["choices"][0].get("finish_reason", "N/A")
                                 logger.info(f"[OpenRouter Fallback] Summary generated successfully (len: {len(summary_text)}). Finish: {finish_reason}")
                                 # Check for length finish reason?
                                 if finish_reason == 'length':
@@ -735,6 +774,7 @@ Key Bullet Points Summary:"""
 
 async def generate_summary(text: str, summary_type: str) -> str:
     """ Generates a summary using the primary AI (Gemini) and falling back to OpenRouter. """
+    # ... (Keep existing implementation - no changes needed here based on logs) ...
     global _gemini_primary_enabled, _openrouter_fallback_enabled, GEMINI_MODEL, OPENROUTER_MODEL
     logger.info(f"[Summary Generation] Starting process. Primary: Gemini ({GEMINI_MODEL}), Fallback: OpenRouter ({OPENROUTER_MODEL})")
     final_summary: Optional[str] = None
@@ -791,6 +831,7 @@ async def process_summary_task(
     bot_token: str
 ) -> None:
     """Handles fetching content, generating summary, and sending results."""
+    # ... (Keep existing implementation - no changes needed here based on logs) ...
     task_id = f"{user_id}-{message_id_to_edit or 'new'}"
     logger.info(f"[Task {task_id}] Starting processing for URL: {url}")
     background_request: Optional[BaseRequest] = None
@@ -798,8 +839,8 @@ async def process_summary_task(
     content: Optional[str] = None
     user_feedback_message: Optional[str] = None
     success = False
-    status_message_id = message_id_to_edit
-    message_to_delete_later_id: Optional[int] = None
+    status_message_id = message_id_to_edit # Keep track of the original button message ID
+    message_to_delete_later_id: Optional[int] = None # For temporary "Processing..." messages
 
     try:
         # Initialize background bot
@@ -807,12 +848,15 @@ async def process_summary_task(
         bot = Bot(token=bot_token, request=background_request)
     except Exception as e:
         logger.critical(f"[Task {task_id}] Failed to create background bot: {e}", exc_info=True)
+        # Cannot send feedback without bot
         return
 
     try:
         # Send/Edit "Processing..." message
+        # We *always* edit the original button message first
         processing_message_text = f"Got it! Generating '{summary_type}' summary for:\n{html.escape(url)}\n\nThis might take a moment..."
-        if status_message_id:
+        edited_original_msg = False
+        if status_message_id: # If we have the ID of the message with buttons
             try:
                 await retry_bot_operation(
                     bot.edit_message_text,
@@ -820,32 +864,15 @@ async def process_summary_task(
                     message_id=status_message_id,
                     text=processing_message_text,
                     parse_mode=ParseMode.HTML, # Use HTML for escaped URL
-                    reply_markup=None,
+                    reply_markup=None, # Remove buttons
                     link_preview_options={'is_disabled': True} # Disable preview here too
                 )
-                logger.debug(f"[Task {task_id}] Edited message {status_message_id} to 'Processing'")
-            except Exception as e:
-                logger.warning(f"[Task {task_id}] Could not edit original message {status_message_id}: {e}. Sending new.")
-                status_message_id = None # Flag to send a new message
-
-        if not status_message_id: # If editing failed or wasn't applicable
-            try:
-                status_message = await retry_bot_operation(
-                    bot.send_message,
-                    chat_id=chat_id,
-                    text=processing_message_text,
-                    parse_mode=ParseMode.HTML, # Use HTML for escaped URL
-                    link_preview_options={'is_disabled': True}
-                )
-                if status_message:
-                    message_to_delete_later_id = status_message.message_id
-                    logger.debug(f"[Task {task_id}] Sent new status message {message_to_delete_later_id}")
-                else:
-                    raise RuntimeError("Failed to send status message after retries.")
+                logger.debug(f"[Task {task_id}] Edited original button message {status_message_id} to 'Processing'")
+                edited_original_msg = True
             except Exception as e:
-                logger.error(f"[Task {task_id}] CRITICAL: Failed to send new status message: {e}")
-                user_feedback_message = "Sorry, there was an issue starting the process."
-                # Attempt to send final feedback later if possible
+                logger.warning(f"[Task {task_id}] Could not edit original button message {status_message_id}: {e}. Will proceed without initial status update on that message.")
+                # Don't send a new message here, the final result/error will handle it.
+                # Keep status_message_id so we know the original message still exists.
 
         # Indicate activity
         try: await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')
@@ -870,6 +897,7 @@ async def process_summary_task(
             content = await get_website_content_via_crawl4ai(url)
 
             if not content:
+                # Log the failure reason from Crawl4AI if available (already logged in the function)
                 logger.warning(f"[Task {task_id}] Crawl4AI failed for {url}. Attempting BeautifulSoup (Fallback 1)...")
                 try: await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')
                 except Exception: pass
@@ -883,8 +911,6 @@ async def process_summary_task(
                         except Exception: pass
                         content = await get_website_content_via_api(url, URLTOTEXT_API_KEY)
                         if not content:
-                            # Check if the specific error was insufficient credits
-                            # Note: get_website_content_via_api already logs the specific error
                             logger.error(f"[Task {task_id}] API fallback (urltotext) also failed for {url}.")
                             user_feedback_message = "Sorry, I couldn't fetch content from that website using any method (Crawl4AI/BS4 failed, API failed or ran out of credits)." # Updated message
                     else:
@@ -908,68 +934,50 @@ async def process_summary_task(
             if final_summary.startswith("Error:") or final_summary.startswith("Sorry,"):
                 user_feedback_message = final_summary # Pass AI error message to user
                 logger.warning(f"[Task {task_id}] Summary generation failed: {final_summary}")
+                success = False # Explicitly mark as failure
             else:
-                # Success - Send the summary
+                # Success - Split and Send the summary
                 summary_parts = []
                 current_part = ""
                 # Split respecting newlines, ensure no part exceeds MAX_SUMMARY_CHUNK_SIZE
                 lines = final_summary.splitlines(keepends=True)
                 for line in lines:
-                     # If adding the next line exceeds the limit, finalize the current part
                      if len(current_part) + len(line) > MAX_SUMMARY_CHUNK_SIZE:
                          if current_part.strip(): # Don't add empty parts
                              summary_parts.append(current_part.strip())
-                         current_part = line # Start new part with the current line
-                         # If a single line itself is too long, truncate it (edge case)
+                         current_part = line
                          if len(current_part) > MAX_SUMMARY_CHUNK_SIZE:
                               logger.warning(f"[Task {task_id}] Truncating overly long line in summary.")
                               current_part = current_part[:MAX_SUMMARY_CHUNK_SIZE]
                      else:
                          current_part += line
-
-                # Add the last part if it has content
-                if current_part.strip():
-                    summary_parts.append(current_part.strip())
-
-                # If somehow splitting resulted in nothing (e.g., empty summary initially?)
+                if current_part.strip(): summary_parts.append(current_part.strip())
                 if not summary_parts:
                      summary_parts.append("Summary generated, but it appears to be empty.")
                      logger.warning(f"[Task {task_id}] Summary was non-empty initially but splitting resulted in zero parts.")
 
-
                 logger.info(f"[Task {task_id}] Summary generated (orig len: {len(final_summary)}). Sending in {len(summary_parts)} part(s).")
 
-                # Determine the target message ID for the *first* part
-                # Prefer editing the "Processing..." message if we sent a new one
-                edit_target_id = message_to_delete_later_id if message_to_delete_later_id else status_message_id
-                message_sent = False
-
-                if edit_target_id:
+                # Try to edit the original button message with the *first* part of the summary
+                edited_final_result = False
+                if status_message_id: # If we have the original button message ID
                     try:
-                        # Try editing the status message first
                         await retry_bot_operation(
                             bot.edit_message_text,
                             chat_id=chat_id,
-                            message_id=edit_target_id,
+                            message_id=status_message_id,
                             text=summary_parts[0],
                             parse_mode=None, # Send as plain text initially, safer
                             link_preview_options={'is_disabled': True}
                         )
-                        logger.debug(f"[Task {task_id}] Edited message {edit_target_id} with first summary part.")
-                        # Prevent this message from being deleted later if it was the 'Processing...' one
-                        if message_to_delete_later_id == edit_target_id: message_to_delete_later_id = None
-                        # If it was the *original* button message that we are editing, keep status_message_id
-                        # so we know *not* to delete it in finally block if it's the only message left.
-                        # However, it's clearer to just prevent deletion if edited.
-                        if status_message_id == edit_target_id: status_message_id = None # Mark as handled
-
-                        message_sent = True
+                        logger.debug(f"[Task {task_id}] Edited original button message {status_message_id} with first summary part.")
+                        edited_final_result = True
                     except Exception as edit_err:
-                         logger.warning(f"[Task {task_id}] Failed to edit message {edit_target_id} with summary: {edit_err}. Sending new message instead.")
-                         # If edit fails, fall through to send a new message
+                        logger.warning(f"[Task {task_id}] Failed to edit original button message {status_message_id} with summary part 1: {edit_err}. Sending as new message.")
+                        # Original message remains as "Processing..." or its initial state if first edit failed
 
-                if not message_sent:
-                     # Send the first part as a new message
+                # If editing failed, or if there was no original message_id (shouldn't happen), send first part as new message
+                if not edited_final_result:
                      sent_msg = await retry_bot_operation(
                         bot.send_message,
                         chat_id=chat_id,
@@ -977,15 +985,13 @@ async def process_summary_task(
                         parse_mode=None,
                         link_preview_options={'is_disabled': True}
                      )
-                     if sent_msg:
-                        logger.debug(f"[Task {task_id}] Sent first summary part as new message {sent_msg.message_id}.")
-                     else: # Should be caught by retry, but log defensively
+                     if not sent_msg:
                         logger.error(f"[Task {task_id}] Failed to send first summary part even as new message.")
-                        user_feedback_message = "Sorry, failed to send the summary." # Set error
-
+                        user_feedback_message = "Sorry, failed to send the summary."
+                        success = False
 
                 # Send remaining parts (if any and first part succeeded)
-                if not user_feedback_message and len(summary_parts) > 1:
+                if success and len(summary_parts) > 1: # Check success flag before sending more parts
                     for i, part in enumerate(summary_parts[1:], start=2):
                         await asyncio.sleep(0.5) # Small delay between parts
                         try:
@@ -1000,40 +1006,40 @@ async def process_summary_task(
                         except Exception as part_err:
                              logger.error(f"[Task {task_id}] Failed to send summary part {i}: {part_err}")
                              user_feedback_message = f"Sorry, failed to send part {i} of the summary."
-                             # Should we stop sending further parts? Yes.
+                             success = False # Mark as failure
                              break # Stop sending remaining parts
 
-                # Determine overall success based on whether feedback message is set
+                # Determine overall success based on whether feedback message is set *during this block*
                 if not user_feedback_message:
                     success = True
-                # user_feedback_message = None # Clear feedback message ONLY on full success
 
-        # --- Handle Cases Where No Content Was Fetched or Summary Failed ---
-        if user_feedback_message: # Check if any error occurred
+        # --- Handle Failure Cases (Content Fetching Failed or Summary Failed) ---
+        if not success: # Check overall success flag
+            if not user_feedback_message: # If success is false but no specific message, set a generic one
+                user_feedback_message = "Sorry, an unknown error occurred during processing."
+                logger.error(f"[Task {task_id}] Task failed but no specific user_feedback_message was set.")
+
             logger.warning(f"[Task {task_id}] Sending failure/error feedback to user: {user_feedback_message}")
             try:
-                # Try editing the status message first
-                feedback_target_id = message_to_delete_later_id if message_to_delete_later_id else status_message_id
-                message_sent = False
-                if feedback_target_id:
+                # Try editing the original button message with the error
+                edited_final_error = False
+                if status_message_id:
                     try:
                         await retry_bot_operation(
                             bot.edit_message_text,
                             chat_id=chat_id,
-                            message_id=feedback_target_id,
+                            message_id=status_message_id,
                             text=user_feedback_message,
                             link_preview_options={'is_disabled': True},
                             reply_markup=None # Remove buttons
                         )
-                        logger.debug(f"[Task {task_id}] Edited message {feedback_target_id} with failure feedback.")
-                        # Prevent deletion if edited
-                        if message_to_delete_later_id == feedback_target_id: message_to_delete_later_id = None
-                        if status_message_id == feedback_target_id: status_message_id = None
-                        message_sent = True
+                        logger.debug(f"[Task {task_id}] Edited original button message {status_message_id} with failure feedback.")
+                        edited_final_error = True
                     except Exception as edit_err:
-                         logger.warning(f"[Task {task_id}] Failed to edit message {feedback_target_id} with failure feedback: {edit_err}. Sending new message instead.")
+                         logger.warning(f"[Task {task_id}] Failed to edit original button message {status_message_id} with failure feedback: {edit_err}. Sending as new message.")
 
-                if not message_sent:
+                # If editing failed or wasn't applicable, send error as a new message
+                if not edited_final_error:
                     await retry_bot_operation(
                         bot.send_message,
                         chat_id=chat_id,
@@ -1046,36 +1052,28 @@ async def process_summary_task(
 
     except Exception as e:
         # Catch-all for unexpected errors during the main processing logic
-        logger.error(f"[Task {task_id}] Unexpected error during processing: {e}", exc_info=True)
+        logger.error(f"[Task {task_id}] Unexpected error during processing task: {e}", exc_info=True)
+        success = False
         user_feedback_message = "Oops! Something went wrong while processing your request. Please try again later."
         if bot: # Ensure bot exists before trying to send
             try:
-                # Attempt to send a final error message
-                await retry_bot_operation(
-                    bot.send_message,
-                    chat_id=chat_id,
-                    text=user_feedback_message
-                )
+                # Attempt to send a final error message (maybe edit original if possible?)
+                edited_final_crash_error = False
+                if status_message_id:
+                     try:
+                         await retry_bot_operation( bot.edit_message_text, chat_id=chat_id, message_id=status_message_id, text=user_feedback_message, reply_markup=None, link_preview_options={'is_disabled': True} )
+                         edited_final_crash_error = True
+                     except Exception: pass # Ignore error editing here, just try sending new
+                if not edited_final_crash_error:
+                     await retry_bot_operation( bot.send_message, chat_id=chat_id, text=user_feedback_message )
             except Exception as final_err:
                 logger.error(f"[Task {task_id}] Failed to send the final unexpected error feedback: {final_err}")
 
     finally:
         # --- Cleanup ---
-        # Delete the temporary "Processing..." message if it exists and wasn't edited/handled
-        if message_to_delete_later_id and bot:
-            try:
-                await retry_bot_operation(bot.delete_message, chat_id=chat_id, message_id=message_to_delete_later_id)
-                logger.debug(f"[Task {task_id}] Deleted temporary status message {message_to_delete_later_id}")
-            except Exception as del_e:
-                logger.warning(f"[Task {task_id}] Failed to delete temporary status message {message_to_delete_later_id}: {del_e}")
-
-        # Explicitly DO NOT delete the original message with buttons (status_message_id)
-        # if it was successfully edited with the final result or error message.
-        # The logic above sets status_message_id = None if it was edited.
-        # If status_message_id still holds the ID here, it means editing failed and we sent a *new* message.
-        # In that failure case, maybe we *should* delete the original button message? Or leave it?
-        # Let's leave it for now to avoid deleting user context if things went very wrong.
-        # Deleting message_to_delete_later_id covers the main cleanup case.
+        # No automatic deletion needed now. The original message (status_message_id) is either
+        # edited with the result/error, or left as is if editing failed. Temporary messages
+        # were not introduced in this version of the logic.
 
         # Close the background bot's HTTP client
         if background_request and hasattr(background_request, '_client') and background_request._client:
@@ -1090,26 +1088,23 @@ async def process_summary_task(
 
 # --- Telegram Handlers ---
 # (start, help_command, handle_potential_url, handle_summary_type_callback, error_handler)
-# These remain largely the same.
+# No changes needed in these handlers based on logs.
 
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    # ... (Keep existing implementation) ...
     user = update.effective_user; mention = user.mention_html()
     if not user or not update.message: return
     logger.info(f"User {user.id} ({user.username or 'N/A'}) used /start.")
     await update.message.reply_html( f"👋 Hello {mention}! I can summarise YouTube links or website URLs.\n\nJust send me a link anytime!" )
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    # ... (Keep existing implementation) ...
     user = update.effective_user
     if not user or not update.message: return
     logger.info(f"User {user.id} ({user.username or 'N/A'}) used /help.")
-    # Updated help text slightly
     help_text = ( "🔍 **How to use:**\n\n"
                  "1. Send me any YouTube video link or website URL.\n"
                  "2. I'll ask how you want it summarised (paragraph or points).\n"
                  "3. Click the button for your choice.\n"
-                 "4. Wait for the summary!\n\n"
+                 "4. Wait while I process it!\n\n" # Slightly rephrased
                  "⚙️ **Behind the scenes:**\n"
                  f"• **Websites:** I try `Crawl4AI` (smart crawl), then `BeautifulSoup` (basic scrape), and `urltotext.com` API (if configured & credits available).\n"
                  "• **YouTube:** I use `youtube-transcript-api` first, then fall back to `Supadata` and `Apify` APIs if needed.\n"
@@ -1120,15 +1115,14 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
     await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
 
 async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    # ... (Keep existing implementation) ...
     if not update.message or not update.message.text: return
     url = update.message.text.strip(); user = update.effective_user
     if not user: return
     # Basic URL validation
-    if not (url.startswith('http://') or url.startswith('https://')) or '.' not in url[8:]:
+    url_pattern = re.compile(r'https?://[^\s/$.?#].[^\s]*', re.IGNORECASE) # Slightly improved regex
+    if not url_pattern.match(url):
         logger.debug(f"Ignoring non-URL from {user.id}: {url}")
-        # Optionally reply to the user that it doesn't look like a valid URL
-        await update.message.reply_text("Hmm, that doesn't look like a valid web URL. Please make sure it starts with `http://` or `https://`.", parse_mode=ParseMode.MARKDOWN)
+        await update.message.reply_text("Hmm, that doesn't look like a valid web URL. Please make sure it starts with `http://` or `https://` and includes a domain.", parse_mode=ParseMode.MARKDOWN)
         return
     logger.info(f"User {user.id} ({user.username or 'N/A'}) sent potential URL: {url}")
     # Store URL and original message ID in user_data
@@ -1140,12 +1134,11 @@ async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYP
     await update.message.reply_html( f"Okay, I see this link:\n<code>{escaped_url}</code>\n\nHow would you like it summarised?", reply_markup=reply_markup, disable_web_page_preview=True )
 
 async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    # ... (Keep existing implementation, check AI config) ...
     query = update.callback_query
     if not query or not query.message or not query.from_user: logger.warning("Callback query missing data."); return
     user = query.from_user; summary_type = query.data; query_id = query.id
     try: await query.answer(); logger.debug(f"Ack callback {query_id} from {user.id} ({user.username or 'N/A'})")
-    except Exception as e: logger.error(f"Error answering callback {query_id}: {e}", exc_info=True) # Log but continue
+    except Exception as e: logger.warning(f"Error answering callback {query_id}: {e}") # Log warning, don't stop
 
     url = context.user_data.get('url_to_summarize')
     message_id_to_edit = query.message.message_id # The message with the buttons
@@ -1161,10 +1154,6 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
         except Exception as e: logger.error(f"Failed edit 'URL not found' msg: {e}")
         return # Do not proceed further
 
-    # Clear context *only after* successfully scheduling the task below
-    # context.user_data.pop('url_to_summarize', None) # Moved clearing
-    # context.user_data.pop('original_message_id', None) # Moved clearing
-
     # Check necessary configurations before scheduling
     global TELEGRAM_TOKEN, _gemini_primary_enabled, _openrouter_fallback_enabled
     if not TELEGRAM_TOKEN:
@@ -1177,13 +1166,13 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
         try: await query.edit_message_text(text="❌ AI configuration error: No summarization models are available. Cannot proceed.", reply_markup=None)
         except Exception: pass
         return
-    # Log warnings if one model is missing, but proceed if at least one is available
     elif not _gemini_primary_enabled: logger.warning("Primary AI (Gemini) is unavailable, will rely on fallback (OpenRouter).")
     elif not _openrouter_fallback_enabled: logger.warning("Fallback AI (OpenRouter) is unavailable, relying on primary (Gemini).")
 
     # Schedule the background task
     logger.info(f"Scheduling task for user {user.id}, chat {query.message.chat_id}, msg {message_id_to_edit} (URL: {url})")
-    asyncio.create_task(
+    # Use asyncio.ensure_future for slightly better practice than create_task directly here
+    asyncio.ensure_future(
         process_summary_task(
             user_id=user.id,
             chat_id=query.message.chat_id,
@@ -1191,28 +1180,21 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
             url=url,
             summary_type=summary_type,
             bot_token=TELEGRAM_TOKEN # Pass token explicitly
-        ),
-        name=f"SummaryTask-{user.id}-{message_id_to_edit}"
+        )
+        # Consider adding .set_name(...) if using Python 3.8+ for better debugging
+        # .set_name(f"SummaryTask-{user.id}-{message_id_to_edit}")
     )
 
-    # Clear context AFTER scheduling the task to prevent race conditions if user clicks fast
+    # Clear context AFTER scheduling the task
     context.user_data.pop('url_to_summarize', None)
     context.user_data.pop('original_message_id', None)
     logger.debug(f"Cleared URL context for user {user.id} after scheduling task.")
 
-    # Optionally edit the button message *immediately* to give feedback before the task edits it again
-    # This prevents the user clicking again while the task starts up.
-    # try:
-    #     await query.edit_message_text(text=f"Okay, starting '{summary_type}' summary...", reply_markup=None)
-    # except Exception as e:
-    #     logger.warning(f"Could not edit button message immediately after scheduling: {e}")
-    # This initial edit will be quickly overwritten by the task's "Processing..." message.
-
+    # Do not edit the message here - let the task handle its own status updates by editing this message
 
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
     # ... (Keep existing implementation) ...
-    # Consider adding specific TelegramError types if needed
-    ignore_errors = (AttributeError, BadRequest, TimedOut, NetworkError, RetryAfter) # Add common transient errors
+    ignore_errors = (AttributeError, BadRequest, TimedOut, NetworkError, RetryAfter)
     if isinstance(context.error, ignore_errors):
         ignore_messages = ["message is not modified", "query is too old", "message to edit not found", "chat not found", "bot was blocked by the user"]
         err_str = str(context.error).lower()
@@ -1220,10 +1202,6 @@ async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> N
             logger.warning(f"Ignoring known/handled/transient error in error_handler: {context.error}")
             return
     logger.error("Exception while handling an update:", exc_info=context.error)
-    # Consider notifying the user about unexpected errors if appropriate and possible
-    # if isinstance(update, Update) and update.effective_chat:
-    #     try: await context.bot.send_message(chat_id=update.effective_chat.id, text="An unexpected error occurred.")
-    #     except Exception: pass
 
 
 # --- Application Setup ---
@@ -1231,22 +1209,19 @@ async def setup_bot_config() -> Application:
     # ... (Keep existing implementation) ...
     logger.info("Configuring Telegram Application..."); global TELEGRAM_TOKEN
     if not TELEGRAM_TOKEN: raise ValueError("TELEGRAM_TOKEN missing.")
-    # Configure HTTPX client with slightly longer timeouts for PTB internal requests if needed
     custom_request = HTTPXRequest( connect_timeout=10.0, read_timeout=30.0, write_timeout=30.0, pool_timeout=60.0 )
     application = ( Application.builder() .token(TELEGRAM_TOKEN) .request(custom_request) .build() )
     # Add Handlers
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
-    # Use a slightly broader filter to catch URLs even without explicit entity type from Telegram
     url_filter = filters.TEXT & ~filters.COMMAND & (filters.Entity("url") | filters.Entity("text_link") | filters.Regex(r'https?://[^\s]+'))
     application.add_handler(MessageHandler(url_filter, handle_potential_url))
     application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
-    # Error Handler
     application.add_error_handler(error_handler)
     logger.info("Telegram application handlers configured."); return application
 
 # --- ASGI Lifespan & Routes ---
-# (lifespan, health_check, telegram_webhook remain the same)
+# (lifespan, telegram_webhook remain the same)
 @contextlib.asynccontextmanager
 async def lifespan(app: Starlette):
     global ptb_app, WEBHOOK_SECRET, TELEGRAM_TOKEN
@@ -1254,33 +1229,39 @@ async def lifespan(app: Starlette):
     if not TELEGRAM_TOKEN: logger.critical("TG TOKEN missing."); raise RuntimeError("Telegram token missing.")
     try:
         ptb_app = await setup_bot_config()
-        await ptb_app.initialize()
+        await ptb_app.initialize() # This sets the _initialized flag
         bot_info = await ptb_app.bot.get_me()
         logger.info(f"Bot initialized: @{bot_info.username} (ID: {bot_info.id})")
 
         # Webhook setup logic (remains the same)
         current_webhook_info = await ptb_app.bot.get_webhook_info()
+        webhook_delete_success = True # Assume success unless proven otherwise
         if current_webhook_info and current_webhook_info.url:
             logger.info(f"Found existing webhook: {current_webhook_info.url}. Deleting...")
             try:
                 if await ptb_app.bot.delete_webhook(drop_pending_updates=True): logger.info("Webhook deleted.")
-                else: logger.warning("Failed delete webhook (API returned False).")
-            except Exception as e: logger.warning(f"Could not delete webhook: {e}"); await asyncio.sleep(1)
+                else: logger.warning("Failed delete webhook (API returned False)."); webhook_delete_success = False
+            except Exception as e: logger.warning(f"Could not delete webhook: {e}"); await asyncio.sleep(1); webhook_delete_success = False
 
+        # Determine Webhook URL
         space_host = os.environ.get("SPACE_HOST")
         webhook_path = "/webhook" # Standard path
         full_webhook_url = None
         if space_host:
-             # Ensure correct protocol and clean up host string
-            protocol = "https"
-            host = space_host.split('://')[-1] # Get host part if protocol included
-            full_webhook_url = f"{protocol}://{host.rstrip('/')}{webhook_path}"
+             protocol = "https"
+             host = space_host.split('://')[-1]
+             full_webhook_url = f"{protocol}://{host.rstrip('/')}{webhook_path}"
+             logger.info(f"Using SPACE_HOST to determine webhook URL: {full_webhook_url}")
+        else:
+            logger.critical("Could not construct webhook URL (SPACE_HOST env var missing or invalid).")
+            raise RuntimeError("Webhook URL undetermined.")
 
-        if full_webhook_url:
+        # Set Webhook
+        if full_webhook_url and webhook_delete_success:
             logger.info(f"Attempting to set webhook: {full_webhook_url}")
             set_webhook_args = {
                 "url": full_webhook_url,
-                "allowed_updates": Update.ALL_TYPES, # Or specify needed types
+                "allowed_updates": Update.ALL_TYPES,
                 "drop_pending_updates": True
             }
             if WEBHOOK_SECRET:
@@ -1290,30 +1271,28 @@ async def lifespan(app: Starlette):
             await asyncio.sleep(1.0) # Short delay before setting
 
             try:
-                await ptb_app.bot.set_webhook(**set_webhook_args)
-                await asyncio.sleep(1.0) # Short delay after setting
+                webhook_set = await ptb_app.bot.set_webhook(**set_webhook_args)
+                if not webhook_set:
+                    raise RuntimeError("set_webhook API call returned False.")
+                await asyncio.sleep(1.5) # Longer delay after setting before verification
                 webhook_info = await ptb_app.bot.get_webhook_info()
                 if webhook_info and webhook_info.url == full_webhook_url:
-                    logger.info(f"Webhook set successfully: URL='{webhook_info.url}', Secret={'YES' if WEBHOOK_SECRET else 'NO'}")
-                    # Log other info if useful: e.g., webhook_info.last_error_message
+                    logger.info(f"Webhook set and verified successfully: URL='{webhook_info.url}', Secret={'YES' if WEBHOOK_SECRET else 'NO'}")
                     if webhook_info.last_error_message:
                         logger.warning(f"Webhook status has last error: {webhook_info.last_error_message}")
                 else:
-                    logger.error(f"Webhook URL mismatch or failed to set! Expected '{full_webhook_url}', Got '{webhook_info.url if webhook_info else 'N/A'}'")
-                    raise RuntimeError("Webhook URL mismatch or failed confirmation.")
+                    logger.error(f"Webhook verification failed! Expected '{full_webhook_url}', Got info: {webhook_info}")
+                    raise RuntimeError("Webhook verification failed after setting.")
 
-                await ptb_app.start() # Start PTB processing updates
+                await ptb_app.start() # Start PTB processing updates AFTER successful webhook setup
                 logger.info("PTB Application started (webhook mode).")
             except Exception as e:
-                logger.error(f"FATAL: Failed to set webhook: {e}", exc_info=True)
-                raise RuntimeError(f"Failed to set webhook: {e}") from e
-        else:
-            # Attempt to get URL from request headers if available (might work in some environments)
-            # This is less reliable than SPACE_HOST
-            logger.warning("SPACE_HOST environment variable not found. Webhook URL cannot be determined reliably for setup.")
-            # You might decide to raise an error or try to run in polling mode if webhook fails
-            raise RuntimeError("Webhook URL undetermined (SPACE_HOST missing).")
-
+                logger.error(f"FATAL: Failed to set or verify webhook: {e}", exc_info=True)
+                raise RuntimeError(f"Failed to set/verify webhook: {e}") from e
+        elif not webhook_delete_success:
+             logger.error("FATAL: Failed to delete previous webhook. Cannot set new one.")
+             raise RuntimeError("Failed to delete previous webhook.")
+        # else: # Already handled by raising error if full_webhook_url is None
 
         logger.info("ASGI Lifespan: Startup complete.");
         yield # Application runs here
@@ -1324,7 +1303,8 @@ async def lifespan(app: Starlette):
         if ptb_app:
             try:
                 if ptb_app.running: await ptb_app.stop()
-                await ptb_app.shutdown()
+                # Check if initialized before shutting down
+                if ptb_app._initialized: await ptb_app.shutdown()
             except Exception as shutdown_err:
                 logger.error(f"Error during shutdown after startup failure: {shutdown_err}")
         raise # Reraise the original startup error
@@ -1337,36 +1317,42 @@ async def lifespan(app: Starlette):
                 if ptb_app.running:
                     logger.info("Stopping PTB application...")
                     await ptb_app.stop()
-                logger.info("Shutting down PTB application...")
-                await ptb_app.shutdown()
-                logger.info("PTB Application shut down successfully.")
+                # Check if initialized before shutting down
+                if ptb_app._initialized:
+                    logger.info("Shutting down PTB application...")
+                    await ptb_app.shutdown()
+                    logger.info("PTB Application shut down successfully.")
+                else:
+                    logger.info("PTB Application was not fully initialized, skipping shutdown.")
             except Exception as e:
                 logger.error(f"Error during PTB shutdown: {e}", exc_info=True)
         else:
-            logger.info("PTB application was not initialized or startup failed.")
+            logger.info("PTB application object not created.")
         logger.info("ASGI Lifespan: Shutdown complete.")
 
 
 async def health_check(request: Request) -> PlainTextResponse:
-    # ... (Keep existing implementation, updated with model names) ...
     global OPENROUTER_MODEL, GEMINI_MODEL, APIFY_ACTOR_ID, _apify_token_exists, _gemini_primary_enabled, _openrouter_fallback_enabled, _crawl4ai_primary_web_enabled, _urltotext_fallback_enabled, SUPADATA_API_KEY
     bot_status = "Not Initialized"
     bot_username = "N/A"
-    if ptb_app and ptb_app.bot and ptb_app.initialized: # Check if initialized
+    # *** FIXED Attribute Name ***
+    if ptb_app and ptb_app.bot and ptb_app._initialized: # Check if initialized using _initialized
         try:
              # Quick check if webhook seems ok, more reliable than get_me() sometimes
             wh_info = await ptb_app.bot.get_webhook_info()
+            # Check running status as well
             if ptb_app.running and wh_info and wh_info.url:
                  bot_info = await ptb_app.bot.get_me()
                  bot_username = f"@{bot_info.username}"
                  bot_status = f"Running (Webhook OK, {bot_username})"
             elif ptb_app.running:
-                 bot_status = "Running (Webhook check failed or not set)"
+                 bot_status = f"Running (Webhook Status: {wh_info.url if wh_info else 'N/A'}, Last Error: {wh_info.last_error_message if wh_info else 'N/A'})"
             else: bot_status = "Initialized/Not running"
-        except Exception as e: bot_status = f"Error checking status: {e}"
+        except Exception as e:
+            logger.error(f"Error checking bot status in health check: {e}", exc_info=True)
+            bot_status = f"Error checking status: {e}"
     elif ptb_app:
-        bot_status = "Initializing..."
-
+        bot_status = "Initializing..." # Or Initialized but not running yet
 
     health_info = [
         f"=== Telegram Summary Bot Status ===",
@@ -1390,6 +1376,9 @@ async def telegram_webhook(request: Request) -> Response:
     if not ptb_app:
         logger.error("Webhook received but PTB application not initialized.")
         return PlainTextResponse('Bot not initialized', status_code=503) # Service Unavailable
+    if not ptb_app._initialized: # Check _initialized flag
+        logger.error("Webhook received but PTB application not running (not initialized).")
+        return PlainTextResponse('Bot not initialized', status_code=503)
     if not ptb_app.running:
         logger.warning("Webhook received but PTB application not running.")
         return PlainTextResponse('Bot not running', status_code=503) # Service Unavailable
@@ -1443,9 +1432,13 @@ if __name__ == '__main__':
 
     # Make sure necessary env vars are loaded for local dev if not set system-wide
     # Example using python-dotenv if you add it to requirements-dev.txt
-    # from dotenv import load_dotenv
-    # load_dotenv()
-    # logger.info("Loaded environment variables from .env file for local development.")
+    try:
+         from dotenv import load_dotenv
+         load_dotenv()
+         logger.info("Loaded environment variables from .env file for local development.")
+    except ImportError:
+         logger.info(".env file not found or python-dotenv not installed, using system environment variables.")
+
 
     # Re-check required tokens after potential .env load
     if not get_secret('TELEGRAM_TOKEN'): logger.critical("Local Dev: TELEGRAM_TOKEN not found.")