handling of duplicate calls for tools

agent.py

@@ -23,7 +23,10 @@ class TeacherStudentAgentWorkflow:
             description="Useful for searching the web for information on a given topic and recording notes on the topic.",
             system_prompt=(
                 "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. "
-                "Once notes are recorded and you are satisfied, you should hand off control to the WriteAgent to write a report on the topic. "
+                "IMPORTANT: Never make duplicate tool calls. Each tool call should be unique and purposeful. "
+                "Process: 1) Search for information ONCE with a clear query, 2) Record the notes ONCE with a descriptive title, "
+                "3) Only search again if you need different/additional information with a different query. "
+                "Once you have sufficient notes recorded, immediately hand off control to the WriteAgent. "
                 "You should have at least some notes on a topic before handing off control to the WriteAgent."
             ),
             llm=self.llm,
@@ -36,8 +39,9 @@ class TeacherStudentAgentWorkflow:
             description="Useful for writing a report on a given topic.",
             system_prompt=(
                 "You are the WriteAgent that can write a report on a given topic. "
+                "IMPORTANT: Never make duplicate tool calls. Write the report only ONCE with all available research. "
                 "Your report should be in a markdown format. The content should be grounded in the research notes. "
-                "Once the report is written, you should get feedback at least once from the ReviewAgent."
+                "Once the report is written ONCE, immediately hand off control to the ReviewAgent for feedback."
             ),
             llm=self.llm,
             tools=[write_report],
@@ -48,9 +52,10 @@ class TeacherStudentAgentWorkflow:
             name="ReviewAgent",
             description="Useful for reviewing a report and providing feedback.",
             system_prompt=(
-                "You are the ReviewAgent that can review the write report and provide feedback. "
-                "Your review should either approve the current report or request changes for the WriteAgent to implement. "
-                "If you have feedback that requires changes, you should hand off control to the WriteAgent to implement the changes after submitting the review."
+                "You are the ReviewAgent that can review the report and provide feedback. "
+                "IMPORTANT: Never make duplicate tool calls. Review the report only ONCE and provide clear feedback. "
+                "Your review should either approve the current report or request specific changes for the WriteAgent to implement. "
+                "If you have feedback that requires changes, hand off control to the WriteAgent to implement the changes after submitting the review ONCE."
             ),
             llm=self.llm,
             tools=[review_report],

app.py

@@ -1,6 +1,8 @@
 import gradio as gr
 from gradio import ChatMessage
 import asyncio
