prompt

app.py

@@ -23,6 +23,9 @@ SEARCH STRATEGY:
   2. If Wikipedia still doesn't help, try arxiv_search_tool for academic/research topics
   3. You can use multiple search attempts with different keywords to find better information
 - Always evaluate if the search results are relevant and sufficient before proceeding to your final answer
+- IMPORTANT: When you see [END_OF_SEARCH] in tool results, this means the search is complete and you have all available information
+- Do NOT perform additional searches after seeing [END_OF_SEARCH] - immediately proceed to analyze the provided information and give your final answer
+- The [END_OF_SEARCH] marker indicates you should stop searching and work with what you have
 
 RECURSION LIMIT HANDLING:
 - You have a maximum of 8 steps to complete your task

tools.py

@@ -43,101 +43,68 @@ def _download_file_for_task(task_id: str, ext: str) -> str:
 @tool
 def image_tool(task_id: str) -> str:
     """
-    Expects: task_id is a string
-    Returns: "OCR text + brief caption or an error message"
-      
+    Expects: task_id (str) — a valid image task ID.
+    Returns: image caption from Hugging Face API or error message.
     """
-    print(f"DEBUG: image_tool called with task_id: {task_id}")
-    
-    local_img = None  # Initialize the variable
-    
-    # Try to download image file with different extensions
+
+    import requests, os
+
+    # Try downloading image with one of the allowed extensions
     for ext in ("png", "jpg", "jpeg"):
-        print(f"DEBUG: Trying to download {task_id}.{ext}")
-        candidate = _download_file_for_task(task_id, ext)
-        if candidate:
-            local_img = candidate
-            print(f"DEBUG: Successfully downloaded image: {local_img}")
+        file_path = _download_file_for_task(task_id, ext)
+        if file_path and os.path.exists(file_path):
             break
-        else:
-            print(f"DEBUG: Failed to download {task_id}.{ext}")
-
-    if not local_img or not os.path.exists(local_img):
-        error_msg = f"Error: No image file found for task_id {task_id} (tried png, jpg, jpeg extensions)"
-        print(f"DEBUG: {error_msg}")
-        return error_msg
+    else:
+        return f"Error: Image file for task_id '{task_id}' not found."
 
-    # 2) Read raw bytes
+    # Read the image bytes
     try:
-        print(f"DEBUG: Reading image file: {local_img}")
-        with open(local_img, "rb") as f:
+        with open(file_path, "rb") as f:
             image_bytes = f.read()
-        print(f"DEBUG: Successfully read {len(image_bytes)} bytes from image")
     except Exception as e:
-        error_msg = f"Error reading image file: {e}"
-        print(f"DEBUG: {error_msg}")
-        return error_msg
+        return f"Error reading image: {str(e)}"
 
-    # 3) Prepare HF Inference headers
+    # Load HF token
     hf_token = os.getenv("HF_TOKEN")
     if not hf_token:
-        error_msg = "Error: HF_TOKEN not set in environment."
-        print(f"DEBUG: {error_msg}")
-        return error_msg
+        return "Error: HF_TOKEN not set in environment."
 
+    # Use a single reliable model
+    model = "Salesforce/blip-image-captioning-base"
     headers = {"Authorization": f"Bearer {hf_token}"}
-    print("DEBUG: HF token found, proceeding with API calls")
-
-    # Try different HF models for image analysis
-    models_to_try = [
-        "nlpconnect/vit-gpt2-image-captioning",
-        "Salesforce/blip-image-captioning-large", 
-        "microsoft/git-base-coco",
-        "microsoft/git-large-coco"
-    ]
-    
-    result_text = ""
-    success = False
-    
-    for model_name in models_to_try:
-        try:
-            print(f"DEBUG: Trying model: {model_name}")
-            resp = requests.post(
-                f"https://api-inference.huggingface.co/models/{model_name}",
-                headers=headers,
-                files={"file": image_bytes},
-                timeout=30
-            )
-            print(f"DEBUG: {model_name} response status: {resp.status_code}")
-            
-            if resp.status_code == 200:
-                resp_json = resp.json()
-                print(f"DEBUG: {model_name} response: {resp_json}")
-                
-                # Handle different response formats
-                if isinstance(resp_json, list) and len(resp_json) > 0:
-                    result_text = resp_json[0].get("generated_text", "").strip()
-                elif isinstance(resp_json, dict):
-                    result_text = resp_json.get("generated_text", "").strip()
-                
-                if result_text:
-                    print(f"DEBUG: Successfully got result from {model_name}: {result_text}")
-                    success = True
-                    break
-            else:
-                print(f"DEBUG: {model_name} failed with status {resp.status_code}")
-                
-        except Exception as e:
-            print(f"DEBUG: {model_name} failed with error: {e}")
-            continue
-    
-    if not success or not result_text:
-        result_text = "Unable to analyze image - all HuggingFace models failed or returned empty results"
-    
-    # Format the result
-    final_result = f"Image Analysis Result:\n{result_text}"
-    print(f"DEBUG: Final result: {final_result}")
-    return final_result
+
+    try:
+        response = requests.post(
+            f"https://api-inference.huggingface.co/models/{model}",
+            headers=headers,
+            files={"file": image_bytes},
+            timeout=30
+        )
+    except Exception as e:
+        return f"Error calling HuggingFace API: {e}"
+
+    # Parse response
+    if response.status_code != 200:
+        return f"Error from model ({model}): {response.status_code} - {response.text}"
+
+    try:
+        result = response.json()
+        if isinstance(result, list) and result:
+            caption = result[0].get("generated_text", "").strip()
+        elif isinstance(result, dict):
+            caption = result.get("generated_text", "").strip()
+        else:
+            caption = ""
+    except Exception as e:
+        return f"Error parsing response: {e}"
+
+    if not caption:
+        return "No caption generated by model."
+
+    return f"Image Caption:\n{caption}"
+
+
+
 
 @tool
 def excel_tool(task_id: str) -> str:
