Update main.py

main.py

@@ -45,11 +45,13 @@ except ImportError:
 try:
     import google.generativeai as genai
     from google.generativeai.types import HarmCategory, HarmBlockThreshold
+    import google.api_core.exceptions # <-- ADD THIS LINE
     _gemini_sdk_available = True
 except ImportError:
     genai = None
     HarmCategory = None
     HarmBlockThreshold = None
+    google = None # Set google to None if core part fails too
     _gemini_sdk_available = False
 
 # --- Groq SDK ---
@@ -101,13 +103,16 @@ WEBHOOK_SECRET = get_secret('WEBHOOK_SECRET')
 
 # --- Model Configurations (Specific April 2025 - Updated Order) ---
 # New Model Priority:
-# 1. Gemini 2.5 Flash Preview (NEW)
+# 1. Gemini 2.5 Flash Preview (NEW - Using specific date variant)
 # 2. Gemini 2.5 Pro Exp
 # 3. Gemini 2.0 Flash
 # 4. OpenRouter DeepSeek V3 Free
 # 5. Groq Llama 4 Scout (Moved to Last)
 
-GEMINI_FLASH_PREVIEW_MODEL = os.environ.get("GEMINI_FLASH_PREVIEW_MODEL", "gemini-2.5-flash-preview") # NEW Model
+# --- MODIFIED LINE: Changed default model name ---
+GEMINI_FLASH_PREVIEW_MODEL = os.environ.get("GEMINI_FLASH_PREVIEW_MODEL", "gemini-2.5-flash-preview-04-17") # NEW Model with date
+# --- END MODIFIED LINE ---
+
 GEMINI_PRO_EXP_MODEL = os.environ.get("GEMINI_PRO_EXP_MODEL", "gemini-2.5-pro-exp-03-25")
 GEMINI_FLASH_MODEL = os.environ.get("GEMINI_FLASH_MODEL", "gemini-2.0-flash-001") # Original Flash model
 OPENROUTER_DEEPSEEK_MODEL = os.environ.get("OPENROUTER_DEEPSEEK_MODEL", "deepseek/deepseek-chat-v3-0324:free") # Specific DeepSeek model
