Update app.py

app.py

@@ -109,23 +109,24 @@ try:
             genai.types.FunctionDeclaration(
                 name='load_page',
                 description='Fetches the content of a specific web page URL as Markdown text. Use this when the user asks for information from a specific URL they provide, or when you need to look up live information mentioned alongside a specific source URL.',
-                # --- CORRECTED PARAMETERS STRUCTURE WITH STRING TYPES ---
+                # Use basic string types for schema definition
                 parameters={
-                    'type': 'object', # Use string 'object'
+                    'type': 'object',
                     'properties': {
                         'url': {
-                             'type': 'string', # Use string 'string'
+                             'type': 'string',
                              'description': "The *full* URL of the webpage to load (must start with http:// or https://)."
                         }
                     },
                     'required': ['url']
                 }
-                # --- END OF CORRECTION ---
             )
         ]
     )
-    # Code execution tool definition remains the same
-    code_execution_tool = genai.types.Tool(code_execution=genai.types.ToolCodeExecution())
+    # --- CORRECTED Code Execution Tool Definition ---
+    # Pass an empty dictionary to enable code execution capability
+    code_execution_tool = genai.types.Tool(code_execution={})
+    # --- END OF CORRECTION ---
 
     tools = [browse_tool, code_execution_tool]
 
@@ -197,22 +198,17 @@ def handle_function_call(function_call):
 
 def generate_response_with_tools(user_input, history_state):
     """Handles user input, interacts with Gemini (incl. tools), and manages history."""
-    # Check if model initialization failed earlier
     if not model:
-         # Return list format suitable for Gradio Chatbot display
          return [[None, "Error: The AI model (Gemini) could not be initialized. Please check the logs or API key configuration."]], history_state or []
 
     if not user_input.strip():
-        # Return tuple suitable for Gradio Chatbot display
         return [[None, "Please enter a valid query."]], history_state or []
 
     # --- History Management ---
     conversation_history = history_state if isinstance(history_state, list) else []
-    # Use genai.types for Content and Part
     conversation_history.append(genai.types.Content(role="user", parts=[genai.types.Part.from_text(user_input)]))
     print(f"\n--- Sending to Gemini (History length: {len(conversation_history)}) ---")
 
-    # Simple history trimming (can be made more sophisticated)
     MAX_HISTORY_TURNS = 10
     max_history_items = MAX_HISTORY_TURNS * 2 + (1 if conversation_history and conversation_history[0].role == "system" else 0)
     if len(conversation_history) > max_history_items:
@@ -225,9 +221,8 @@ def generate_response_with_tools(user_input, history_state):
     # --- Interaction Loop ---
     MAX_TOOL_LOOPS = 5
     loop_count = 0
-    # Work with a copy of history in the loop to easily revert on error
     current_history_for_api = list(conversation_history)
-    final_bot_message = "" # Initialize variable to hold the final message text
+    final_bot_message = ""
 
     try:
         while loop_count < MAX_TOOL_LOOPS:
@@ -236,7 +231,7 @@ def generate_response_with_tools(user_input, history_state):
 
             response = model.generate_content(
                 current_history_for_api,
-                request_options={"timeout": 120}, # Set a timeout for API calls
+                request_options={"timeout": 120},
             )
 
             if not response.candidates:
@@ -248,23 +243,18 @@ def generate_response_with_tools(user_input, history_state):
             candidate = response.candidates[0]
             finish_reason = candidate.finish_reason
 
-            # Append model's (potential) response to history *before* handling tools
-            # This ensures the model's thought process (including asking for tools) is recorded
             if candidate.content:
                 current_history_for_api.append(candidate.content)
 
-            # Check for non-stop, non-tool reasons first
             if finish_reason not in (genai.types.Candidate.FinishReason.STOP, genai.types.Candidate.FinishReason.TOOL_CALL):
                  print(f"Warning: Generation stopped unexpectedly. Reason: {finish_reason.name}")
                  stop_reason_msg = f"[Model stopped generating. Reason: {finish_reason.name}]"
                  partial_text = ""
