Update app.py

app.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 import os
 import gradio as gr
-# Corrected import: Import the main module and use an alias
+# Import the main module and use an alias
 import google.generativeai as genai
-# Types will be accessed via genai.types
+# Core types like Content/Part are accessed directly via 'genai'
+# Other types like Tool, FunctionDeclaration are under genai.types
 
 import requests
 import markdownify
@@ -103,13 +104,12 @@ try:
     MODEL_NAME = "gemini-2.5-pro-exp-03-25"
     print(f"Attempting to use EXPERIMENTAL model: {MODEL_NAME}")
 
-    # Define tools using genai.types
+    # Use genai.types for Tool, FunctionDeclaration etc.
     browse_tool = genai.types.Tool(
         function_declarations=[
             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.',
-                # Use basic string types for schema definition
                 parameters={
                     'type': 'object',
                     'properties': {
@@ -123,16 +123,15 @@ try:
             )
         ]
     )
-    # --- CORRECTED Code Execution Tool Definition ---
-    # Pass an empty dictionary to enable code execution capability
+    # Use genai.types.Tool, enable code execution with {}
     code_execution_tool = genai.types.Tool(code_execution={})
-    # --- END OF CORRECTION ---
 
     tools = [browse_tool, code_execution_tool]
 
     model = genai.GenerativeModel(
         model_name=MODEL_NAME,
         tools=tools,
+        # Use genai.types for HarmCategory and HarmBlockThreshold
         safety_settings={
              genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT: genai.types.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
              genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH: genai.types.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
@@ -146,7 +145,6 @@ try:
 except Exception as e:
     print(f"CRITICAL ERROR: Error initializing Gemini client: {e}")
     traceback.print_exc()
-    # Set model to None so the app can report initialization failure
     model = None
     tools = []
 
@@ -156,7 +154,7 @@ except Exception as e:
 def handle_function_call(function_call):
     """Executes the function call requested by the model."""
     function_name = function_call.name
-    args = function_call.args # Dict-like object
+    args = function_call.args
 
     print(f"Executing Function Call: {function_name} with args: {dict(args)}")
 
@@ -165,7 +163,7 @@ def handle_function_call(function_call):
             url = args.get('url')
             if url:
                 function_response_content = load_page(url=url)
-                MAX_RESPONSE_LEN = 50000 # Limit response size
+                MAX_RESPONSE_LEN = 50000
                 if len(function_response_content) > MAX_RESPONSE_LEN:
                     print(f"Tool Response truncated from {len(function_response_content)} to {MAX_RESPONSE_LEN} chars.")
                     function_response_content = function_response_content[:MAX_RESPONSE_LEN] + "\n\n[... Tool Response Truncated Due to Size Limit ...]"
@@ -175,11 +173,11 @@ def handle_function_call(function_call):
             print(f"Error: Received call for unknown function '{function_name}'")
             function_response_content = f"Error: Unknown function '{function_name}' called by the model."
 
-        # Use genai.types for FunctionResponse and Part
-        function_response_part = genai.types.Part(
+        # *** CORRECTED: Use genai.Part and genai.types.FunctionResponse ***
+        function_response_part = genai.Part(
             function_response=genai.types.FunctionResponse(
                 name=function_name,
-                response={'content': function_response_content} # Response must be a dict
+                response={'content': function_response_content}
             )
         )
         print(f"Function Response generated for {function_name}")
@@ -188,8 +186,8 @@ def handle_function_call(function_call):
     except Exception as e:
          print(f"Error during execution of function '{function_name}': {e}")
          traceback.print_exc()
-         # Use genai.types here too, return error details in the response dict
-         return genai.types.Part(
+         # *** CORRECTED: Use genai.Part and genai.types.FunctionResponse ***
+         return genai.Part(
              function_response=genai.types.FunctionResponse(
                  name=function_name,
                  response={'error': f"Failed to execute function {function_name}: {str(e)}"}
@@ -206,7 +204,8 @@ def generate_response_with_tools(user_input, history_state):
 
     # --- History Management ---
     conversation_history = history_state if isinstance(history_state, list) else []
-    conversation_history.append(genai.types.Content(role="user", parts=[genai.types.Part.from_text(user_input)]))
+    # *** CORRECTED: Use genai.Content and genai.Part ***
+    conversation_history.append(genai.Content(role="user", parts=[genai.Part.from_text(user_input)]))
     print(f"\n--- Sending to Gemini (History length: {len(conversation_history)}) ---")
 
     MAX_HISTORY_TURNS = 10
@@ -237,15 +236,19 @@ def generate_response_with_tools(user_input, history_state):
             if not response.candidates:
                  print("Warning: No candidates received from Gemini.")
                  final_bot_message = "[No response generated by the model.]"
-                 current_history_for_api.append(genai.types.Content(role="model", parts=[genai.types.Part.from_text(final_bot_message)]))
+                 # *** CORRECTED: Use genai.Content and genai.Part ***
+                 current_history_for_api.append(genai.Content(role="model", parts=[genai.Part.from_text(final_bot_message)]))
                  break
 
             candidate = response.candidates[0]
+            # Use genai.types for Candidate fields
             finish_reason = candidate.finish_reason
 
+            # Append model's response (Content object) to history
             if candidate.content:
-                current_history_for_api.append(candidate.content)
+                current_history_for_api.append(candidate.content) # content should already be a genai.Content object
 
+            # Check finish reason using genai.types.Candidate
             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}]"
@@ -255,10 +258,12 @@ def generate_response_with_tools(user_input, history_state):
                  final_bot_message = (partial_text + "\n" if partial_text else "") + stop_reason_msg
                  break
 
+            # Use genai.types.Candidate for comparison
             has_tool_call = finish_reason == genai.types.Candidate.FinishReason.TOOL_CALL
 
             if has_tool_call:
                 print("Tool call requested by model.")
+                # Model response (genai.Content obj) is already appended above
                 if not candidate.content or not candidate.content.parts:
                      print("Error: TOOL_CALL indicated but candidate content/parts is missing.")
                      final_bot_message = "[Model indicated tool use but provided no details.]"
@@ -275,6 +280,7 @@ def generate_response_with_tools(user_input, history_state):
 
                 tool_responses = []
                 for func_call in function_calls:
+                     # handle_function_call now returns a genai.Part object
                      function_response_part = handle_function_call(func_call)
                      tool_responses.append(function_response_part)
 
@@ -283,7 +289,8 @@ def generate_response_with_tools(user_input, history_state):
                      final_bot_message = "[Failed to process tool call request.]"
                      break
 
-                current_history_for_api.append(genai.types.Content(role="tool", parts=tool_responses))
+                # Add tool responses to history using genai.Content
+                current_history_for_api.append(genai.Content(role="tool", parts=tool_responses)) # parts expects list of genai.Part
                 print("Added tool response(s) to history. Continuing loop...")
                 final_bot_message = ""
                 continue
@@ -292,10 +299,11 @@ def generate_response_with_tools(user_input, history_state):
                 print("No tool call requested. Final response received.")
                 final_bot_message = ""
                 code_parts_display = []
+                # Extract text/code from the last model turn (genai.Content object) in history
                 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:
-                        for part in last_model_content.parts:
+                        for part in last_model_content.parts: # part is already a genai.Part object
                             if hasattr(part, 'text') and part.text:
                                 final_bot_message += part.text
                             if hasattr(part, 'executable_code') and part.executable_code:
@@ -303,6 +311,7 @@ def generate_response_with_tools(user_input, history_state):
                                 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:
+                                # outcome check uses genai.types
                                 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)
@@ -315,11 +324,12 @@ 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.]"
+                     # Add this as a text Part to the last model Content object if it was otherwise empty
                      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))
-
+                              current_history_for_api[-1].parts = []
+                          # *** CORRECTED: Use genai.Part ***
+                          current_history_for_api[-1].parts.append(genai.Part.from_text(final_bot_message))
                 break
 
         # End of while loop
@@ -327,22 +337,25 @@ def generate_response_with_tools(user_input, history_state):
              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 as a genai.Part to the last model message
              if current_history_for_api and current_history_for_api[-1].role == "model":
                  if not hasattr(current_history_for_api[-1], 'parts') or not current_history_for_api[-1].parts:
                      current_history_for_api[-1].parts = []
-                 current_history_for_api[-1].parts.append(genai.types.Part.from_text(warning_msg))
+                 # *** CORRECTED: Use genai.Part ***
+                 current_history_for_api[-1].parts.append(genai.Part.from_text(warning_msg))
 
         print("--- Response Generation Complete ---")
 
         # --- Format final output for Gradio Chatbot ---
         chatbot_display_list = []
         user_msg_buffer = None
-        for content in current_history_for_api:
+        for content in current_history_for_api: # content is genai.Content object
             if content.role == "system": continue
 
             display_text = ""
             if hasattr(content, 'parts') and content.parts:
-                for part in content.parts:
+                for part in content.parts: # part is genai.Part object
+                    # Extract text for display, format code etc.
                     if hasattr(part, 'text') and part.text:
                         display_text += part.text + "\n"
                     elif hasattr(part, 'executable_code') and part.executable_code:
@@ -350,6 +363,7 @@ 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:
+                         # outcome check uses genai.types
                         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)
