Delete src

src/agent.py

@@ -1,487 +0,0 @@
-"""
-Enhanced Gemini AI Agent implementation with improved accuracy strategies and multi-API key support.
-"""
-
-import logging
-import asyncio
-import re
-from typing import List, Dict, Any, Optional
-import google.generativeai as genai
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
-from src.config import Config
-from src.utils import sanitize_input, format_response
-
-logger = logging.getLogger(__name__)
-
-
-class GeminiClientWithFallback:
-    """
-    Enhanced Gemini client that automatically switches API keys when quota is exceeded.
-    Integrated into the existing agent architecture.
-    """
-
-    def __init__(self, config: Config):
-        """Initialize the client with configuration."""
-        self.config = config
-        self.current_model = None
-        self._initialize_model()
-
-    def _initialize_model(self):
-        """Initialize the Gemini model with current API key."""
-        try:
-            current_key = self.config.get_current_api_key()
-            genai.configure(api_key=current_key)
-
-            # Enhanced safety settings
-            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,
-            }
-
-            self.current_model = genai.GenerativeModel(
-                model_name=self.config.model_name,
-                safety_settings=safety_settings
-            )
-
-            current_key_info = self.config.api_keys[self.config.current_key_index]
-            logger.info(f"Initialized model with API key: {current_key_info.label}")
-
-        except RuntimeError as e:
-            logger.error(f"Failed to initialize model: {e}")
-            self.current_model = None
-
-    def _switch_api_key(self, error_message: str = "") -> bool:
-        """Switch to next available API key."""
-        if self.config.handle_quota_error(error_message):
-            self._initialize_model()
-            return self.current_model is not None
-        return False
-
-    def generate_content(self, prompt: str, generation_config: Optional[Dict] = None, max_retries: Optional[int] = None) -> Optional[str]:
-        """Generate content with automatic API key fallback."""
-        if max_retries is None:
-            max_retries = self.config.retry_attempts
-
-        last_error = None
-
-        for attempt in range(max_retries + 1):
-            if not self.current_model:
-                logger.warning("No model available. Trying to initialize...")
-                self._initialize_model()
-                if not self.current_model:
-                    continue
-
-            try:
-                current_key_info = self.config.api_keys[self.config.current_key_index]
-                logger.debug(f"Attempt {attempt + 1}/{max_retries + 1} with {current_key_info.label}")
-
-                # Make the request with custom generation config if provided
-                if generation_config:
-                    config_obj = genai.types.GenerationConfig(**generation_config)
-                    response = self.current_model.generate_content(prompt, generation_config=config_obj)
-                else:
-                    response = self.current_model.generate_content(prompt)
-
-                # Record successful request
-                self.config.record_successful_request()
-
-                # Return the generated text
-                if response and response.text:
-                    return response.text.strip()
-                else:
-                    logger.warning("Empty response received")
-                    return None
-
-            except Exception as e:
-                error_message = str(e)
-                last_error = error_message
-                logger.warning(f"Request failed: {error_message}")
-
-                # Check if it's a quota error
-                if "429" in error_message or "quota" in error_message.lower():
-                    logger.info("Quota exceeded detected. Attempting to switch API key...")
-
-                    if not self._switch_api_key(error_message):
-                        logger.error("No more API keys available")
-                        break
-
-                    # Continue to next attempt with new key
-                    continue
-
-                # For other errors, wait a bit before retrying
-                elif attempt < max_retries:
-                    import time
-                    wait_time = min(2 ** attempt, 10)  # Exponential backoff, max 10 seconds
-                    logger.info(f"Waiting {wait_time} seconds before retry...")
-                    time.sleep(wait_time)
-                else:
-                    break
-
-        logger.error(f"All attempts failed. Last error: {last_error}")
-        return None
-
-    def get_status(self) -> Dict[str, Any]:
-        """Get current status of the client and API keys."""
-        status = self.config.get_keys_status()
-        status.update({
-            "model_initialized": self.current_model is not None,
-            "current_model": self.config.model_name
-        })
-        return status
-
-
-class GeminiAgent:
-    """
-    Enhanced AI Agent powered by Google's Gemini model with advanced reasoning capabilities and multi-API key support.
-    """
-
-    def __init__(self, config: Config):
-        """Initialize the Enhanced Gemini Agent with multi-key support."""
-        self.config = config
-        self.conversation_history: List[Dict[str, str]] = []
-        self._initialize_client()
-
-    def _initialize_client(self):
-        """Initialize the Gemini API client with multi-key support and optimized settings."""
-        try:
-            # Initialize the enhanced client with fallback support
-            self.client = GeminiClientWithFallback(self.config)
-
-            logger.info(f"Enhanced Gemini client initialized with model: {self.config.model_name}")
-
-            # Log API key status
-            status = self.get_status()
-            logger.info(f"Available API keys: {status['total_keys']}")
-            current_key_info = status['keys'][status['current_key']]
-            logger.info(f"Starting with: {current_key_info['label']}")
-
-        except Exception as e:
-            logger.error(f"Failed to initialize Gemini client: {e}")
-            raise
-
-    def _build_enhanced_system_prompt(self) -> str:
-        """Build an enhanced system prompt for maximum accuracy."""
-        return """You are an elite AI research assistant with exceptional analytical capabilities. Your mission is to provide the most accurate, precise, and well-reasoned answers possible.
-
-CRITICAL SUCCESS STRATEGIES:
-
-1. **DEEP ANALYSIS PROTOCOL**:
-   - Read questions multiple times to fully understand what's being asked
-   - Identify the exact type of information needed (factual, numerical, analytical, etc.)
-   - Break complex questions into sub-components
-   - Consider multiple interpretations and choose the most logical one
-
-2. **RESEARCH EXCELLENCE**:
-   - For factual questions: Provide specific, verifiable information
-   - For numerical questions: Show clear calculations and reasoning
-   - For analytical questions: Provide structured, logical analysis
-   - For historical/biographical questions: Include specific dates, names, and context
-
-3. **ACCURACY MAXIMIZATION**:
-   - If you're not completely certain, state your confidence level
-   - Distinguish between facts you know and reasonable inferences
-   - For mathematical problems, double-check your calculations
-   - For factual claims, consider if they align with well-established knowledge
-
-4. **QUESTION TYPE OPTIMIZATION**:
-   - Factual queries: Provide direct, specific answers with key details
-   - Quantitative queries: Show step-by-step calculations
-   - Comparative queries: Create clear comparisons with specific criteria
-   - Creative queries: Balance creativity with logical structure
-
-5. **RESPONSE STRUCTURE**:
-   - Start with a direct answer to the main question
-   - Provide supporting evidence or reasoning
-   - Include relevant context when helpful
-   - End with a clear, concise summary if the answer is complex
-
-SPECIAL FOCUS AREAS:
-- Pay extra attention to numbers, dates, and specific details
-- For "how many" questions, provide exact counts when possible
-- For "when" questions, provide specific timeframes
-- For "who" questions, provide full names and relevant context
-- For "what" questions, provide comprehensive but focused explanations
-
-Remember: Accuracy is your top priority. A well-reasoned, precise answer is infinitely better than a vague or uncertain response."""
-
-    def _analyze_question_type(self, question: str) -> str:
-        """Analyze the question type to apply appropriate strategies."""
-        question = question.lower()
-
-        if any(word in question for word in ['how many', 'count', 'number of']):
-            return 'quantitative'
-        elif any(word in question for word in ['when', 'date', 'year', 'time']):
-            return 'temporal'
-        elif any(word in question for word in ['who', 'which person', 'author', 'creator']):
-            return 'biographical'
-        elif any(word in question for word in ['what is', 'define', 'explain']):
-            return 'definitional'
-        elif any(word in question for word in ['compare', 'difference', 'versus', 'vs']):
-            return 'comparative'
-        elif any(word in question for word in ['calculate', 'compute', 'solve']):
-            return 'mathematical'
-        else:
-            return 'general'
-
-    def _build_enhanced_prompt(self, question: str, question_type: str) -> str:
-        """Build question-specific prompts for maximum accuracy."""
-        base_prompt = self._build_enhanced_system_prompt()
-
-        type_specific_instructions = {
-            'quantitative': """
-QUANTITATIVE QUESTION DETECTED:
-- Provide exact numbers whenever possible
-- Show your counting/calculation process
-- Double-check your arithmetic
-- If estimating, clearly state it's an estimate
-- Be precise about the scope of your count
-""",
-            'temporal': """
-TEMPORAL QUESTION DETECTED:
-- Provide specific dates, years, or time periods
-- Use exact timeframes when known
-- If uncertain about exact dates, provide the closest known timeframe
-- Consider historical context and sequence of events
-""",
-            'biographical': """
-BIOGRAPHICAL QUESTION DETECTED:
-- Provide full names when available
-- Include relevant titles, positions, or roles
-- Add brief context about why this person is notable
-- Verify the person matches the context of the question
-""",
-            'definitional': """
-DEFINITIONAL QUESTION DETECTED:
-- Provide clear, accurate definitions
-- Include key characteristics or components
-- Add relevant examples if helpful
-- Ensure completeness without unnecessary complexity
-""",
-            'comparative': """
-COMPARATIVE QUESTION DETECTED:
-- Identify specific criteria for comparison
-- Provide structured analysis
-- Highlight key similarities and differences
-- Use concrete examples where possible
-""",
-            'mathematical': """
-MATHEMATICAL QUESTION DETECTED:
-- Show all calculation steps clearly
-- Double-check your arithmetic
-- State any assumptions made
-- Present the final answer clearly
-"""
-        }
-
-        specific_instruction = type_specific_instructions.get(question_type, "")
-
-        return f"{base_prompt}\n\n{specific_instruction}\nQUESTION: {question}\n\nProvide your most accurate, well-reasoned response:"
-
-    async def process_question(self, question: str, context: Optional[str] = None) -> str:
-        """Process a question with enhanced accuracy strategies and multi-key fallback."""
-        try:
-            # Sanitize and analyze the question
-            clean_question = sanitize_input(question)
-            question_type = self._analyze_question_type(clean_question)
-
-            # Build the enhanced prompt
-            enhanced_prompt = self._build_enhanced_prompt(clean_question, question_type)
-
-            # Add context if provided
-            if context:
-                enhanced_prompt += f"\n\nAdditional Context: {context}"
-
-            # Generate response with optimized parameters using multi-key client
-            generation_config = {
-                'max_output_tokens': self.config.max_tokens,
-                'temperature': self.config.temperature,
-                'top_p': self.config.top_p,
-                'top_k': self.config.top_k,
-            }
-
-            response_text = self.client.generate_content(
-                enhanced_prompt,
-                generation_config=generation_config
-            )
-
-            if response_text:
-                # Post-process the response for accuracy
-                processed_response = self._post_process_response(response_text, question_type)
-                formatted_response = format_response(processed_response)
-
-                # Update conversation history
-                self._update_history(clean_question, formatted_response)
-
-                logger.info(f"Successfully processed {question_type} question: {clean_question[:50]}...")
-                return formatted_response
-            else:
-                # Check if all API keys are exhausted
-                status = self.get_status()
-                available_keys = sum(1 for key in status['keys'] if key['can_make_request'])
-
-                if available_keys == 0:
-                    error_msg = "I apologize, but all API keys have exceeded their quotas. Please try again later or add more API keys."
-                else:
-                    error_msg = "I apologize, but I couldn't generate a response. Please try rephrasing your question."
-
-                logger.warning(f"Failed to generate response. Available keys: {available_keys}")
-                return error_msg
-
-        except Exception as e:
-            logger.error(f"Error processing question: {e}")
-            return f"I encountered an error while processing your question: {str(e)}"
-
-    def _post_process_response(self, response: str, question_type: str) -> str:
-        """Post-process responses based on question type for maximum accuracy."""
-
-        if question_type == 'quantitative':
-            # Ensure numerical answers are clearly stated
-            numbers = re.findall(r'\b\d+\b', response)
-            if numbers and not response.strip().startswith(tuple(numbers)):
-                # If the response doesn't start with a number, try to restructure
-                pass  # Keep original for now, but could enhance further
-
-        elif question_type == 'temporal':
-            # Ensure dates are properly formatted
-            response = re.sub(r'\b(\d{4})\b', r'\1', response)  # Ensure years are clear
-
-        # General cleanup
-        response = response.strip()
-
-        # Remove any uncertain language that might reduce confidence
-        uncertain_phrases = [
-            "I think", "I believe", "probably", "might be", "could be",
-            "it seems", "appears to be", "likely"
-        ]
-
-        # Only remove uncertainty if we have factual content
-        if any(indicator in response.lower() for indicator in ['according to', 'research shows', 'studies indicate']):
-            for phrase in uncertain_phrases:
-                response = re.sub(f'\\b{phrase}\\b', '', response, flags=re.IGNORECASE)
-                response = re.sub(r'\s+', ' ', response)  # Clean up extra spaces
-
-        return response
-
-    def _update_history(self, question: str, answer: str):
-        """Update conversation history with enhanced tracking."""
-        self.conversation_history.append({
-            'question': question,
-            'answer': answer,
-            'question_type': self._analyze_question_type(question)
-        })
-
-        # Keep recent history for context
-        if len(self.conversation_history) > self.config.max_history_length:
-            self.conversation_history = self.conversation_history[-self.config.max_history_length:]
-
-    def clear_history(self):
-        """Clear the conversation history."""
-        self.conversation_history.clear()
-        logger.info("Conversation history cleared")
-
-    def get_stats(self) -> Dict[str, Any]:
-        """Get enhanced agent statistics including API key information."""
-        question_types = {}
-        for entry in self.conversation_history:
-            q_type = entry.get('question_type', 'unknown')
-            question_types[q_type] = question_types.get(q_type, 0) + 1
-
-        # Get API key status
-        api_status = self.get_status()
-
-        return {
-            'model': self.config.model_name,
-            'conversation_length': len(self.conversation_history),
-            'max_tokens': self.config.max_tokens,
-            'temperature': self.config.temperature,
-            'question_types_handled': question_types,
-            'total_api_keys': api_status['total_keys'],
-            'current_api_key': api_status['keys'][api_status['current_key']]['label'],
-            'available_keys': sum(1 for key in api_status['keys'] if key['can_make_request'])
-        }
-
-    def get_status(self) -> Dict[str, Any]:
-        """Get current status of the agent and API keys."""
-        return self.client.get_status()
-
-    def get_detailed_status(self) -> str:
-        """Get a formatted status report."""
-        status = self.get_status()
-        stats = self.get_stats()
-
-        report = []
-        report.append("=== ENHANCED GEMINI AGENT STATUS ===")
-        report.append(f"Model: {status['current_model']}")
-        report.append(f"Model Initialized: {status['model_initialized']}")
-        report.append(f"Total API Keys: {status['total_keys']}")
-        report.append(f"Available Keys: {stats['available_keys']}")
-        report.append(f"Conversation Length: {stats['conversation_length']}")
-        report.append(f"Temperature: {stats['temperature']}")
-        report.append(f"Max Tokens: {stats['max_tokens']}")
-        report.append("")
-        report.append("Question Types Handled:")
-        for q_type, count in stats['question_types_handled'].items():
-            report.append(f"  {q_type}: {count}")
-        report.append("")
-        report.append("API Keys Status:")
-
-        for key_info in status['keys']:
-            active_indicator = "✓" if key_info['is_active'] else "✗"
-            current_indicator = " (CURRENT)" if key_info['is_current'] else ""
-            can_request = "✓" if key_info['can_make_request'] else "✗"
-
-            report.append(
-                f"  {active_indicator} {key_info['label']}: "
-                f"Daily {key_info['daily_usage']}, "
-                f"Minute {key_info['minute_usage']}, "
-                f"Can Request: {can_request}"
-                f"{current_indicator}"
-            )
-
-        return "\n".join(report)
-
-    def reset_all_keys(self):
-        """Reset all API keys (for testing purposes)."""
-        self.client.config.reset_all_keys()
-        logger.info("All API keys reset")
-
-    def switch_to_next_key(self) -> bool:
-        """Manually switch to next available API key."""
-        try:
-            current_status = self.get_status()
-            current_key_label = current_status['keys'][current_status['current_key']]['label']
-
-            # Force switch by simulating quota error
-            success = self.client._switch_api_key("Manual switch requested")
-
-            if success:
-                new_status = self.get_status()
-                new_key_label = new_status['keys'][new_status['current_key']]['label']
-                logger.info(f"Switched from {current_key_label} to {new_key_label}")
-                return True
-            else:
-                logger.warning("No alternative API keys available")
-                return False
-
-        except Exception as e:
-            logger.error(f"Error switching API key: {e}")
-            return False
-
-    # Compatibility method for Gradio interface
-    def chat(self, message: str, history: Optional[List[List[str]]] = None) -> str:
-        """
-        Chat method for Gradio interface compatibility.
-        Processes the message asynchronously and returns the response.
-        """
-        try:
-            # Run the async process_question method
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            response = loop.run_until_complete(self.process_question(message))
-            loop.close()
-            return response
-        except Exception as e:
-            logger.error(f"Error in chat method: {e}")
-            return f"I encountered an error: {str(e)}"

src/config.py

@@ -1,315 +0,0 @@
-"""
-Enhanced configuration with multiple API keys and automatic fallback.
-"""
-
-import os
-import time
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class APIKeyInfo:
-    """Information about an API key."""
-    key: str
-    label: str
-    is_active: bool = True
-    requests_used: int = 0
-    requests_this_minute: int = 0
-    last_request_time: float = 0
-    daily_limit: int = 1500  # Gemini free tier daily limit
-    minute_limit: int = 15   # Gemini free tier per-minute limit
-
-
-class Config:
-    """
-    Enhanced configuration class with multiple API keys and automatic fallback.
-    """
-
-    def __init__(self):
-        """Initialize configuration with multiple API keys."""
-        # Model configuration
-        self.model_name = "gemini-2.0-flash"
-        self.temperature = 0.7
-        self.max_output_tokens = 2048
-        self.max_tokens = 4096  # Backward compatibility
-        self.timeout_seconds = 30
-        self.retry_attempts = 3
-
-        # Additional backward compatibility attributes
-        self.top_p = 0.95
-        self.top_k = 40
-        self.max_history_length = 10  # Maximum conversation history to maintain
-        self.safety_threshold = "BLOCK_MEDIUM_AND_ABOVE"  # Safety settings
-        self.candidate_count = 1  # Number of response candidates
-
-        # Initialize API keys
-        self.api_keys: List[APIKeyInfo] = []
-        self.current_key_index = 0
-        self._load_api_keys()
-
-        if not self.api_keys:
-            raise ValueError("No API keys found. Please set GEMINI_API_KEY or GEMINI_API_KEY_1, GEMINI_API_KEY_2, etc.")
-
-    def _load_api_keys(self):
-        """Load API keys from environment variables."""
-        # Try single key first
-        single_key = os.getenv("GEMINI_API_KEY")
-        if single_key:
-            self.api_keys.append(APIKeyInfo(
-                key=single_key,
-                label="Primary Key"
-            ))
-
-        # Try numbered keys
-        key_index = 1
-        while True:
-            key = os.getenv(f"GEMINI_API_KEY_{key_index}")
-            if not key:
-                break
-            self.api_keys.append(APIKeyInfo(
-                key=key,
-                label=f"Key #{key_index}"
-            ))
-            key_index += 1
-
-        # If we found numbered keys and a single key, rename the single key
-        if len(self.api_keys) > 1 and single_key:
-            self.api_keys[0].label = "Key #0 (Primary)"
-
-        print(f"Loaded {len(self.api_keys)} API key(s)")
-
-    def get_current_api_key(self) -> str:
-        """Get the current active API key."""
-        if not self.api_keys or self.current_key_index >= len(self.api_keys):
-            raise RuntimeError("No active API key available")
-
-        current_key_info = self.api_keys[self.current_key_index]
-        if not current_key_info.is_active:
-            raise RuntimeError("Current API key is not active")
-
-        return current_key_info.key
-
-    def get_generation_config(self) -> Dict[str, Any]:
-        """Get the generation configuration for Gemini."""
-        return {
-            "temperature": self.temperature,
-            "max_output_tokens": self.max_output_tokens,
-            "top_p": getattr(self, 'top_p', 0.95),
-            "top_k": getattr(self, 'top_k', 40),
-            "candidate_count": getattr(self, 'candidate_count', 1),
-        }
-
-    def get_safety_settings(self) -> List[Dict[str, str]]:
-        """Get safety settings for Gemini."""
-        from google.generativeai.types import HarmCategory, HarmBlockThreshold
-
-        # Return basic safety settings
-        return [
-            {
-                "category": "HARM_CATEGORY_HARASSMENT",
-                "threshold": getattr(self, 'safety_threshold', "BLOCK_MEDIUM_AND_ABOVE")
-            },
-            {
-                "category": "HARM_CATEGORY_HATE_SPEECH",
-                "threshold": getattr(self, 'safety_threshold', "BLOCK_MEDIUM_AND_ABOVE")
-            },
-            {
-                "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-                "threshold": getattr(self, 'safety_threshold', "BLOCK_MEDIUM_AND_ABOVE")
-            },
-            {
-                "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-                "threshold": getattr(self, 'safety_threshold', "BLOCK_MEDIUM_AND_ABOVE")
-            }
-        ]
-
-    def handle_quota_error(self, error_message: str = "") -> bool:
-        """
-        Handle quota exceeded error by switching to next available API key.
-
-        Args:
-            error_message: Error message from the failed request
-
-        Returns:
-            bool: True if successfully switched to new key, False if no keys available
-        """
-        # Mark current key as exhausted
-        if self.current_key_index < len(self.api_keys):
-            current_key = self.api_keys[self.current_key_index]
-            current_key.is_active = False
-            print(f"Marking {current_key.label} as exhausted")
-
-        # Find next active key
-        original_index = self.current_key_index
-        attempts = 0
-
-        while attempts < len(self.api_keys):
-            self.current_key_index = (self.current_key_index + 1) % len(self.api_keys)
-            attempts += 1
-
-            if self.api_keys[self.current_key_index].is_active:
-                print(f"Switched to {self.api_keys[self.current_key_index].label}")
-                return True
-
-            if self.current_key_index == original_index:
-                break
-
-        # No active keys found
-        print("No active API keys remaining")
-        return False
-
-    def record_successful_request(self):
-        """Record a successful request for rate limiting."""
-        if self.current_key_index < len(self.api_keys):
-            key_info = self.api_keys[self.current_key_index]
-            current_time = time.time()
-
-            # Reset minute counter if more than a minute has passed
-            if current_time - key_info.last_request_time > 60:
-                key_info.requests_this_minute = 0
-
-            key_info.requests_used += 1
-            key_info.requests_this_minute += 1
-            key_info.last_request_time = current_time
-
-            # Check if we should preemptively mark key as exhausted
-            if (key_info.requests_used >= key_info.daily_limit or
-                key_info.requests_this_minute >= key_info.minute_limit):
-                print(f"Rate limit approaching for {key_info.label}, marking as exhausted")
-                key_info.is_active = False
-
-    def get_keys_status(self) -> Dict[str, Any]:
-        """
-        Get status of all API keys.
-
-        Returns:
-            Dictionary with detailed status information
-        """
-        keys_status = []
-
-        for i, key_info in enumerate(self.api_keys):
-            keys_status.append({
-                "label": key_info.label,
-                "is_active": key_info.is_active,
-                "is_current": i == self.current_key_index,
-                "daily_usage": key_info.requests_used,
-                "minute_usage": key_info.requests_this_minute,
-                "daily_limit": key_info.daily_limit,
-                "minute_limit": key_info.minute_limit
-            })
-
-        return {
-            "total_keys": len(self.api_keys),
-            "active_keys": sum(1 for key in self.api_keys if key.is_active),
-            "current_key": self.current_key_index,
-            "keys": keys_status
-        }
-
-    def reset_all_keys(self):
-        """Reset all API keys to active state (for testing purposes)."""
-        for key_info in self.api_keys:
-            key_info.is_active = True
-            key_info.requests_used = 0
-            key_info.requests_this_minute = 0
-            key_info.last_request_time = 0
-        print("All API keys reset to active state")
-
-    def add_api_key(self, api_key: str, label: str = None):
-        """
-        Add a new API key to the configuration.
-
-        Args:
-            api_key: The API key string
-            label: Optional label for the key
-        """
-        if label is None:
-            label = f"Key #{len(self.api_keys) + 1}"
-
-        self.api_keys.append(APIKeyInfo(key=api_key, label=label))
-        print(f"Added new API key: {label}")
-
-    def remove_api_key(self, index: int):
-        """
-        Remove an API key by index.
-
-        Args:
-            index: Index of the key to remove
-        """
-        if 0 <= index < len(self.api_keys):
-            removed_key = self.api_keys.pop(index)
-            print(f"Removed API key: {removed_key.label}")
-
-            # Adjust current index if necessary
-            if self.current_key_index >= len(self.api_keys):
-                self.current_key_index = 0
-        else:
-            print(f"Invalid key index: {index}")
-
-    def __getattr__(self, name):
-        """
-        Handle missing attributes gracefully with sensible defaults.
-        This ensures backward compatibility with existing code.
-        """
-        defaults = {
-            'max_history_length': 10,
-            'safety_threshold': 'BLOCK_MEDIUM_AND_ABOVE',
-            'candidate_count': 1,
-            'stop_sequences': [],
-            'presence_penalty': 0.0,
-            'frequency_penalty': 0.0,
-            'response_mime_type': 'text/plain',
-            'system_instruction': '',
-            'tools': [],
-            'tool_config': None
-        }
-
-        if name in defaults:
-            # Set the attribute so it's available for future access
-            setattr(self, name, defaults[name])
-            return defaults[name]
-
-        # If no default is available, raise the normal AttributeError
-        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
-
-
-# Example of how to set up multiple API keys in your environment:
-def setup_example():
-    """
-    Example showing how to set up multiple API keys.
-    This would typically be done in your shell/environment, not in code.
-    """
-    example_setup = '''
-    # In your shell or .env file:
-    export GEMINI_API_KEY="your-primary-key-here"
-    export GEMINI_API_KEY_1="your-first-backup-key"
-    export GEMINI_API_KEY_2="your-second-backup-key"
-    export GEMINI_API_KEY_3="your-third-backup-key"
-    '''
-    print("To use multiple API keys, set up your environment like this:")
-    print(example_setup)
-
-
-if __name__ == "__main__":
-    try:
-        config = Config()
-        status = config.get_keys_status()
-
-        print("=== Configuration Status ===")
-        print(f"Model: {config.model_name}")
-        print(f"Total API keys: {status['total_keys']}")
-        print(f"Active keys: {status['active_keys']}")
-        print()
-
-        print("API Keys:")
-        for key_status in status["keys"]:
-            active_indicator = "✓" if key_status["is_active"] else "✗"
-            current_indicator = " (CURRENT)" if key_status["is_current"] else ""
-            print(f"  {active_indicator} {key_status['label']}: "
-                  f"{key_status['daily_usage']}/{key_status['daily_limit']} daily, "
-                  f"{key_status['minute_usage']}/{key_status['minute_limit']} per minute"
-                  f"{current_indicator}")
-
-    except Exception as e:
-        print(f"Error: {e}")
-        setup_example()