-                 if candidate.content and candidate.content.parts: # Extract any partial text
+                 if candidate.content and candidate.content.parts:
                      partial_text = "".join([p.text for p in candidate.content.parts if hasattr(p, 'text') and p.text])
                  final_bot_message = (partial_text + "\n" if partial_text else "") + stop_reason_msg
-                 # History already has the partial content (if any) from the append above
-                 break # Exit loop
+                 break
 
-            # Check for Tool Call
             has_tool_call = finish_reason == genai.types.Candidate.FinishReason.TOOL_CALL
 
             if has_tool_call:
@@ -274,18 +264,15 @@ def generate_response_with_tools(user_input, history_state):
                      final_bot_message = "[Model indicated tool use but provided no details.]"
                      break
 
-                # Extract valid function calls
                 function_calls = [part.function_call for part in candidate.content.parts if hasattr(part, 'function_call') and part.function_call]
 
                 if not function_calls:
                      print("Warning: TOOL_CALL finish reason but no valid function_call part found.")
-                     # Extract any text response that might have come along
                      final_bot_message = "".join([p.text for p in candidate.content.parts if hasattr(p, 'text') and p.text])
                      if not final_bot_message:
                           final_bot_message = "[Model indicated tool use but provided no callable function or text.]"
                      break
 
-                # Execute tools and collect responses
                 tool_responses = []
                 for func_call in function_calls:
                      function_response_part = handle_function_call(func_call)
@@ -296,18 +283,15 @@ def generate_response_with_tools(user_input, history_state):
                      final_bot_message = "[Failed to process tool call request.]"
                      break
 
-                # Add the tool execution results to history for the next API call
                 current_history_for_api.append(genai.types.Content(role="tool", parts=tool_responses))
                 print("Added tool response(s) to history. Continuing loop...")
-                final_bot_message = "" # Reset final message as we are looping
-                continue # Go back to the start of the while loop
+                final_bot_message = ""
+                continue
 
             else: # FinishReason == STOP
                 print("No tool call requested. Final response received.")
-                # Extract final text and any code suggestions/results from the *last* model turn
                 final_bot_message = ""
                 code_parts_display = []
-                # Ensure we look at the last content which should be the final model response
                 if current_history_for_api and current_history_for_api[-1].role == "model":
                     last_model_content = current_history_for_api[-1]
                     if last_model_content.parts:
@@ -315,13 +299,12 @@ def generate_response_with_tools(user_input, history_state):
                             if hasattr(part, 'text') and part.text:
                                 final_bot_message += part.text
                             if hasattr(part, 'executable_code') and part.executable_code:
-                                lang = getattr(getattr(part.executable_code, 'language', None), 'name', 'python').lower() # Safe access
-                                code = getattr(part.executable_code, 'code', '') # Safe access
+                                lang = getattr(getattr(part.executable_code, 'language', None), 'name', 'python').lower()
+                                code = getattr(part.executable_code, 'code', '')
                                 code_parts_display.append(f"Suggested Code ({lang}):\n```{'python' if lang == 'unknown_language' else lang}\n{code}\n```")
                             elif hasattr(part, 'code_execution_result') and part.code_execution_result:
-                                # Safer access to outcome comparison value
                                 outcome_enum = getattr(genai.types, 'ExecutableCodeResponse', None)
-                                outcome_ok_val = getattr(outcome_enum.Outcome, 'OK', None) if outcome_enum and hasattr(outcome_enum, 'Outcome') else 1 # Default fallback
+                                outcome_ok_val = getattr(outcome_enum.Outcome, 'OK', None) if outcome_enum and hasattr(outcome_enum, 'Outcome') else 1
                                 outcome_val = getattr(part.code_execution_result, 'outcome', None)
                                 outcome_str = "Success" if outcome_val == outcome_ok_val else "Failure"
                                 output = getattr(part.code_execution_result, 'output', '')