@@ -151,7 +156,7 @@ if not WEBHOOK_SECRET: logger.info("Optional secret 'WEBHOOK_SECRET' not found.
 
 logger.info("Secret loading and configuration check finished.")
 # --- Log summarizers in the NEW order ---
-logger.info(f"Summarizer 1 (Gemini Flash Preview): {GEMINI_FLASH_PREVIEW_MODEL if _gemini_api_enabled else 'DISABLED'}")
+logger.info(f"Summarizer 1 (Gemini Flash Preview): {GEMINI_FLASH_PREVIEW_MODEL if _gemini_api_enabled else 'DISABLED'} (Using specific date variant)") # Added note
 logger.info(f"Summarizer 2 (Gemini Pro Exp): {GEMINI_PRO_EXP_MODEL if _gemini_api_enabled else 'DISABLED'}")
 logger.info(f"Summarizer 3 (Gemini Flash): {GEMINI_FLASH_MODEL if _gemini_api_enabled else 'DISABLED'}")
 logger.info(f"Summarizer 4 (OpenRouter): {OPENROUTER_DEEPSEEK_MODEL if _openrouter_fallback_enabled else 'DISABLED'}")
@@ -844,15 +849,20 @@ async def _call_groq(text: str, summary_type: str) -> Tuple[Optional[str], Optio
 
 async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[Optional[str], Optional[str]]:
     """Internal function to call Gemini API. Returns (summary, error_message)."""
-    global _gemini_api_enabled, HarmCategory, HarmBlockThreshold
+    global _gemini_api_enabled, HarmCategory, HarmBlockThreshold, genai, google # Add google to global if needed, though import should make it available
     if not _gemini_api_enabled:
         logger.error(f"[Gemini {model_name}] Called but API is disabled.");
         return None, f"Error: AI service (Gemini API) not configured/available."
 
-    # Explicit check for the types themselves
-    if HarmCategory is None or HarmBlockThreshold is None:
-         logger.error(f"[Gemini {model_name}] Safety setting types (HarmCategory/HarmBlockThreshold) are None. SDK might be partially loaded or initial import failed.")
-         return None, f"Sorry, an internal configuration error occurred with the AI service ({model_name}). Safety types missing."
+    # Check if SDK and necessary types are loaded
+    if genai is None or HarmCategory is None or HarmBlockThreshold is None:
+         logger.error(f"[Gemini {model_name}] SDK or safety types (HarmCategory/HarmBlockThreshold) are None/unavailable.")
+         return None, f"Sorry, an internal configuration error occurred with the AI service ({model_name}). SDK components missing."
+
+    # Also check if the google exceptions module loaded - needed for specific error handling
+    if google is None or not hasattr(google, 'api_core') or not hasattr(google.api_core, 'exceptions'):
+         logger.warning(f"[Gemini {model_name}] google.api_core.exceptions not available for specific error handling. Will use general exceptions.")
+         # We can proceed but error handling might be less specific
 
     logger.info(f"[Gemini {model_name}] Generating {summary_type} summary using {model_name}. Input length: {len(text)}")
 
@@ -866,41 +876,28 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
     full_prompt = f"{prompt}\n\n{text}"
 
     # Define safety_settings
-    safety_settings = {} # Initialize empty dict
+    safety_settings = {}
     try:
-        # --- CORRECTED SAFETY SETTINGS ---
-        # Define settings only for categories confirmed to exist in the SDK version being used.
-        # HARM_CATEGORY_CIVIC_INTEGRITY caused an AttributeError, so it's removed.
-        # The goal is to set all *available* categories to BLOCK_NONE.
+        # Use only categories known to exist in the SDK
         safety_settings = {
             HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
             HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
             HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
             HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-            # HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY is REMOVED as it's not defined in the SDK version
         }
-        # Log the actual settings being used
         settings_applied_str = ", ".join([k.name for k in safety_settings.keys()])
         logger.debug(f"[Gemini {model_name}] Applying BLOCK_NONE to available safety categories: [{settings_applied_str}]")
 
     except (NameError, AttributeError) as e:
-        # This catch block remains as a safeguard.
-        logger.error(f"[Gemini {model_name}] Unexpected error defining safety settings ({type(e).__name__}): {e}. HarmCategory/HarmBlockThreshold might be invalid.", exc_info=True)
-        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). Safety settings definition failed unexpectedly."
+        logger.error(f"[Gemini {model_name}] Unexpected error defining safety settings ({type(e).__name__}): {e}.", exc_info=True)
+        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). Safety settings definition failed."
 
-    # Check if safety_settings dictionary is empty (shouldn't happen if the 4 base categories exist)
-    if not safety_settings:
-        logger.error(f"[Gemini {model_name}] Failed to define any safety settings. Cannot proceed with Gemini call.")
-        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). No safety settings could be defined."
+    if not safety_settings: # Should not happen if base categories exist
+        logger.error(f"[Gemini {model_name}] Failed to define any safety settings.")
+        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). No safety settings defined."
 
-    # --- API call logic remains the same ---
+    # --- API Call ---
     try:
-        logger.debug(f"[Gemini {model_name}] Initializing model {model_name}")
-        # Make sure genai is accessible
-        if genai is None:
-            logger.error(f"[Gemini {model_name}] GenAI SDK object (genai) is None. Cannot initialize model.")
-            return None, f"Sorry, the AI service ({model_name}) SDK is not properly initialized."
-
         model = genai.GenerativeModel(model_name)
         logger.info(f"[Gemini {model_name}] Sending request to Gemini ({model_name})...")
         request_options = {"timeout": 120}
@@ -909,7 +906,7 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
              safety_settings=safety_settings, request_options=request_options )
         logger.info(f"[Gemini {model_name}] Received response from Gemini.")
 
