Update app.py

app.py

@@ -1,11 +1,16 @@
 import os
 import gradio as gr
 from google import genai
+from google.genai import types
 import requests
 import markdownify
 from urllib.robotparser import RobotFileParser
 from urllib.parse import urlparse
 
+# Initialize Gemini client
+client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
+MODEL = "gemini-2.5-pro-exp-03-25"
+
 # Configure browser tools
 def can_crawl_url(url: str, user_agent: str = "*") -> bool:
     """Check robots.txt permissions for a URL"""
@@ -29,62 +34,86 @@ def load_page(url: str) -> str:
     except Exception as e:
         return f"Error loading page: {str(e)}"
 
-# Initialize Gemini client
-client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
-MODEL = "gemini-2.0-flash"
+def execute_code(code: str) -> str:
+    """Execute Python code safely"""
+    try:
+        # Create a dictionary to hold the execution context
+        local_vars = {}
+        # Execute the code in the isolated context
+        exec(code, {}, local_vars)
+        # Return any output variables
+        return str(local_vars.get('result', 'Code executed (no output captured)'))
+    except Exception as e:
+        return f"Error executing code: {str(e)}"
 
-def generate_response(user_input):
+def generate_response(user_input, mode):
     try:
         if not user_input.strip():
             return "Please enter a valid query"
         
-        # First try direct response
-        response = client.models.generate_content(
-            model=MODEL,
-            contents=[user_input]
-        )
-        
-        result = response.text
-        
-        # If the response suggests needing web data, handle it
-        if "search" in result.lower() or "look up" in result.lower():
-            # Extract URL if mentioned
-            url = None
-            if "http" in result:
-                url = result.split("http")[1].split()[0]
-                url = "http" + url.split('"')[0].split("'")[0].split()[0]
-            
-            if url:
-                page_content = load_page(url)
-                follow_up = f"Here's content from {url}:\n\n{page_content[:2000]}...\n\nPlease summarize this information."
-                response = client.models.generate_content(
-                    model=MODEL,
-                    contents=[follow_up]
-                )
-                result = response.text
-            else:
-                result += "\n\n(I can't perform live searches but you can ask me to visit specific URLs)"
-        
-        # Handle code execution requests
-        if "code" in result.lower() or "calculate" in result.lower():
-            code_prompt = f"""Please provide only the Python code to solve this problem:
+        if mode == "code":
+            # Generate code for the problem
+            code_prompt = f"""Please provide complete Python code to solve this problem:
             {user_input}
-            The code should be complete and executable."""
-            code_response = client.models.generate_content(
+            The code should:
+            1. Be executable as-is
+            2. Store the final result in a variable called 'result'
+            3. Include any necessary imports"""
+            
+            response = client.models.generate_content(
                 model=MODEL,
                 contents=[code_prompt]
             )
-            result += f"\n\nSuggested Python code:\n```python\n{code_response.text}\n```"
+            
+            if response.text:
+                code = response.text.strip()
+                # Execute the generated code
+                execution_result = execute_code(code)
+                return f"Generated Python code:\n```python\n{code}\n```\n\nExecution result:\n{execution_result}"
+            return "No code was generated for this request."
         
-        return result
+        elif mode == "search":
+            # Simulate search functionality
+            search_prompt = f"""You are an AI assistant with web search capabilities.
+            For the query: "{user_input}"
+            1. Determine if this requires current/live information
+            2. If yes, suggest specific URLs to visit
+            3. If no, answer directly"""
+            
+            response = client.models.generate_content(
+                model=MODEL,
+                contents=[search_prompt]
+            )
+            
+            if "http" in response.text:
+                # Extract URL if mentioned
+                url = response.text.split("http")[1].split()[0]
+                url = "http" + url.split('"')[0].split("'")[0].split()[0]
+                page_content = load_page(url)
+                return f"Information from {url}:\n\n{page_content[:2000]}..."
+            return response.text
         
+        else:  # default mode
+            response = client.models.generate_content(
+                model=MODEL,
+                contents=[user_input]
+            )
+            return response.text
+            
     except Exception as e:
         return f"Error: {str(e)}"
 
 # Create Gradio interface
 with gr.Blocks(title="Gemini AI Assistant") as demo:
     gr.Markdown("# 🚀 Gemini AI Assistant")
-    gr.Markdown("Information • Code Suggestions")
+    gr.Markdown("Code Execution • Information Search")
+    
+    with gr.Row():
+        mode_radio = gr.Radio(
+            ["Default", "Code Execution", "Search Mode"],
+            label="Mode",
+            value="Default"
+        )
     
     with gr.Row():
         input_box = gr.Textbox(
@@ -93,28 +122,37 @@ with gr.Blocks(title="Gemini AI Assistant") as demo:
             lines=3,
             max_lines=10
         )
-        output_box = gr.Markdown(
-            label="Response",
-            elem_classes="markdown-output"
-        )
     
     with gr.Row():
         submit_btn = gr.Button("Submit", variant="primary")
         clear_btn = gr.Button("Clear")
     
+    output_box = gr.Markdown(
+        label="Response",
+        elem_classes="markdown-output"
+    )
+    
     def clear():
-        return ["", ""]
+        return ["", "", "Default"]
+    
+    def process_input(user_input, mode):
+        mode_map = {
+            "Default": "default",
+            "Code Execution": "code",
+            "Search Mode": "search"
+        }
+        return generate_response(user_input, mode_map.get(mode, "default"))
     
     submit_btn.click(
-        fn=generate_response,
-        inputs=input_box,
+        fn=process_input,
+        inputs=[input_box, mode_radio],
         outputs=output_box
     )
     
     clear_btn.click(
         fn=clear,
         inputs=[],
-        outputs=[input_box, output_box]
+        outputs=[input_box, output_box, mode_radio]
     )
 
 if __name__ == "__main__":