@@ -332,22 +315,21 @@ def generate_response_with_tools(user_input, history_state):
 
                 if not final_bot_message.strip():
                      final_bot_message = "[Assistant completed its turn without generating text output.]"
-                     # Ensure this message is associated with the last model turn in history if needed
                      if current_history_for_api[-1].role == "model" and not any(hasattr(p,'text') and p.text for p in current_history_for_api[-1].parts):
+                          if not hasattr(current_history_for_api[-1], 'parts') or not current_history_for_api[-1].parts:
+                              current_history_for_api[-1].parts = [] # Initialize if needed
                           current_history_for_api[-1].parts.append(genai.types.Part.from_text(final_bot_message))
 
-                break # Exit the while loop (finish reason was STOP)
+                break
 
         # End of while loop
         if loop_count >= MAX_TOOL_LOOPS:
              print(f"Warning: Reached maximum tool execution loops ({MAX_TOOL_LOOPS}).")
              warning_msg = f"\n\n[Warning: Reached maximum tool execution loops ({MAX_TOOL_LOOPS}). The final response might be incomplete.]"
              final_bot_message += warning_msg
-             # Append warning to the last model message in history
              if current_history_for_api and current_history_for_api[-1].role == "model":
-                 # Check if parts list exists before appending
                  if not hasattr(current_history_for_api[-1], 'parts') or not current_history_for_api[-1].parts:
-                      current_history_for_api[-1].parts = [] # Initialize if needed
+                     current_history_for_api[-1].parts = []
                  current_history_for_api[-1].parts.append(genai.types.Part.from_text(warning_msg))
 
         print("--- Response Generation Complete ---")
@@ -355,11 +337,11 @@ def generate_response_with_tools(user_input, history_state):
         # --- Format final output for Gradio Chatbot ---
         chatbot_display_list = []
         user_msg_buffer = None
-        for content in current_history_for_api: # Use the final history
+        for content in current_history_for_api:
             if content.role == "system": continue
 
             display_text = ""
-            if hasattr(content, 'parts') and content.parts: # Ensure parts exists
+            if hasattr(content, 'parts') and content.parts:
                 for part in content.parts:
                     if hasattr(part, 'text') and part.text:
                         display_text += part.text + "\n"
@@ -368,9 +350,9 @@ def generate_response_with_tools(user_input, history_state):
                         code = getattr(part.executable_code, 'code', '')
                         display_text += f"\n```{'python' if lang == 'unknown_language' else lang}\n{code}\n```\n"
                     elif hasattr(part, 'code_execution_result') and part.code_execution_result:
-                        # Simplified display formatting
+                        outcome_enum = getattr(genai.types, 'ExecutableCodeResponse', None)
+                        outcome_ok_val = getattr(outcome_enum.Outcome, 'OK', None) if outcome_enum and hasattr(outcome_enum, 'Outcome') else 1
                         outcome_val = getattr(part.code_execution_result, 'outcome', None)
-                        outcome_ok_val = getattr(getattr(genai.types, 'ExecutableCodeResponse', {}).get('Outcome',{}), 'OK', 1)
                         outcome_str = "Success" if outcome_val == outcome_ok_val else "Failure"
                         output = getattr(part.code_execution_result, 'output', '')
                         display_text += f"\nCode Execution Result ({outcome_str}):\n```\n{output}\n```\n"
@@ -387,27 +369,23 @@ def generate_response_with_tools(user_input, history_state):
                     user_msg_buffer = None
                 else:
                     chatbot_display_list.append([None, display_text])
-            # Ignore 'tool' role messages for chat display
 
-        # If loop ended with user msg pending
         if user_msg_buffer is not None:
              chatbot_display_list.append([user_msg_buffer, None])
 
-        # Return the final display list and the complete history state
         return chatbot_display_list, current_history_for_api
 
     except Exception as e:
         print(f"ERROR during Gemini generation or tool processing: {str(e)}")
         traceback.print_exc()
         error_message = f"An error occurred: {str(e)}"