-        # Response handling logic (prompt feedback, candidates, summary extraction) remains unchanged...
+        # --- Response Handling (same as before) ---
         if response.prompt_feedback and response.prompt_feedback.block_reason:
             block_reason_str = getattr(response.prompt_feedback.block_reason, 'name', str(response.prompt_feedback.block_reason))
             logger.warning(f"[Gemini {model_name}] Request blocked by API. Reason: {block_reason_str}");
@@ -922,7 +919,6 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
             finish_reason_str = finish_reason_name or 'N/A'
 
             if finish_reason_name == 'SAFETY':
-                # Log safety ratings if available
                 safety_ratings_str = "N/A"
                 if hasattr(candidate, 'safety_ratings'):
                     safety_ratings_str = ", ".join([f"{rating.category.name}: {rating.probability.name}" for rating in candidate.safety_ratings])
@@ -931,73 +927,65 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
             elif finish_reason_name not in ['STOP', 'MAX_TOKENS', None]:
                  logger.warning(f"[Gemini {model_name}] Candidate finished with non-standard reason: {finish_reason_str}")
 
-            # Check for content within the candidate
             if candidate.content and candidate.content.parts:
                  summary = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
 
-        # Fallback to response.text if no summary extracted from candidate
         if summary is None:
             try:
-                # Check if response.text exists before accessing
-                if hasattr(response, 'text'):
-                    summary = response.text
-                else:
-                    logger.warning(f"[Gemini {model_name}] Response object lacks 'text' attribute.")
-                    summary = None # Ensure summary remains None
-            except ValueError as e: # This often indicates blocked content
-                logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked/no content): {e}"); summary = None
-            except Exception as e:
-                logger.warning(f"[Gemini {model_name}] Unexpected error accessing response.text: {e}"); summary = None
-
-        # Final check and return
+                if hasattr(response, 'text'): summary = response.text
+                else: logger.warning(f"[Gemini {model_name}] Response object lacks 'text' attribute."); summary = None
+            except ValueError as e: logger.warning(f"[Gemini {model_name}] Error accessing response.text (likely blocked/no content): {e}"); summary = None
+            except Exception as e: logger.warning(f"[Gemini {model_name}] Unexpected error accessing response.text: {e}"); summary = None
+
         if summary:
             logger.info(f"[Gemini {model_name}] Success generating summary. Finish Reason: {finish_reason_str}. Output len: {len(summary)}");
             return summary.strip(), None
         else:
             logger.warning(f"[Gemini {model_name}] Gemini returned empty summary or content was blocked. Final Finish Reason: {finish_reason_str}");
-            # Provide a reason if known (e.g., Safety block)
-            if finish_reason_str == 'SAFETY':
-                 return None, f"Sorry, the AI model ({model_name}) response was blocked by safety filters."
+            if finish_reason_str == 'SAFETY': return None, f"Sorry, the AI model ({model_name}) response was blocked by safety filters."
             return None, f"Sorry, the AI model ({model_name}) did not provide a summary (Finish Reason: {finish_reason_str})."
 
-    # --- Error handling logic remains the same ---
-    except AttributeError as ae:
-         logger.error(f"[Gemini {model_name}] AttributeError during Gemini response processing: {ae}. SDK might be incompatible or response structure unexpected.", exc_info=True);
+    # --- Exception Handling (Refined) ---
+    except AttributeError as ae: # Error within response processing
+         logger.error(f"[Gemini {model_name}] AttributeError during Gemini response processing: {ae}. SDK/response structure issue.", exc_info=True);
          return None, f"Sorry, there was an issue processing the response from the AI service ({model_name}). Attribute error."
