Update app.py

app.py

@@ -22,51 +22,9 @@ app = Flask(__name__)
 # For persistent history, a database (like Firestore) is required.
 conversation_histories = {}
 
-async def call_google_search_tool(query):
-    """
-    Calls the internal google_search tool provided by the environment.
-    """
-    print(f"Calling google_search tool for query: {query}")
-    search_payload = {
-        "queries": [query]
-    }
-    # This endpoint is specific to the Canvas/Hugging Face environment where tools are exposed
-    # If running locally, you would need to replace this with an actual Google Search API call
-    # (e.g., Google Custom Search API) and handle its API key.
-    try:
-        search_response = requests.post(
-            'http://localhost:8000/api/google_search', # This URL is for the Canvas environment's tool access
-            headers={'Content-Type': 'application/json'},
-            data=json.dumps(search_payload)
-        )
-        search_response.raise_for_status()
-        search_result = search_response.json()
-        print("Google Search results received.")
-
-        context = ""
-        if search_result.get('results'):
-            for query_result in search_result['results']:
-                if query_result.get('results'):
-                    for item_index, item in enumerate(query_result['results']):
-                        if item.get('snippet'):
-                            context += f"[Source {item_index + 1}] {item['snippet']}\n"
-                            if len(context) > 2000: # Limit context length to avoid excessively long prompts
-                                context += "...\n"
-                                break
-                    if len(context) > 2000:
-                        break
-        return context
-    except requests.exceptions.RequestException as e:
-        print(f"Error calling google_search tool: {e}")
-        return f"Error retrieving information from search: {e}"
-    except Exception as e:
-        print(f"Unexpected error in google_search tool call: {e}")
-        return f"An unexpected error occurred during search: {e}"
-
-
 async def generate_solution_python(chat_history):
     """
-    Generates a solution using Google Search for context and Gemini LLM,
+    Generates a solution using a dummy context and Gemini LLM,
     based on the provided chat history which can include text, images, and extracted PDF text.
 
     Args:
@@ -84,47 +42,38 @@ async def generate_solution_python(chat_history):
     response_text = ""
 
     try:
-        # Extract the latest user query from chat history for Google Search
-        latest_user_query = ""
+        # --- IMPORTANT: Placeholder for Search API Integration ---
+        # The 'google_search' tool is specific to the Canvas environment.
+        # On Hugging Face, you would integrate a real public search API here.
+        # For this example, we'll use a dummy context based on the latest user query.
+
+        # Find the latest user input (text or image/document indication) for dummy context
+        latest_user_input = ""
         for message in reversed(chat_history):
             if message["role"] == "user" and message["parts"]:
                 for part in message["parts"]:
                     if part.get("text"):
-                        latest_user_query = part["text"]
-                        break # Found the latest text query
-            if latest_user_query:
+                        latest_user_input = part["text"]
+                        break
+                    if part.get("inlineData") and "image" in part["inlineData"].get("mimeType", ""):
+                        latest_user_input = "an image"
+                        break
+                    # If a document was processed and its text added, use that
+                    if part.get("text") and part["text"].startswith("PDF Document Content:") or part["text"].startswith("Document content:"):
+                        latest_user_input = "a document"
+                        break
+            if latest_user_input:
                 break
 
-        # --- Google Search Integration Point ---
-        search_context = ""
-        if latest_user_query:
-            search_context = await call_google_search_tool(latest_user_query)
-            if search_context and not search_context.startswith("Error"):
-                search_context = "\n\nRelevant Information from Web Search:\n" + search_context
-            else:
-                search_context = f"\n\nCould not retrieve web search results: {search_context}"
-
-
-        # Construct the final `contents` list for the LLM call.
-        # We'll prepend the search context to the latest user message.
-        augmented_chat_contents = []
-        for i, message in enumerate(chat_history):
-            if i == len(chat_history) - 1 and message["role"] == "user": # Last user message
-                augmented_parts = []
-                if search_context:
-                    augmented_parts.append({"text": search_context})
-                for part in message["parts"]:
-                    augmented_parts.append(part)
-                augmented_chat_contents.append({"role": "user", "parts": augmented_parts})
-            else:
-                augmented_chat_contents.append(message)
-
-        # Step 2: Call Gemini API with the augmented chat history
-        print("Calling Gemini API with augmented chat history...")
+        dummy_context = f"Information related to '{latest_user_input}' from various online sources indicates that..."
+        
+        # Step 2: Call Gemini API with the full chat history
+        print("Calling Gemini API with full chat history...")
         llm_payload = {
-            "contents": augmented_chat_contents # Pass the augmented history
+            "contents": chat_history # Pass the entire history, including text and image parts
         }
 
+        # Get API key from environment variables (Hugging Face Space Secrets)
         gemini_api_key = os.environ.get("GEMINI_API_KEY") 
         if not gemini_api_key:
             raise ValueError("GEMINI_API_KEY environment variable not set.")
@@ -137,7 +86,7 @@ async def generate_solution_python(chat_history):
             data=json.dumps(llm_payload)
         )
 
-        gemini_response.raise_for_status()
+        gemini_response.raise_for_status() # Raise an exception for HTTP errors
         llm_result = gemini_response.json()
         print("Gemini API response received.")
 
@@ -173,7 +122,7 @@ def index():
 @app.route('/generate', methods=['POST'])
 async def generate():
     """Handles the AI generation request, managing conversation history and multi-modal input."""
-    session_id = None
+    session_id = None # Initialize session_id to None
     try:
         data = request.get_json()
         if not data:
@@ -184,6 +133,7 @@ async def generate():
         document_text = data.get('document_text') # Text extracted from .txt on frontend
         pdf_data = data.get('pdf_data') # Base64 PDF data
         
+        # Ensure session_id is assigned before use
         session_id = data.get('session_id')
         if not session_id:
             session_id = str(uuid.uuid4())
@@ -194,6 +144,7 @@ async def generate():
         
         current_chat_history = conversation_histories.get(session_id, [])
         
+        # Construct the parts for the user message
         user_message_parts = []
         if user_query:
             user_message_parts.append({"text": user_query})
@@ -211,6 +162,7 @@ async def generate():
                 return jsonify({"error": "PDF parsing library (PyPDF2) not installed on backend."}), 500
             
             try:
+                # Decode base64 PDF data
                 pdf_bytes = base64.b64decode(pdf_data['data'])
                 pdf_file = io.BytesIO(pdf_bytes)
                 reader = PdfReader(pdf_file)
@@ -218,7 +170,7 @@ async def generate():
                 pdf_extracted_text = ""
                 for page_num in range(len(reader.pages)):
                     page = reader.pages[page_num]
-                    pdf_extracted_text += page.extract_text() or ""
+                    pdf_extracted_text += page.extract_text() or "" # extract_text can return None
                 
                 if pdf_extracted_text.strip():
                     user_message_parts.append({"text": f"PDF Document Content:\n{pdf_extracted_text}"})
@@ -230,6 +182,9 @@ async def generate():
             except Exception as pdf_error:
                 print(f"Error processing PDF: {pdf_error}")
                 user_message_parts.append({"text": f"PDF Document: (Error processing PDF: {pdf_error})"})
+                # Do not return error to frontend immediately for PDF processing issues
+                # Let the LLM try to respond even if PDF extraction failed
+                # return jsonify({"error": f"Failed to process PDF: {pdf_error}"}), 400 
 
         # If only a file was provided without a query, add a default instruction
         if not user_query and (image_data or document_text or pdf_data):
@@ -238,18 +193,23 @@ async def generate():
             elif document_text or pdf_data:
                 user_message_parts.insert(0, {"text": "Please analyze the following document content and provide a summary or answer questions:"})
 
+        # Append the new user message (which can be multi-part) to the history
         current_chat_history.append({"role": "user", "parts": user_message_parts})
 
+        # Generate the solution using the full chat history
         solution_text = await generate_solution_python(current_chat_history)
 
+        # Append the model's response to the history
         current_chat_history.append({"role": "model", "parts": [{"text": solution_text}]})
         
+        # Store the updated history
         conversation_histories[session_id] = current_chat_history
 
         return jsonify({"solution": solution_text, "session_id": session_id})
 
     except Exception as e:
         print(f"Error in /generate endpoint: {e}")
+        # Ensure session_id is handled even in the outer exception for logging/debugging
         if session_id:
             return jsonify({"error": f"Internal server error for session {session_id}: {e}"}), 500
         else: