Update app.py

app.py

@@ -13,166 +13,7 @@ import json
 import os
 from typing import Dict, List, Optional, Union, Any
 
-# Create a custom model adapter for Gemini since it's not natively supported in smolagents 1.13.0
-from smolagents.models import LLMAdapter
-import google.generativeai as genai
 
-class CustomGeminiAdapter(LLMAdapter):
-    """
-    Custom adapter for Google's Gemini model.
-    
-    This adapter lets us use Gemini with smolagents even if it's not natively supported.
-    """
-    
-    def __init__(
-        self,
-        model: str = "gemini-1.5-pro",
-        temperature: float = 0.7,
-        max_tokens: int = 2048,
-        api_key: Optional[str] = None,
-    ):
-        """Initialize the Gemini adapter."""
-        self.model = model
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-        
-        # Set up API key
-        if api_key:
-            genai.configure(api_key=api_key)
-        elif os.environ.get("GOOGLE_API_KEY"):
-            genai.configure(api_key=os.environ.get("GOOGLE_API_KEY"))
-        else:
-            raise ValueError("Google API key must be provided either through api_key parameter or GOOGLE_API_KEY environment variable")
-        
-        # Configure the model
-        self.generation_config = {
-            "temperature": temperature,
-            "max_output_tokens": max_tokens,
-            "top_p": 0.95,
-            "top_k": 0,
-        }
-
-    def call(
-        self,
-        system_message: str,
-        messages: List[Dict[str, str]],
-        functions: Optional[List[Dict]] = None,
-        function_call: Optional[str] = None,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        """
-        Call the Gemini model with messages and return the response.
-        
-        Args:
-            system_message: System message to set context
-            messages: List of messages in the conversation
-            functions: Function definitions (for function calling)
-            function_call: Function to call
-        
-        Returns:
-            Dictionary with model response
-        """
-        try:
-            # Convert messages format to what Gemini expects
-            gemini_messages = []
-            
-            # Add system message as user message at the beginning (Gemini doesn't have system)
-            if system_message:
-                gemini_messages.append({
-                    "role": "user",
-                    "parts": [{"text": f"System: {system_message}"}]
-                })
-                gemini_messages.append({
-                    "role": "model",
-                    "parts": [{"text": "I understand and will follow these instructions."}]
-                })
-            
-            # Add the rest of the messages
-            for message in messages:
-                if message["role"] == "system":
-                    # Handle system messages as user instructions
-                    gemini_messages.append({
-                        "role": "user",
-                        "parts": [{"text": f"System instruction: {message['content']}"}]
-                    })
-                else:
-                    role = "user" if message["role"] == "user" else "model"
-                    gemini_messages.append({
-                        "role": role,
-                        "parts": [{"text": message["content"]}]
-                    })
-            
-            # Create the Gemini model
-            model = genai.GenerativeModel(
-                model_name=self.model,
-                generation_config=self.generation_config
-            )
-            
-            # For function calling (tools)
-            if functions and len(functions) > 0:
-                # Simulate function calling by adding function descriptions to the prompt
-                function_descriptions = []
-                for func in functions:
-                    function_descriptions.append(f"""
-Function Name: {func.get('name')}
-Description: {func.get('description')}
-Parameters: {json.dumps(func.get('parameters', {}))}
-                    """)
-                
-                function_context = """
-You have access to the following functions. When you decide to use a function, respond with a JSON object with 'function_call' key containing 'name' and 'arguments' keys.
-Example: {"function_call": {"name": "function_name", "arguments": {"arg1": "value1"}}}
-
-Functions:
-""" + "\n\n".join(function_descriptions)
-                
-                # Add function description as the last user message
-                gemini_messages.append({
-                    "role": "user",
-                    "parts": [{"text": function_context}]
-                })
-            
-            # Create a chat session
-            chat = model.start_chat(history=gemini_messages[:-1])
-            
-            # Get the last message content
-            last_message = gemini_messages[-1]["parts"][0]["text"]
-            
-            # Generate response
-            response = chat.send_message(last_message)
-            content = response.text
-            
-            # Process the content to see if it contains a function call
-            function_call_data = None
-            if functions:
-                # Check if the response contains a function call format
-                import re
-                function_call_match = re.search(r'{\s*"function_call"\s*:\s*{.*?}\s*}', content, re.DOTALL)
-                if function_call_match:
-                    try:
-                        function_call_text = function_call_match.group(0)
-                        function_call_data = json.loads(function_call_text)
-                        # Remove the function call from the content
-                        content = content.replace(function_call_text, "").strip()
-                    except json.JSONDecodeError:
-                        pass
-            
-            # Create response format that matches what smolagents expects
-            result = {
-                "content": content
-            }
-            
-            # Add function call if present
-            if function_call_data:
-                result["function_call"] = {
-                    "name": function_call_data.get("function_call", {}).get("name", ""),
-                    "arguments": function_call_data.get("function_call", {}).get("arguments", {})
-                }
-            
-            return result
-        
-        except Exception as e:
-            return {"content": f"Error calling Gemini model: {str(e)}"}
 
 '''
 # Below is an example of a tool that does nothing. Amaze us with your creativity !