Update main.py

main.py

@@ -844,20 +844,15 @@ 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)."""
-    # 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.
+    # 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.")
-         # 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)}")
 
@@ -870,93 +865,118 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
         text = text[:MAX_INPUT_LENGTH_GEMINI] + "... (Content truncated)"
     full_prompt = f"{prompt}\n\n{text}"
 
-    # Define safety_settings - Now guarded by the explicit check above
+    # Define safety_settings
+    safety_settings = {} # Initialize empty dict
     try:
-        # These constants should now be valid if the check above passed
+        # --- 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.
         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 and docs
+            # HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY is REMOVED as it's not defined in the SDK version
         }
-        logger.debug(f"[Gemini {model_name}] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }")
-    # Keep the original NameError/AttributeError check as a final fallback,
-    # though the explicit None check should ideally prevent reaching here with this specific error.
+        # 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:
-        # 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)
+        # 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."
 
-    # --- Rest of the function (API call, response handling) remains the same as the previous version ---
+    # 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."
+
+    # --- API call logic remains the same ---
     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} # Keep timeout reasonable
+        request_options = {"timeout": 120}
         response = await model.generate_content_async(
-             full_prompt, generation_config=genai.types.GenerationConfig(), # Use default config
+             full_prompt, generation_config=genai.types.GenerationConfig(),
              safety_settings=safety_settings, request_options=request_options )
         logger.info(f"[Gemini {model_name}] Received response from Gemini.")
 
-        # Check for prompt blocking first
+        # Response handling logic (prompt feedback, candidates, summary extraction) remains unchanged...
         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}");
             return None, f"Sorry, the AI model ({model_name}) blocked the request (Reason: {block_reason_str})."
 
         summary = None; finish_reason_str = 'UNKNOWN'
-        # Check candidates for content and safety blocking
         if response.candidates:
             candidate = response.candidates[0]
             finish_reason_name = getattr(candidate.finish_reason, 'name', None)
-            finish_reason_str = finish_reason_name or 'N/A' # Default if None
+            finish_reason_str = finish_reason_name or 'N/A'
 
-            # Check if the *candidate* was blocked by safety
             if finish_reason_name == 'SAFETY':
-                safety_ratings_str = ", ".join([f"{rating.category.name}: {rating.probability.name}" for rating in candidate.safety_ratings])
+                # 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])
                 logger.warning(f"[Gemini {model_name}] Candidate blocked due to SAFETY. Finish Reason: {finish_reason_str}. Ratings: [{safety_ratings_str}]")
-                # Provide a more specific error message about response blocking
                 return None, f"Sorry, the AI model ({model_name}) generated a response that was blocked due to safety filters ({finish_reason_str})."
-            elif finish_reason_name not in ['STOP', 'MAX_TOKENS', None]: # Log other unusual finish reasons
+            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}")
 
-            # Extract content if available
+            # 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: try accessing response.text directly (might raise ValueError if blocked)
+        # Fallback to response.text if no summary extracted from candidate
         if summary is None:
-            try: summary = response.text
-            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
-
-        # Final check if we got a summary
+            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 summary:
             logger.info(f"[Gemini {model_name}] Success generating summary. Finish Reason: {finish_reason_str}. Output len: {len(summary)}");
             return summary.strip(), None
         else:
-            # If no summary after checking candidate and response.text, report failure
             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."
             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:
-         # 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
+    # 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 # Fall through to general Exception
+        pass
     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
+         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."
-         # 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."
+         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
          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)
@@ -967,18 +987,17 @@ async def _call_gemini(text: str, summary_type: str, model_name: str) -> Tuple[O
         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
         logger.error(f"[Gemini {model_name}] Google API error during Gemini call: {gae}", exc_info=False)
-        status_code = getattr(gae, 'code', 'Unknown') # Use code if available
+        status_code = getattr(gae, 'code', 'Unknown')
         user_message = f"Sorry, the AI service ({model_name}) encountered an API error (Code: {status_code})."
-        # 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
+        elif status_code == 400: user_message = f"Sorry, there was a bad request sending data to the AI service ({model_name})."
         return None, user_message
     except Exception as e:
-        # 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})."
+        if isinstance(e, NameError) and 'genai' in str(e):
+            error_msg = "Sorry, the AI service SDK is not properly initialized (internal error)."
         return None, error_msg