+import json
+import hashlib
 from agent import TeacherStudentAgentWorkflow
 from llama_index.core.agent.workflow import (
     AgentInput,
@@ -43,6 +45,10 @@ async def chat_with_agent(message, history):
         final_report = None
         workflow_state = {}
         
+        # Track recent tool calls to prevent UI duplicates
+        recent_tool_calls = set()
+        max_cache_size = 100  # Limit cache size to prevent memory issues
+        
         async for event in handler.stream_events():
             # Check if we switched to a new agent
             if (
@@ -51,6 +57,9 @@ async def chat_with_agent(message, history):
             ):
                 current_agent = event.current_agent_name
                 
+                # Clear tool call tracking when switching agents
+                recent_tool_calls.clear()
+                
                 # Add agent header message
                 agent_header = ChatMessage(
                     role="assistant",
@@ -84,14 +93,36 @@ async def chat_with_agent(message, history):
                     yield history, final_report
                     
             elif isinstance(event, ToolCall):
-                # Show tool being called
-                tool_msg = ChatMessage(
-                    role="assistant",
-                    content=f"🔨 **Calling Tool:** {event.tool_name}\n**Arguments:** {event.tool_kwargs}",
-                    metadata={"title": f"{current_agent} - Tool Call"}
-                )
-                history.append(tool_msg)
-                yield history, final_report
+                # Create a unique identifier for this tool call using a more robust approach
+                try:
+                    # Sort the arguments to ensure consistent hashing
+                    sorted_kwargs = json.dumps(event.tool_kwargs, sort_keys=True, default=str)
+                    tool_call_id = f"{event.tool_name}_{hashlib.md5(sorted_kwargs.encode()).hexdigest()}"
+                except (TypeError, ValueError):
+                    # Fallback for non-serializable arguments
+                    tool_call_id = f"{event.tool_name}_{hash(str(event.tool_kwargs))}"
+                
+                # Only show if we haven't seen this exact tool call recently
+                if tool_call_id not in recent_tool_calls:
+                    recent_tool_calls.add(tool_call_id)
+                    
+                    # Clean up cache if it gets too large
+                    if len(recent_tool_calls) > max_cache_size:
+                        # Remove some old entries (keep the most recent half)
+                        recent_tool_calls = set(list(recent_tool_calls)[-max_cache_size//2:])
+                    
+                    # Show tool being called
+                    tool_msg = ChatMessage(
+                        role="assistant",
+                        content=f"🔨 **Calling Tool:** {event.tool_name}\n**Arguments:** {event.tool_kwargs}",
+                        metadata={"title": f"{current_agent} - Tool Call"}
+                    )
+                    history.append(tool_msg)
+                    yield history, final_report
+                else:
+                    # Debug: Log duplicate detection (remove this in production)
+                    print(f"🚫 Duplicate tool call detected and skipped: {event.tool_name} with args {event.tool_kwargs}")
+                # If it's a duplicate, we simply skip displaying it
                 
             elif isinstance(event, ToolCallResult):
                 # Show tool results
@@ -99,21 +130,33 @@ async def chat_with_agent(message, history):
                 if len(result_content) > 500:
                     result_content = result_content[:500] + "..."
                 
-                result_msg = ChatMessage(
-                    role="assistant",
-                    content=f"🔧 **Tool Result ({event.tool_name}):**\n{result_content}",
-                    metadata={"title": f"{current_agent} - Tool Result"}
-                )
+                # Check if this is a duplicate detection message
+                is_duplicate = any(word in result_content.lower() for word in ["duplicate", "skipping"])
+                
+                if is_duplicate:
+                    result_msg = ChatMessage(
+                        role="assistant",
+                        content=f"⚠️ **Duplicate Detection ({event.tool_name}):**\n{result_content}",
+                        metadata={"title": f"{current_agent} - Duplicate Skipped"}
+                    )
+                else:
+                    result_msg = ChatMessage(
+                        role="assistant",
+                        content=f"🔧 **Tool Result ({event.tool_name}):**\n{result_content}",
+                        metadata={"title": f"{current_agent} - Tool Result"}
+                    )
+                
                 history.append(result_msg)
                 
-                # Track tool results to detect report writing and review approval
-                if event.tool_name == "write_report":
-                    workflow_state["has_report"] = True
-                elif event.tool_name == "review_report" and current_agent == "ReviewAgent":
-                    workflow_state["has_review"] = True
-                    # Check if review indicates approval
-                    if any(word in result_content.lower() for word in ["approved", "ready", "good", "excellent"]):
-                        workflow_state["review_approved"] = True
+                # Track tool results to detect report writing and review approval (only for non-duplicates)
+                if not is_duplicate:
+                    if event.tool_name == "write_report":
+                        workflow_state["has_report"] = True
+                    elif event.tool_name == "review_report" and current_agent == "ReviewAgent":
+                        workflow_state["has_review"] = True
+                        # Check if review indicates approval
+                        if any(word in result_content.lower() for word in ["approved", "ready", "good", "excellent"]):
+                            workflow_state["review_approved"] = True
                 
                 yield history, final_report
         

test_deduplication.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+Test script to verify that the deduplication mechanism works correctly.
+"""
+
+import asyncio
+import sys
+import os
+sys.path.append(os.path.dirname(__file__))
+
+from tools.tavily_search_tool import search_web, _should_execute_call
+
+async def test_deduplication():
+    """Test that duplicate tool calls are properly detected and prevented."""
+    print("Testing deduplication mechanism...")
+    
+    # Test 1: Same query should be deduplicated
+    print("\n1. Testing search_web deduplication:")
+    query = "test query for deduplication"
+    
+    print(f"First call with query: '{query}'")
+    result1 = await search_web(query)
+    print(f"Result: {result1[:100]}...")
+    
+    print(f"Second call with same query: '{query}'")
+    result2 = await search_web(query)
+    print(f"Result: {result2}")
+    
+    # Test 2: Direct deduplication function
+    print("\n2. Testing _should_execute_call function:")
+    should_execute_1 = _should_execute_call("test_tool", arg1="value1", arg2="value2")
+    print(f"First call should execute: {should_execute_1}")
+    
+    should_execute_2 = _should_execute_call("test_tool", arg1="value1", arg2="value2")
+    print(f"Second call should execute: {should_execute_2}")
+    
+    should_execute_3 = _should_execute_call("test_tool", arg1="value1", arg2="different_value")
+    print(f"Third call with different args should execute: {should_execute_3}")
+    
+    print("\n✅ Deduplication test completed!")
+
+if __name__ == "__main__":
+    asyncio.run(test_deduplication()) 

tools/tavily_search_tool.py

@@ -2,17 +2,57 @@ from tavily import AsyncTavilyClient
 from llama_index.core.workflow import Context
 from dotenv import load_dotenv
 import os
+import time
+import hashlib
+import json
 
 load_dotenv(os.path.join(os.path.dirname(__file__), '../env.local'))
 
+# Global cache to track recent tool calls and prevent duplicates
+_tool_call_cache = {}
+_cache_timeout = 30  # 30 seconds timeout for deduplication
+
+def _generate_call_hash(tool_name: str, **kwargs) -> str:
+    """Generate a hash for tool call deduplication."""
+    # Create a stable hash from tool name and arguments
+    call_data = {"tool": tool_name, "args": kwargs}
+    call_str = json.dumps(call_data, sort_keys=True)
+    return hashlib.md5(call_str.encode()).hexdigest()
+
+def _should_execute_call(tool_name: str, **kwargs) -> bool:
+    """Check if a tool call should be executed or if it's a duplicate."""
+    current_time = time.time()
+    call_hash = _generate_call_hash(tool_name, **kwargs)
+    
+    # Clean up old cache entries
+    expired_keys = [k for k, v in _tool_call_cache.items() if current_time - v > _cache_timeout]
+    for key in expired_keys:
+        del _tool_call_cache[key]
+    
+    # Check if this call was made recently
+    if call_hash in _tool_call_cache:
+        return False
+    
+    # Record this call
+    _tool_call_cache[call_hash] = current_time
+    return True
+
 async def search_web(query: str) -> str:
     """Useful for using the web to answer questions."""
+    # Check for duplicate calls
+    if not _should_execute_call("search_web", query=query):
+        return f"Duplicate search call detected for query: '{query}'. Skipping to avoid redundant API calls."
+    
     client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
     return str(await client.search(query))
 
 
 async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
     """Useful for recording notes on a given topic. Your input should be notes with a title to save the notes under."""
+    # Check for duplicate calls
+    if not _should_execute_call("record_notes", notes=notes, notes_title=notes_title):
+        return f"Duplicate notes recording detected for title: '{notes_title}'. Skipping to avoid redundant recording."
+    
     current_state = await ctx.get("state")
     if "research_notes" not in current_state:
         current_state["research_notes"] = {}
@@ -23,6 +63,10 @@ async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
 
 async def write_report(ctx: Context, report_content: str) -> str:
     """Useful for writing a report on a given topic. Your input should be a markdown formatted report."""
+    # Check for duplicate calls
+    if not _should_execute_call("write_report", report_content=report_content):
+        return "Duplicate report writing detected. Skipping to avoid redundant report generation."
+    
     current_state = await ctx.get("state")
     current_state["report_content"] = report_content
     await ctx.set("state", current_state)
@@ -31,6 +75,10 @@ async def write_report(ctx: Context, report_content: str) -> str:
 
 async def review_report(ctx: Context, review: str) -> str:
     """Useful for reviewing a report and providing feedback. Your input should be a review of the report."""
+    # Check for duplicate calls
+    if not _should_execute_call("review_report", review=review):
+        return "Duplicate review detected. Skipping to avoid redundant review submission."
+    
     current_state = await ctx.get("state")
     current_state["review"] = review
     await ctx.set("state", current_state)