Update main.py

main.py

@@ -844,38 +844,51 @@ 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 # Ensure HarmCategory/Threshold are available if SDK is loaded
+    # Initial check (already present)
+    global _gemini_api_enabled, HarmCategory, HarmBlockThreshold
     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."
+
+    # --- ADDED EXPLICIT CHECK ---
+    # Double-check if the necessary types were imported correctly, even if _gemini_api_enabled is True.
+    # This guards against cases where the SDK might be partially available or the import didn't fully register.
+    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.")
+         # Provide a user-facing error that points to configuration/internal issue
+         return None, f"Sorry, an internal configuration error occurred with the AI service ({model_name}). Safety types missing."
+    # --- END ADDED CHECK ---
+
     logger.info(f"[Gemini {model_name}] Generating {summary_type} summary using {model_name}. Input length: {len(text)}")
 
     prompt = PROMPT_PARAGRAPH if summary_type == "paragraph" else PROMPT_POINTS
-    # Determine max input length based on model - Flash Preview is likely 1M like Flash 2.0, Pro Exp is 2M
-    # Use a conservative estimate for safety, but larger than Llama/Deepseek
     MAX_INPUT_LENGTH_GEMINI = 900000
-    if 'pro-exp' in model_name.lower(): MAX_INPUT_LENGTH_GEMINI = 1800000 # Higher for Pro
+    if 'pro-exp' in model_name.lower(): MAX_INPUT_LENGTH_GEMINI = 1800000
 
     if len(text) > MAX_INPUT_LENGTH_GEMINI:
         logger.warning(f"[Gemini {model_name}] Input length ({len(text)}) exceeds estimated limit ({MAX_INPUT_LENGTH_GEMINI}). Truncating.");
         text = text[:MAX_INPUT_LENGTH_GEMINI] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
 
-    # Define safety_settings explicitly with the 5 known categories set to BLOCK_NONE.
-    # This satisfies the requirement "make sure that all safety censors are set to none".
+    # Define safety_settings - Now guarded by the explicit check above
     try:
+        # These constants should now be valid if the check above passed
         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: HarmBlockThreshold.BLOCK_NONE, # Present in previous code
+            HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY: HarmBlockThreshold.BLOCK_NONE, # Present in previous code and docs
         }
         logger.debug(f"[Gemini {model_name}] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }")
-    except (NameError, AttributeError): # Catch if HarmCategory/Threshold are not loaded (SDK issue)
-        logger.error(f"[Gemini {model_name}] Failed to define safety settings. HarmCategory/HarmBlockThreshold missing or SDK not fully available?")
-        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). Safety settings unavailable."
-
+    # Keep the original NameError/AttributeError check as a final fallback,
+    # though the explicit None check should ideally prevent reaching here with this specific error.
+    except (NameError, AttributeError) as e:
+        # Log with more context if this somehow still happens
+        logger.error(f"[Gemini {model_name}] Unexpected error defining safety settings ({type(e).__name__}): {e}. HarmCategory/HarmBlockThreshold might be invalid despite passing initial checks.", exc_info=True)
+        return None, f"Sorry, an internal error occurred configuring the AI service ({model_name}). Safety settings definition failed unexpectedly."
+
+    # --- Rest of the function (API call, response handling) remains the same as the previous version ---
     try:
         logger.debug(f"[Gemini {model_name}] Initializing model {model_name}")
         model = genai.GenerativeModel(model_name)
@@ -931,24 +944,39 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
          # This can happen if the response structure changes or expected fields are missing
          logger.error(f"[Gemini {model_name}] AttributeError during Gemini response processing: {ae}. SDK might be incompatible or response structure unexpected.", exc_info=True);
          return None, f"Sorry, there was an issue processing the response from the AI service ({model_name}). Attribute error."
+    # Use google.api_core.exceptions if available, otherwise use general Exception
+    except ImportError: # Handle if google.api_core isn't available for some reason
+        logger.warning("[Gemini] google.api_core.exceptions not available for specific error handling.")
+        pass # Fall through to general Exception
     except google.api_core.exceptions.InvalidArgument as iae:
          # Catch specific InvalidArgument, often related to safety settings or model params
          logger.error(f"[Gemini {model_name}] Invalid Argument error from Gemini API: {iae}", exc_info=False) # Don't need full stack trace often
          error_detail = str(iae)
          user_message = f"Sorry, the AI service ({model_name}) reported an invalid argument."
+         # Add more specific messages based on common InvalidArgument errors
          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."
          return None, user_message
+    except google.api_core.exceptions.PermissionDenied as pde:
+        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:
+        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:
-        # Catch other potential Google API errors (like permission denied, quota exceeded, etc.)
+        # Catch other potential 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')
+        status_code = getattr(gae, 'code', 'Unknown') # Use code if available
         user_message = f"Sorry, the AI service ({model_name}) encountered an API error (Code: {status_code})."
-        if status_code == 429: user_message = f"Sorry, the AI model ({model_name}) is busy (Rate Limit/Quota Exceeded). Try again later."
-        elif status_code == 500: user_message = f"Sorry, the AI service ({model_name}) had an internal server error."
+        # Add specific known codes if needed, ResourceExhausted (429) handled above
+        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})." # Often model name typo or bad input structure
         return None, user_message
     except Exception as e:
-        # General catch-all for unexpected issues
+        # General catch-all for unexpected issues (e.g., network errors not caught by httpx inside SDK)
         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})."
         return None, error_msg