src/gemini_client.py

@@ -1,232 +0,0 @@
-"""
-Enhanced Gemini client with automatic API key fallback.
-"""
-
-import google.generativeai as genai
-import time
-from typing import Optional, Dict, Any
-from config import Config  # Import the enhanced config
-
-
-class GeminiClientWithFallback:
-    """
-    Enhanced Gemini client that automatically switches API keys when quota is exceeded.
-    """
-
-    def __init__(self, config: Config):
-        """
-        Initialize the client with configuration.
-
-        Args:
-            config: Enhanced configuration with multiple API keys
-        """
-        self.config = config
-        self.current_model = None
-        self._initialize_model()
-
-    def _initialize_model(self):
-        """Initialize the Gemini model with current API key."""
-        try:
-            current_key = self.config.get_current_api_key()
-            genai.configure(api_key=current_key)
-            self.current_model = genai.GenerativeModel(
-                model_name=self.config.model_name,
-                generation_config=self.config.get_generation_config()
-            )
-            print(f"Initialized model with API key: {self.config.api_keys[self.config.current_key_index].label}")
-        except RuntimeError as e:
-            print(f"Failed to initialize model: {e}")
-            self.current_model = None
-
-    def _switch_api_key(self, error_message: str = "") -> bool:
-        """
-        Switch to next available API key.
-
-        Args:
-            error_message: Error message from failed request
-
-        Returns:
-            bool: True if successfully switched, False if no keys available
-        """
-        if self.config.handle_quota_error(error_message):
-            self._initialize_model()
-            return self.current_model is not None
-        return False
-
-    def generate_content(self, prompt: str, max_retries: Optional[int] = None) -> Optional[str]:
-        """
-        Generate content with automatic API key fallback.
-
-        Args:
-            prompt: The prompt to send to Gemini
-            max_retries: Maximum number of retries (uses config default if None)
-
-        Returns:
-            Generated content or None if all attempts failed
-        """
-        if max_retries is None:
-            max_retries = self.config.retry_attempts
-
-        last_error = None
-
-        for attempt in range(max_retries + 1):
-            if not self.current_model:
-                print("No model available. Trying to initialize...")
-                self._initialize_model()
-                if not self.current_model:
-                    continue
-
-            try:
-                print(f"Attempt {attempt + 1}/{max_retries + 1} with {self.config.api_keys[self.config.current_key_index].label}")
-
-                # Make the request
-                response = self.current_model.generate_content(
-                    prompt,
-                    request_options={"timeout": self.config.timeout_seconds}
-                )
-
-                # Record successful request
-                self.config.record_successful_request()
-
-                # Return the generated text
-                if response and response.text:
-                    return response.text.strip()
-                else:
-                    print("Empty response received")
-                    return None
-
-            except Exception as e:
-                error_message = str(e)
-                last_error = error_message
-                print(f"Request failed: {error_message}")
-
-                # Check if it's a quota error
-                if "429" in error_message or "quota" in error_message.lower():
-                    print("Quota exceeded detected. Attempting to switch API key...")
-
-                    if not self._switch_api_key(error_message):
-                        print("No more API keys available")
-                        break
-
-                    # Continue to next attempt with new key
-                    continue
-
-                # For other errors, wait a bit before retrying
-                elif attempt < max_retries:
-                    wait_time = min(2 ** attempt, 10)  # Exponential backoff, max 10 seconds
-                    print(f"Waiting {wait_time} seconds before retry...")
-                    time.sleep(wait_time)
-
-        print(f"All attempts failed. Last error: {last_error}")
-        return None
-
-    def get_status(self) -> Dict[str, Any]:
-        """
-        Get current status of the client and API keys.
-
-        Returns:
-            Dictionary with status information
-        """
-        status = self.config.get_keys_status()
-        status.update({
-            "model_initialized": self.current_model is not None,
-            "current_model": self.config.model_name
-        })
-        return status
-
-    def reset_all_keys(self):
-        """Reset all API keys to active state (for testing purposes)."""
-        for key_info in self.config.api_keys:
-            key_info.is_active = True
-            key_info.requests_used = 0
-            key_info.requests_this_minute = 0
-        print("All API keys reset to active state")
-
-
-# Example usage and testing
-def example_usage():
-    """
-    Example of how to use the enhanced client with fallback.
-    """
-    try:
-        # Initialize configuration
-        config = Config()
-
-        # Create client
-        client = GeminiClientWithFallback(config)
-
-        # Print initial status
-        print("=== Initial Status ===")
-        status = client.get_status()
-        print(f"Model initialized: {status['model_initialized']}")
-        print(f"Total API keys: {status['total_keys']}")
-        print(f"Current key: {status['keys'][status['current_key']]['label']}")
-
-        # Test request
-        print("\n=== Testing Request ===")
-        prompt = "Explain quantum computing in simple terms."
-        response = client.generate_content(prompt)
-
-        if response:
-            print("Success! Response received:")
-            print(response[:200] + "..." if len(response) > 200 else response)
-        else:
-            print("Failed to get response")
-
-        # Print final status
-        print("\n=== Final Status ===")
-        final_status = client.get_status()
-        for key_status in final_status["keys"]:
-            active_indicator = "✓" if key_status["is_active"] else "✗"
-            current_indicator = " (CURRENT)" if key_status["is_current"] else ""
-            print(f"  {active_indicator} {key_status['label']}: {key_status['daily_usage']} daily, {key_status['minute_usage']} per minute{current_indicator}")
-
-    except Exception as e:
-        print(f"Error in example: {e}")
-
-
-def simulate_quota_exhaustion():
-    """
-    Simulate quota exhaustion to test key switching.
-    """
-    try:
-        config = Config()
-        client = GeminiClientWithFallback(config)
-
-        print("=== Simulating Heavy Usage ===")
-
-        # Simulate many requests to trigger quota limits
-        for i in range(15):  # More than the free tier limit per minute
-            print(f"\nRequest {i+1}:")
-            response = client.generate_content(f"Count to {i+1}")
-
-            if response:
-                print(f"Success: {response[:50]}...")
-            else:
-                print("Failed")
-
-            # Show current status
-            status = client.get_status()
-            current_key = status['keys'][status['current_key']]
-            print(f"Current key: {current_key['label']} ({current_key['minute_usage']} requests this minute)")
-
-            time.sleep(1)  # Small delay between requests
-
-    except Exception as e:
-        print(f"Error in simulation: {e}")
-
-
-if __name__ == "__main__":
-    print("Choose test mode:")
-    print("1. Normal usage example")
-    print("2. Simulate quota exhaustion")
-
-    choice = input("Enter choice (1 or 2): ").strip()
-
-    if choice == "1":
-        example_usage()
-    elif choice == "2":
-        simulate_quota_exhaustion()
-    else:
-        print("Invalid choice")
-        example_usage()