@@ -369,6 +383,7 @@ 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 user_msg_buffer is not None:
              chatbot_display_list.append([user_msg_buffer, None])
@@ -380,12 +395,14 @@ def generate_response_with_tools(user_input, history_state):
         traceback.print_exc()
         error_message = f"An error occurred: {str(e)}"
         error_display_list = []
+        # Rebuild display from previous state (history_state)
         if isinstance(history_state, list):
             temp_user_msg = None
-            for content in history_state:
+            for content in history_state: # content is genai.Content
                  if content.role == "system": continue
                  text = ""
                  if hasattr(content, 'parts') and content.parts:
+                     # parts contains genai.Part objects
                      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:
@@ -396,6 +413,7 @@ def generate_response_with_tools(user_input, history_state):
 
         error_display_list.append([None, error_message])
 
+        # Revert to history *before* this failed turn
         previous_history = conversation_history[:-1] if isinstance(conversation_history, list) and conversation_history else []
         return error_display_list, previous_history
 
@@ -408,7 +426,7 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
 
     chatbot_display = gr.Chatbot(
         label="Conversation",
-        bubble_full_width=False,
+        bubble_full_width=False, # Keep param even if deprecated
         height=600,
         show_copy_button=True,
         render_markdown=True,
@@ -423,8 +441,9 @@ 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") # Uses custom clear_all below
+            clear_btn = gr.ClearButton(value="🗑️ Clear Chat")
 
+    # State stores list of genai.Content objects
     chat_history_state = gr.State([])
 
     def user_message_update(user_message, history_display_list):
@@ -435,10 +454,9 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
 
     def bot_response_update(history_display_list, history_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 current state
+            return history_display_list, history_state
 
         user_message = history_display_list[-1][0]
         print(f"User message being sent to backend: {user_message}")
@@ -455,8 +473,8 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
         queue=False,
     ).then(
         bot_response_update,
-        [chatbot_display, chat_history_state],
-        [chatbot_display, chat_history_state]
+        [chatbot_display, chat_history_state], # Pass display list and history state
+        [chatbot_display, chat_history_state]  # Receive updated display list and state
     )
 
     send_btn.click(
@@ -470,17 +488,14 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
         [chatbot_display, chat_history_state]
     )
 
-    # Custom clear function to reset state as well
+    # Custom clear function resets state
     def clear_all():
-         # Returns values for outputs=[msg_input, chatbot_display, chat_history_state]
          return ["", None, []]
 
-    # Wire clear button to the custom function
     clear_btn.click(clear_all, [], [msg_input, chatbot_display, chat_history_state], queue=False)
 
 
 if __name__ == "__main__":
     print("Starting Gradio App...")
-    # 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.")