@@ -227,7 +194,7 @@ def wikipedia_search_tool(wiki_query: str) -> str:
     """
     print(f"DEBUG: reached wikipedia_search_tool with query: {wiki_query}")
     try:
-        docs = WikipediaLoader(query=wiki_query, load_max_docs=2).load()
+        docs = WikipediaLoader(query=wiki_query, load_max_docs=3).load()  # Reduced from 5 to 3
         print(f"DEBUG: WikipediaLoader returned {len(docs)} documents")
         
         result = ""
@@ -255,19 +222,28 @@ def wikipedia_search_tool(wiki_query: str) -> str:
             
             print(f"DEBUG: Using Wikipedia title: {title}")
             
-            # Truncate content if too long
-            content = doc.page_content[:2000] if len(doc.page_content) > 2000 else doc.page_content
-            result += f"\n\nDocument{counter}: {title}\n{content}"
+            # Trim content to key information only (reduced from 2000 to 800 characters)
+            content = doc.page_content[:800] if len(doc.page_content) > 800 else doc.page_content
+            
+            # Add document but keep it concise
+            result += f"\n\nWikipedia Result {counter}: {title}\nSummary: {content}..."
             counter += 1
+            
+            # Stop after 2 documents to keep response manageable
+            if counter > 2:
+                break
         
         if not result.strip():
-            return "No Wikipedia results found for the given query"
+            return "No Wikipedia results found for the given query. [END_OF_SEARCH]"
+        
+        # Add clear end marker
+        result += "\n\n[END_OF_SEARCH] - Wikipedia search complete. Use this information to answer the question."
         
         print(f"DEBUG: Final Wikipedia result length: {len(result)}")
         return result
         
     except Exception as e:
-        error_msg = f"Error during Wikipedia search: {str(e)}"
+        error_msg = f"Error during Wikipedia search: {str(e)} [END_OF_SEARCH]"
         print(f"DEBUG: {error_msg}")
         return error_msg
     
@@ -280,7 +256,7 @@ def arxiv_search_tool(arxiv_query: str) -> str:
     """
     print(f"DEBUG: reached arxiv_search_tool with query: {arxiv_query}")
     try:
-        docs = ArxivLoader(query=arxiv_query, load_max_docs=2).load()
+        docs = ArxivLoader(query=arxiv_query, load_max_docs=3).load()  # Reduced from 5 to 3
         print(f"DEBUG: ArxivLoader returned {len(docs)} documents")
         
         result = ""
@@ -310,19 +286,28 @@ def arxiv_search_tool(arxiv_query: str) -> str:
             
             print(f"DEBUG: Using title: {title}")
             
-            # Truncate content if too long
-            content = doc.page_content[:2000] if len(doc.page_content) > 2000 else doc.page_content
-            result += f"\n\nDocument{counter}: {title}\n{content}"
+            # Trim content to key information only (reduced from 2000 to 800 characters)
+            content = doc.page_content[:800] if len(doc.page_content) > 800 else doc.page_content
+            
+            # Add document but keep it concise
+            result += f"\n\nArXiv Result {counter}: {title}\nAbstract/Summary: {content}..."
             counter += 1
+            
+            # Stop after 2 documents to keep response manageable
+            if counter > 2:
+                break
         
         if not result.strip():
-            return "No ArXiv results found for the given query"
+            return "No ArXiv results found for the given query. [END_OF_SEARCH]"
+        
+        # Add clear end marker
+        result += "\n\n[END_OF_SEARCH] - ArXiv search complete. Use this information to answer the question."
         
         print(f"DEBUG: Final ArXiv result length: {len(result)}")
         return result
         
     except Exception as e:
-        error_msg = f"Error during Arxiv search: {str(e)}"
+        error_msg = f"Error during Arxiv search: {str(e)} [END_OF_SEARCH]"
         print(f"DEBUG: {error_msg}")
         return error_msg