-    # Import google.api_core.exceptions if needed (should be loaded if SDK works)
-    except ImportError:
-        logger.warning("[Gemini] google.api_core.exceptions not available for specific error handling.")
-        pass
-    except google.api_core.exceptions.InvalidArgument as iae:
+
+    # Check if specific exceptions are available before trying to catch them
+    except google.api_core.exceptions.NotFound as nfe if google and hasattr(google.api_core, 'exceptions') else None:
+        # Specific handling for the 404 error
+        logger.error(f"[Gemini {model_name}] Model Not Found error from Gemini API: {nfe}", exc_info=False)
+        user_message = f"Sorry, the AI model '{model_name}' was not found by the API service. It might be unavailable or spelled incorrectly."
+        return None, user_message
+    except google.api_core.exceptions.InvalidArgument as iae if google and hasattr(google.api_core, 'exceptions') else None:
          logger.error(f"[Gemini {model_name}] Invalid Argument error from Gemini API: {iae}", exc_info=False)
          error_detail = str(iae)
          user_message = f"Sorry, the AI service ({model_name}) reported an invalid argument."
-         if "safety_settings" in error_detail: user_message += " (Safety Settings issue)."
-         elif "temperature" in error_detail: user_message += " (Generation Parameter issue)."
-         elif "API key not valid" in error_detail: user_message = f"Error: The API key for the AI service ({model_name}) is invalid."
-         elif "model" in error_detail and ("not found" in error_detail or "does not exist" in error_detail): user_message = f"Error: The AI model name '{model_name}' was not found by the API."
-         elif "HarmCategory" in error_detail: user_message += " (Unsupported safety category passed)." # More specific error if it happens again
+         if "API key not valid" in error_detail: user_message = f"Error: The API key for the AI service ({model_name}) is invalid."
+         # Add other specific InvalidArgument checks if needed
          return None, user_message
-    except google.api_core.exceptions.PermissionDenied as pde:
+    except google.api_core.exceptions.PermissionDenied as pde if google and hasattr(google.api_core, 'exceptions') else None:
         logger.error(f"[Gemini {model_name}] Permission Denied error from Gemini API: {pde}", exc_info=False)
         user_message = f"Error: Access denied for the AI service ({model_name}). Check API key permissions."
         return None, user_message
-    except google.api_core.exceptions.ResourceExhausted as ree:
+    except google.api_core.exceptions.ResourceExhausted as ree if google and hasattr(google.api_core, 'exceptions') else None:
         logger.error(f"[Gemini {model_name}] Resource Exhausted (Quota/Rate Limit) error from Gemini API: {ree}", exc_info=False)
         user_message = f"Sorry, the AI model ({model_name}) is busy or quota exceeded. Please try again later."
         return None, user_message
-    except google.api_core.exceptions.GoogleAPIError as gae:
+    except google.api_core.exceptions.GoogleAPIError as gae if google and hasattr(google.api_core, 'exceptions') else None:
+        # Catch other Google API errors
         logger.error(f"[Gemini {model_name}] Google API error during Gemini call: {gae}", exc_info=False)
         status_code = getattr(gae, 'code', 'Unknown')
         user_message = f"Sorry, the AI service ({model_name}) encountered an API error (Code: {status_code})."
         if status_code == 500: user_message = f"Sorry, the AI service ({model_name}) had an internal server error."
-        elif status_code == 400: user_message = f"Sorry, there was a bad request sending data to the AI service ({model_name})."
+        # Add other status codes if needed
         return None, user_message
     except Exception as e:
+        # General catch-all
         logger.error(f"[Gemini {model_name}] Unexpected error during Gemini API call: {e}", exc_info=True);
         error_msg = f"Sorry, an unexpected error occurred while using the AI service ({model_name})."
-        if isinstance(e, NameError) and 'genai' in str(e):
-            error_msg = "Sorry, the AI service SDK is not properly initialized (internal error)."
+        # Check if it's the specific NameError we saw before, indicating an issue loading the exceptions module
+        if isinstance(e, NameError) and 'google' in str(e):
+             error_msg = f"Sorry, an internal configuration error occurred with the AI service ({model_name}). Exception handling module missing."
         return None, error_msg