Update app.py

app.py

@@ -1,16 +1,178 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import CodeAgent, tool
 import datetime
 import requests
 import pytz
 import yaml
+import os
+import tempfile
 from tools.final_answer import FinalAnswerTool
 from tools.visit_webpage import VisitWebpageTool
-#from tools.web_shearch import DuckDuckGoSearchTool
 from smolagents import GradioUI
-import tempfile
 import gradio as gr
+import json
 import os
-from smolagents.models import GeminiModel
+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 !