src/ui.py

@@ -1,184 +0,0 @@
-"""
-Gradio user interface for the Gemini AI Agent.
-"""
-
-import gradio as gr
-import asyncio
-import logging
-from typing import List, Tuple, Optional
-from src.agent import GeminiAgent
-from src.utils import validate_question, format_error_message
-
-
-logger = logging.getLogger(__name__)
-
-
-def create_interface(agent: GeminiAgent) -> gr.Blocks:
-    """
-    Create the Gradio interface for the AI agent.
-
-    Args:
-        agent: The GeminiAgent instance
-
-    Returns:
-        gr.Blocks: The Gradio interface
-    """
-
-    async def process_question_async(question: str, context: str = "") -> str:
-        """
-        Async wrapper for question processing.
-        """
-        return await agent.process_question(question, context or None)
-
-    def process_question_sync(question: str, context: str = "") -> str:
-        """
-        Synchronous wrapper for question processing (required by Gradio).
-        """
-        try:
-            # Validate question
-            is_valid, error_msg = validate_question(question)
-            if not is_valid:
-                return f"❌ **Error**: {error_msg}"
-
-            # Process question
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                result = loop.run_until_complete(process_question_async(question, context))
-                return f"🤖 **AI Response**:\n\n{result}"
-            finally:
-                loop.close()
-
-        except Exception as e:
-            error_msg = format_error_message(e)
-            return f"❌ **Error**: {error_msg}"
-
-    def clear_conversation():
-        """
-        Clear the conversation history.
-        """
-        agent.clear_history()
-        return "", "Conversation history cleared! ✨"
-
-    def get_agent_info() -> str:
-        """
-        Get information about the agent.
-        """
-        stats = agent.get_stats()
-        return f"""
-## 🤖 Agent Information
-
-**Model**: {stats['model']}
-**Conversation Length**: {stats['conversation_length']} exchanges
-**Max Tokens**: {stats['max_tokens']}
-**Temperature**: {stats['temperature']}
-
-### 🎯 Specialized Capabilities
-- **Complex Research**: Multi-source fact-checking and analysis
-- **Mathematical Reasoning**: Step-by-step problem solving
-- **Multi-modal Analysis**: Processing images, videos, and audio
-- **Data Interpretation**: Tables, charts, and statistical analysis
-- **Creative Problem Solving**: Innovative approaches to unusual questions
-"""
-
-    # Create the interface
-    with gr.Blocks(
-        title="Gemini AI Research Agent",
-        theme=gr.themes.Soft(),
-        css="""
-        .container {
-            max-width: 1200px;
-            margin: auto;
-        }
-        .question-box {
-            border-left: 4px solid #4CAF50;
-            padding-left: 16px;
-        }
-        .response-box {
-            background-color: #f8f9fa;
-            border-radius: 8px;
-            padding: 16px;
-        }
-        """
-    ) as interface:
-
-        gr.Markdown("""
-        # 🧠 Gemini AI Research Agent
-
-        An advanced AI assistant powered by Google's Gemini 1.5 Flash, specialized in handling complex research questions, data analysis, and multi-modal content processing.
-
-        **Perfect for**: Academic research, fact-checking, mathematical problems, data analysis, and challenging multi-step questions.
-        """)
-
-        with gr.Row():
-            with gr.Column(scale=2):
-                with gr.Group():
-                    gr.Markdown("## 💬 Ask Your Question")
-
-                    question_input = gr.Textbox(
-                        label="Question",
-                        placeholder="Enter your research question here... (e.g., 'How many studio albums were published by Mercedes Sosa between 2000 and 2009?')",
-                        lines=4,
-                        elem_classes=["question-box"]
-                    )
-
-                    context_input = gr.Textbox(
-                        label="Additional Context (Optional)",
-                        placeholder="Provide any additional context, constraints, or specific requirements...",
-                        lines=2
-                    )
-
-                    with gr.Row():
-                        submit_btn = gr.Button("🔍 Ask Question", variant="primary", size="lg")
-                        clear_btn = gr.Button("🗑️ Clear History", variant="secondary")
-
-                with gr.Group():
-                    gr.Markdown("## 📝 Response")
-                    response_output = gr.Textbox(
-                        label="AI Response",
-                        lines=15,
-                        interactive=False,
-                        elem_classes=["response-box"]
-                    )
-
-            with gr.Column(scale=1):
-                with gr.Group():
-                    gr.Markdown("## ℹ️ Agent Status")
-                    agent_info = gr.Markdown(get_agent_info())
-                    refresh_info_btn = gr.Button("🔄 Refresh Info", size="sm")
-
-
-        gr.Markdown("""
-        ---
-        ### 🔧 Tips for Best Results:
-        - **Be Specific**: Include all relevant details and constraints
-        - **Multi-step Questions**: Break complex questions into clear parts
-        - **Context Matters**: Use the context field for additional information
-        - **Iterative Approach**: Build on previous questions for deeper analysis
-        """)
-
-        # Event handlers
-        submit_btn.click(
-            fn=process_question_sync,
-            inputs=[question_input, context_input],
-            outputs=[response_output]
-        )
-
-        clear_btn.click(
-            fn=clear_conversation,
-            outputs=[question_input, response_output]
-        )
-
-        refresh_info_btn.click(
-            fn=get_agent_info,
-            outputs=[agent_info]
-        )
-
-        # Allow Enter key to submit
-        question_input.submit(
-            fn=process_question_sync,
-            inputs=[question_input, context_input],
-            outputs=[response_output]
-        )
-
-    return interface

