Update app.py

app.py

@@ -109,12 +109,12 @@ 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 ---
-                parameters={  # Directly define the schema as a dictionary
-                    'type': genai.types.Type.OBJECT,
+                # --- CORRECTED PARAMETERS STRUCTURE WITH STRING TYPES ---
+                parameters={
+                    'type': 'object', # Use string 'object'
                     'properties': {
-                        'url': { # The 'url' parameter definition is also a dictionary
-                             'type': genai.types.Type.STRING,
+                        'url': {
+                             'type': 'string', # Use string 'string'
                              'description': "The *full* URL of the webpage to load (must start with http:// or https://)."
                         }
                     },
@@ -124,7 +124,7 @@ try:
             )
         ]
     )
-    # Assuming ToolCodeExecution is simplified access, remains the same
+    # Code execution tool definition remains the same
     code_execution_tool = genai.types.Tool(code_execution=genai.types.ToolCodeExecution())
 
     tools = [browse_tool, code_execution_tool]
@@ -252,9 +252,6 @@ def generate_response_with_tools(user_input, history_state):
             # This ensures the model's thought process (including asking for tools) is recorded
             if candidate.content:
                 current_history_for_api.append(candidate.content)
-            # elif finish_reason != genai.types.Candidate.FinishReason.STOP: # Handle cases where content might be missing but expected
-            #     print(f"Warning: Candidate content is missing, finish reason: {finish_reason.name}")
-
 
             # Check for non-stop, non-tool reasons first
             if finish_reason not in (genai.types.Candidate.FinishReason.STOP, genai.types.Candidate.FinishReason.TOOL_CALL):
@@ -275,8 +272,6 @@ def generate_response_with_tools(user_input, history_state):
                 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.]"
-                     # Append error message as model turn?
-                     # current_history_for_api.append(genai.types.Content(role="model", parts=[genai.types.Part.from_text(final_bot_message)]))
                      break
 
                 # Extract valid function calls
@@ -288,7 +283,6 @@ def generate_response_with_tools(user_input, history_state):
                      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.]"
-                     # Model turn (with text if any) is already in history.
                      break
 
                 # Execute tools and collect responses
@@ -300,7 +294,6 @@ def generate_response_with_tools(user_input, history_state):
                 if not tool_responses:
                      print("Warning: No valid tool responses generated despite TOOL_CALL.")
                      final_bot_message = "[Failed to process tool call request.]"
-                     # Decide if to append this message. History has model asking for tool.
                      break
 
                 # Add the tool execution results to history for the next API call
@@ -312,9 +305,9 @@ def generate_response_with_tools(user_input, history_state):
             else: # FinishReason == STOP
                 print("No tool call requested. Final response received.")
                 # Extract final text and any code suggestions/results from the *last* model turn
-                # (which we added to history before the check)
                 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:
@@ -326,11 +319,11 @@ def generate_response_with_tools(user_input, history_state):
                                 code = getattr(part.executable_code, 'code', '') # Safe access
                                 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_ok = getattr(genai.types, 'ExecutableCodeResponse', None) # Safe access to type
-                                outcome_ok = getattr(outcome_ok, 'Outcome', None) if outcome_ok else None # Safe access to enum
-                                outcome_ok = getattr(outcome_ok, 'OK', 1) if outcome_ok else 1 # Safe access to value, fallback
+                                # 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_val = getattr(part.code_execution_result, 'outcome', None)
-                                outcome_str = "Success" if outcome_val == outcome_ok else "Failure"
+                                outcome_str = "Success" if outcome_val == outcome_ok_val else "Failure"
                                 output = getattr(part.code_execution_result, 'output', '')
                                 code_parts_display.append(f"Code Execution Result ({outcome_str}):\n```\n{output}\n```")
 
@@ -343,7 +336,6 @@ def generate_response_with_tools(user_input, history_state):
                      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):
                           current_history_for_api[-1].parts.append(genai.types.Part.from_text(final_bot_message))
 
-
                 break # Exit the while loop (finish reason was STOP)
 
         # End of while loop
@@ -353,10 +345,10 @@ def generate_response_with_tools(user_input, history_state):
              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.append(genai.types.Part.from_text(warning_msg))
-             # elif current_history_for_api: # If last turn wasn't model (e.g. tool), add new model msg
-             #      current_history_for_api.append(genai.types.Content(role="model", parts=[genai.types.Part.from_text(warning_msg)]))
-
 
         print("--- Response Generation Complete ---")
 
@@ -367,39 +359,37 @@ def generate_response_with_tools(user_input, history_state):
             if content.role == "system": continue
 
             display_text = ""
-            if content.parts:
+            if hasattr(content, 'parts') and content.parts: # Ensure parts exists
                 for part in content.parts:
-                    # Simplified text extraction for display - assumes primary output is text
                     if hasattr(part, 'text') and part.text:
                         display_text += part.text + "\n"