-        # Rebuild display history from the state *before* this turn failed + error message
         error_display_list = []
         if isinstance(history_state, list):
             temp_user_msg = None
-            for content in history_state: # Use the state *before* the error
+            for content in history_state:
                  if content.role == "system": continue
                  text = ""
-                 if hasattr(content, 'parts') and content.parts: # Check parts exists
+                 if hasattr(content, 'parts') and content.parts:
                      text = "".join([p.text for p in content.parts if hasattr(p, 'text')])
                  if content.role == "user": temp_user_msg = text
                  elif content.role == "model" and temp_user_msg:
@@ -416,10 +394,8 @@ def generate_response_with_tools(user_input, history_state):
                  elif content.role == "model": error_display_list.append([None, text])
             if temp_user_msg: error_display_list.append([temp_user_msg, None])
 
-        error_display_list.append([None, error_message]) # Add error message bubble
+        error_display_list.append([None, error_message])
 
-        # Return the history state *before* the failed turn started
-        # Make sure conversation_history exists and is a list before slicing
         previous_history = conversation_history[:-1] if isinstance(conversation_history, list) and conversation_history else []
         return error_display_list, previous_history
 
@@ -430,10 +406,9 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
     gr.Markdown(f"# 🚀 Gemini AI Assistant ({MODEL_NAME})")
     gr.Markdown("Ask questions, request info from specific URLs, or ask for code/calculations. Uses function calling and code execution.")
 
-    # Acknowledge Gradio warnings but keep tuple format for now
     chatbot_display = gr.Chatbot(
         label="Conversation",
-        bubble_full_width=False, # Keep param even if deprecated, avoids needing older Gradio
+        bubble_full_width=False,
         height=600,
         show_copy_button=True,
         render_markdown=True,
@@ -448,27 +423,26 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
         )
         with gr.Column(scale=1, min_width=150):
             send_btn = gr.Button("➡️ Send", variant="primary")
-            clear_btn = gr.ClearButton(value="🗑️ Clear Chat") # Will use custom function below
+            clear_btn = gr.ClearButton(value="🗑️ Clear Chat") # Uses custom clear_all below
 
     chat_history_state = gr.State([])
 
     def user_message_update(user_message, history_display_list):
-        """Appends the user's message to the display list (tuples format) and clears input."""
+        """Appends user message to display list and clears input."""
         if not user_message.strip():
              return gr.update(value=""), history_display_list
-        # Append as [user_msg, None] pair
         return gr.update(value=""), history_display_list + [[user_message, None]]
 
     def bot_response_update(history_display_list, history_state):
-        """Calls the backend Gemini function which returns updated display list and state."""
+        """Calls backend Gemini function and updates display/state."""
+        # Check if the last item in display list is a user message awaiting response
         if not history_display_list or (len(history_display_list[-1]) > 1 and history_display_list[-1][1] is not None):
             print("Bot update called without pending user message in display list.")
-            return history_display_list, history_state
+            return history_display_list, history_state # Return current state
 
         user_message = history_display_list[-1][0]
         print(f"User message being sent to backend: {user_message}")
 
-        # Backend now returns the *full* display list and the updated state
         updated_display_list, updated_history_state = generate_response_with_tools(user_message, history_state)
 
         return updated_display_list, updated_history_state
@@ -498,7 +472,7 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
 
     # Custom clear function to reset state as well
     def clear_all():
-         # Return values correspond to outputs=[msg_input, chatbot_display, chat_history_state]
+         # Returns values for outputs=[msg_input, chatbot_display, chat_history_state]
          return ["", None, []]
 
     # Wire clear button to the custom function
@@ -507,6 +481,6 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
 
 if __name__ == "__main__":
     print("Starting Gradio App...")
-    # Ensure queue is enabled for potentially long-running backend calls
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_error=True) # Add show_error=True for debugging
+    # show_error=True can be helpful for seeing Gradio errors in the browser console
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_error=True)
     print("Gradio App Stopped.")