src/utils.py

@@ -1,302 +0,0 @@
-"""
-Enhanced utility functions for the Gemini AI Agent.
-Includes advanced text processing and accuracy improvements.
-"""
-
-import re
-import logging
-from typing import Optional, Tuple, List
-import unicodedata
-
-logger = logging.getLogger(__name__)
-
-
-def sanitize_input(text: str) -> str:
-    """
-    Enhanced input sanitization with better text processing.
-
-    Args:
-        text: Raw input text
-
-    Returns:
-        str: Sanitized and normalized text
-    """
-    if not isinstance(text, str):
-        return str(text)
-
-    # Normalize unicode characters
-    text = unicodedata.normalize('NFKD', text)
-
-    # Remove excessive whitespace while preserving structure
-    text = re.sub(r'\s+', ' ', text.strip())
-
-    # Clean up common formatting issues
-    text = text.replace('\\n', '\n').replace('\\t', '\t')
-
-    # Remove zero-width characters
-    text = re.sub(r'[\u200b-\u200d\ufeff]', '', text)
-
-    return text
-
-
-def format_response(response: str) -> str:
-    """
-    Enhanced response formatting for better readability and accuracy.
-
-    Args:
-        response: Raw response from the AI model
-
-    Returns:
-        str: Enhanced formatted response
-    """
-    if not response:
-        return "No response generated."
-
-    # Clean up the response
-    response = response.strip()
-
-    # Fix spacing issues
-    response = re.sub(r'\.([A-Z])', r'. \1', response)
-    response = re.sub(r'([.!?])\s*([A-Z])', r'\1 \2', response)
-
-    # Clean up multiple newlines but preserve intentional formatting
-    response = re.sub(r'\n\s*\n\s*\n+', '\n\n', response)
-
-    # Ensure proper spacing around punctuation
-    response = re.sub(r'([,;:])\s*', r'\1 ', response)
-    response = re.sub(r'\s+([,;:.])', r'\1', response)
-
-    # Fix common numerical formatting
-    response = re.sub(r'(\d)\s*,\s*(\d{3})', r'\1,\2', response)  # Fix thousands separators
-
-    # Ensure proper capitalization after periods
-    def capitalize_after_period(match):
-        return match.group(1) + match.group(2).upper()
-
-    response = re.sub(r'(\. )([a-z])', capitalize_after_period, response)
-
-    return response
-
-
-def extract_key_information(text: str, question_type: str) -> dict:
-    """
-    Extract key information based on question type for accuracy verification.
-
-    Args:
-        text: Text to analyze
-        question_type: Type of question being answered
-
-    Returns:
-        dict: Extracted key information
-    """
-    extracted = {'type': question_type}
-
-    if question_type == 'quantitative':
-        # Extract numbers
-        numbers = re.findall(r'\b\d+(?:,\d{3})*(?:\.\d+)?\b', text)
-        extracted['numbers'] = numbers
-
-    elif question_type == 'temporal':
-        # Extract dates and years
-        years = re.findall(r'\b(19|20)\d{2}\b', text)
-        dates = re.findall(r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b', text)
-        extracted['years'] = years
-        extracted['dates'] = dates
-
-    elif question_type == 'biographical':
-        # Extract names (basic pattern)
-        names = re.findall(r'\b[A-Z][a-z]+ [A-Z][a-z]+\b', text)
-        extracted['names'] = names
-
-    return extracted
-
-
-def validate_question(question: str) -> Tuple[bool, Optional[str]]:
-    """
-    Enhanced question validation with specific checks.
-
-    Args:
-        question: The question to validate
-
-    Returns:
-        tuple: (is_valid, error_message)
-    """
-    if not question or not question.strip():
-        return False, "Question cannot be empty."
-
-    clean_question = question.strip()
-
-    # Length checks
-    if len(clean_question) < 3:
-        return False, "Question is too short. Please provide more detail."
-
-    if len(clean_question) > 8000:  # Increased limit for complex questions
-        return False, "Question is too long. Please keep it under 8000 characters."
-
-    # Check for question-like structure
-    question_indicators = ['?', 'what', 'how', 'when', 'where', 'who', 'why', 'which', 'can', 'is', 'are', 'do', 'does']
-    has_question_indicator = any(indicator in clean_question.lower() for indicator in question_indicators)
-
-    if not has_question_indicator:
-        return False, "Please formulate your input as a clear question."
-
-    # Check for potentially problematic content
-    problematic_patterns = [
-        r'<script.*?>.*?</script>',  # Script tags
-        r'javascript:',  # JavaScript protocol
-        r'data:text/html',  # Data URLs
-    ]
-
-    for pattern in problematic_patterns:
-        if re.search(pattern, clean_question, re.IGNORECASE):
-            return False, "Question contains potentially unsafe content."
-
-    return True, None
-
-
-def extract_confidence_indicators(text: str) -> dict:
-    """
-    Extract confidence indicators from response text.
-
-    Args:
-        text: Response text to analyze
-
-    Returns:
-        dict: Confidence analysis
-    """
-    # High confidence indicators
-    high_confidence = [
-        'according to', 'research shows', 'studies indicate', 'data shows',
-        'confirmed', 'established', 'proven', 'documented', 'verified'
-    ]
-
-    # Low confidence indicators
-    low_confidence = [
-        'i think', 'i believe', 'probably', 'might be', 'could be',
-        'it seems', 'appears to be', 'likely', 'possibly', 'perhaps',
-        'uncertain', 'unclear', 'ambiguous'
-    ]
-
-    # Hedging language
-    hedging = [
-        'somewhat', 'rather', 'quite', 'fairly', 'relatively',
-        'generally', 'typically', 'usually', 'often'
-    ]
-
-    text_lower = text.lower()
-
-    high_count = sum(1 for phrase in high_confidence if phrase in text_lower)
-    low_count = sum(1 for phrase in low_confidence if phrase in text_lower)
-    hedge_count = sum(1 for phrase in hedging if phrase in text_lower)
-
-    # Calculate confidence score
-    confidence_score = max(0.1, min(1.0, (high_count * 0.3 + (1 - low_count * 0.2) + (1 - hedge_count * 0.1))))
-
-    return {
-        'confidence_score': confidence_score,
-        'high_confidence_indicators': high_count,
-        'low_confidence_indicators': low_count,
-        'hedging_indicators': hedge_count,
-        'assessment': 'high' if confidence_score > 0.7 else 'medium' if confidence_score > 0.4 else 'low'
-    }
-
-
-def format_error_message(error: Exception) -> str:
-    """
-    Enhanced error message formatting with more specific guidance.
-
-    Args:
-        error: The exception that occurred
-
-    Returns:
-        str: User-friendly error message with guidance
-    """
-    error_type = type(error).__name__
-    error_str = str(error)
-
-    # Enhanced error messages with actionable guidance
-    error_messages = {
-        'ConnectionError': 'Unable to connect to the AI service. Please check your internet connection and try again.',
-        'TimeoutError': 'The request timed out. This often happens with very complex questions. Try breaking your question into smaller parts.',
-        'ValueError': 'There was an issue with the input format. Please check that your question is clearly stated and try again.',
-        'KeyError': 'Configuration error detected. Please verify that your API key is correctly set.',
-        'PermissionError': 'Access denied. Please check that your API key has the necessary permissions.',
-        'RateLimitError': 'Rate limit exceeded. Please wait a moment before trying again.',
-        'QuotaExceededError': 'API quota exceeded. Please check your account limits.',
-        'AuthenticationError': 'Authentication failed. Please verify your API key is correct.'
-    }
-
-    # Check for specific error patterns
-    if 'quota' in error_str.lower():
-        user_message = 'API quota exceeded. Please check your account limits or try again later.'
-    elif 'rate limit' in error_str.lower():
-        user_message = 'Rate limit exceeded. Please wait a moment before trying again.'
-    elif 'authentication' in error_str.lower() or 'api key' in error_str.lower():
-        user_message = 'Authentication error. Please verify your API key is correct and has proper permissions.'
-    else:
-        user_message = error_messages.get(error_type, f"An unexpected error occurred: {error_str}")
-
-    logger.error(f"Enhanced error formatted for user: {error_type} - {error_str}")
-    return user_message
-
-
-def optimize_prompt_for_accuracy(prompt: str, question_type: str) -> str:
-    """
-    Optimize prompts based on question types for better accuracy.
-
-    Args:
-        prompt: Original prompt
-        question_type: Type of question
-
-    Returns:
-        str: Optimized prompt
-    """
-    accuracy_boosters = {
-        'quantitative': "Be precise with numbers. If counting items, list them systematically. Double-check calculations.",
-        'temporal': "Provide specific dates and timeframes. If uncertain about exact dates, clearly state the closest known timeframe.",
-        'biographical': "Provide full names and relevant context. Verify the person matches the question context.",
-        'definitional': "Give clear, complete definitions. Include essential characteristics and avoid ambiguity.",
-        'comparative': "Make systematic comparisons using specific criteria. Highlight key differences clearly.",
-        'mathematical': "Show all calculation steps. Verify arithmetic. State assumptions clearly."
-    }
-
-    booster = accuracy_boosters.get(question_type, "Provide accurate, well-reasoned responses with specific details.")
-
-    return f"{prompt}\n\nACCURACY FOCUS: {booster}"
-
-
-def truncate_text(text: str, max_length: int = 2000) -> str:
-    """
-    Enhanced text truncation with better word boundary preservation.
-
-    Args:
-        text: Text to truncate
-        max_length: Maximum length allowed
-
-    Returns:
-        str: Truncated text
-    """
-    if len(text) <= max_length:
-        return text
-
-    # Find the last sentence end before max_length
-    truncated = text[:max_length]
-
-    # Look for sentence endings
-    sentence_endings = ['. ', '! ', '? ']
-    last_sentence_end = -1
-
-    for ending in sentence_endings:
-        pos = truncated.rfind(ending)
-        if pos > last_sentence_end and pos > max_length * 0.7:  # At least 70% of desired length
-            last_sentence_end = pos + len(ending)
-
-    if last_sentence_end > 0:
-        return truncated[:last_sentence_end].strip()
-
-    # Fall back to word boundary
-    last_space = truncated.rfind(' ')
-    if last_space > max_length * 0.8:  # At least 80% of desired length
-        return truncated[:last_space] + "..."
-    else:
-        return truncated + "..."