-                    # Optionally add code block formatting here if needed for display
                     elif hasattr(part, 'executable_code') and part.executable_code:
                         lang = getattr(getattr(part.executable_code, 'language', None), 'name', 'python').lower()
                         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_ok = getattr(genai.types, 'ExecutableCodeResponse', {}).get('Outcome', {}).get('OK', 1)
+                        # Simplified display formatting
                         outcome_val = getattr(part.code_execution_result, 'outcome', None)
-                        outcome_str = "Success" if outcome_val == outcome_ok else "Failure"
+                        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"
 
             display_text = display_text.strip()
 
-            if not display_text and content.role not in ["tool"]: continue # Skip empty non-tool turns
+            if not display_text and content.role not in ["tool"]: continue
 
             if content.role == "user":
                 user_msg_buffer = display_text
             elif content.role == "model":
                 if user_msg_buffer is not None:
-                    chatbot_display_list.append([user_msg_buffer, display_text or "[Processing...]"]) # Add model response text
-                    user_msg_buffer = None # Clear buffer
+                    chatbot_display_list.append([user_msg_buffer, display_text or "[Processing...]"])
+                    user_msg_buffer = None
                 else:
-                    # Consecutive model messages or initial message
                     chatbot_display_list.append([None, display_text])
             # Ignore 'tool' role messages for chat display
 
-        # If loop ended with user msg pending (e.g., error right after user input)
+        # If loop ended with user msg pending
         if user_msg_buffer is not None:
              chatbot_display_list.append([user_msg_buffer, None])
 
@@ -416,7 +406,9 @@ def generate_response_with_tools(user_input, history_state):
             temp_user_msg = None
             for content in history_state: # Use the state *before* the error
                  if content.role == "system": continue
-                 text = "".join([p.text for p in content.parts if hasattr(p, 'text')])
+                 text = ""
+                 if hasattr(content, 'parts') and content.parts: # Check parts exists
+                     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:
                       error_display_list.append([temp_user_msg, text])
@@ -427,7 +419,9 @@ def generate_response_with_tools(user_input, history_state):
         error_display_list.append([None, error_message]) # Add error message bubble
 
         # Return the history state *before* the failed turn started
-        return error_display_list, conversation_history[:-1] # Revert state
+        # 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
 
 
 # --- Gradio Interface ---
@@ -436,17 +430,13 @@ 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.")
 
-    # Note: The UserWarning about 'tuples' format is a Gradio warning.
-    # While 'messages' format is preferred long-term, 'tuples' still works.
-    # Changing would require refactoring the bot_response_update function's return value.
-    # For now, we acknowledge the warning but keep the 'tuples' format as implemented.
+    # Acknowledge Gradio warnings but keep tuple format for now
     chatbot_display = gr.Chatbot(
         label="Conversation",
-        bubble_full_width=False,
+        bubble_full_width=False, # Keep param even if deprecated, avoids needing older Gradio
         height=600,
         show_copy_button=True,
         render_markdown=True,
-        # type='messages' # Would require backend functions to return list-of-dicts
     )
 
     with gr.Row():
@@ -458,8 +448,7 @@ 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")
-            # ClearButton setup remains the same, targeting state via custom function
-            clear_btn = gr.ClearButton(value="🗑️ Clear Chat")
+            clear_btn = gr.ClearButton(value="🗑️ Clear Chat") # Will use custom function below
 
     chat_history_state = gr.State([])
 
@@ -472,9 +461,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 the backend Gemini function which returns updated display list and state."""
-        if not history_display_list or history_display_list[-1][1] is not None:
+        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 if no pending message
+            return history_display_list, history_state
 
         user_message = history_display_list[-1][0]
         print(f"User message being sent to backend: {user_message}")
@@ -488,12 +477,12 @@ with gr.Blocks(title="Gemini AI Assistant w/ Tools", theme=gr.themes.Soft()) as
     msg_input.submit(
         user_message_update,
         [msg_input, chatbot_display],
-        [msg_input, chatbot_display], # Output updates input textbox and chatbot display
-        queue=False, # Run UI update immediately
+        [msg_input, chatbot_display],
+        queue=False,
     ).then(
         bot_response_update,
-        [chatbot_display, chat_history_state], # Inputs: current display list, current state
-        [chatbot_display, chat_history_state]  # Outputs: new display list, new state
+        [chatbot_display, chat_history_state],
+        [chatbot_display, chat_history_state]
     )
 
     send_btn.click(
@@ -509,13 +498,15 @@ 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 ["", None, []] # Clears Textbox, Chatbot display, State
+         # Return values correspond to 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...")
     # Ensure queue is enabled for potentially long-running backend calls
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860)
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_error=True) # Add show_error=True for debugging
     print("Gradio App Stopped.")