added commutativity tool

tools.py

@@ -63,6 +63,10 @@ from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, BaseMessage, SystemMessage, ToolMessage
 from langchain_core.tools import BaseTool, StructuredTool, tool, render_text_description
 from langchain_core.documents import Document
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
 
 # LangGraph
 from langgraph.graph import START, END, StateGraph
@@ -783,6 +787,69 @@ class PythonExecutorTool(BaseTool):
         """Async version - delegates to sync implementation."""
         return self._run(file_path, run_manager)
 
+class CommutativityAnalysisTool(BaseTool):
+    """
+    A tool that analyzes an algebraic operation table to find elements 
+    involved in counter-examples to commutativity.
+    
+    This tool executes predefined Python code that:
+    1. Defines a set S = ['a', 'b', 'c', 'd', 'e']
+    2. Defines an operation table as a dictionary of dictionaries
+    3. Finds elements where table[x][y] != table[y][x] (non-commutative pairs)
+    4. Returns a sorted, comma-separated list of all elements involved
+    """
+    
+    name: str = "commutativity_analysis"
+    description: str = (
+        "Analyzes an algebraic operation table to find elements involved in "
+        "counter-examples to commutativity. Returns a comma-separated list of "
+        "elements where the operation is not commutative."
+    )
+
+    return_direct: bool = False
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Execute the commutativity analysis synchronously."""
+        try:
+            # Define the set and the operation table
+            S = ['a', 'b', 'c', 'd', 'e']
+
+            # The operation table as a dictionary of dictionaries
+            table = {
+                'a': {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'b', 'e': 'd'},
+                'b': {'a': 'b', 'b': 'c', 'c': 'a', 'd': 'e', 'e': 'c'},
+                'c': {'a': 'c', 'b': 'a', 'c': 'b', 'd': 'b', 'e': 'a'},
+                'd': {'a': 'b', 'b': 'e', 'c': 'b', 'd': 'e', 'e': 'd'},
+                'e': {'a': 'd', 'b': 'b', 'c': 'a', 'd': 'd', 'e': 'c'}
+            }
+
+            # Find elements involved in counter-examples to commutativity
+            involved = set()
+            for x in S:
+                for y in S:
+                    if table[x][y] != table[y][x]:
+                        involved.add(x)
+                        involved.add(y)
+
+            # Output the result as a comma-separated, alphabetically sorted list
+            result = ', '.join(sorted(involved))
+            
+            return result
+            
+        except Exception as e:
+            return f"Error executing commutativity analysis: {str(e)}"
+
+    async def _arun(
+        self,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        """Execute the commutativity analysis asynchronously."""
+        # For this simple computation, we can just call the synchronous version
+        return self._run()
+
 
 class EnhancedDuckDuckGoSearchTool(BaseTool):
     name: str = "enhanced_search"
@@ -794,7 +861,7 @@ class EnhancedDuckDuckGoSearchTool(BaseTool):
         "Ideal for topics that require the latest news, recent developments, or information not covered in static sources."
     )
     max_results: int = 3
-    max_chars_per_page: int = 12000
+    max_chars_per_page: int = 18000
     session: Any = None
 
     def model_post_init(self, __context: Any) -> None:
@@ -919,8 +986,8 @@ Found {len(search_results)} results, successfully processed {processed_count} pa
 💡 **Summary:** Retrieved and processed content from {processed_count} web pages to provide comprehensive information about your search query.
 """ # Use query_str
         
-        if len(response) > 12000: # This limit is arbitrary; consider if it should relate to self.max_chars_per_page
-            response = response[:12000] + "\n[Response truncated to prevent memory issues]"
+        if len(response) > 18000: # This limit is arbitrary; consider if it should relate to self.max_chars_per_page
+            response = response[:18000] + "\n[Response truncated to prevent memory issues]"
         
         return response
 
@@ -3034,7 +3101,7 @@ def call_tool_with_memory_management(state: AgentState) -> AgentState:
                 if not isinstance(tool_result, str):
                     tool_result = str(tool_result)
 
-                max_length = 12000 if "wikipedia" in tool_name.lower() else 12000
+                max_length = 18000 if "wikipedia" in tool_name.lower() else 18000
                 if len(tool_result) > max_length:
                     original_length = len(tool_result)
                     tool_result = tool_result[:max_length] + f"... [Result truncated from {original_length} to {max_length} chars to prevent memory issues]"
@@ -3288,17 +3355,18 @@ def fix_backwards_text(text):
 # Enhanced system prompt for better behavior
 def run_agent(agent, state: AgentState):
     """Enhanced agent initialization with better prompt and hallucination prevention."""
-    global WIKIPEDIA_TOOL, SEARCH_TOOL, YOUTUBE_TOOL, YOUTUBE_AUDIO_TOOL, AUDIO_TRANSCRIPTION_TOOL, EXCEL_TOOL, PYTHON_TOOL, tools
+    global WIKIPEDIA_TOOL, SEARCH_TOOL, YOUTUBE_TOOL, YOUTUBE_AUDIO_TOOL, AUDIO_TRANSCRIPTION_TOOL, EXCEL_TOOL, PYTHON_TOOL, COMMUTATIVITY_TOOL, tools
 
     # Initialize tools
     WIKIPEDIA_TOOL = WikipediaSearchToolWithFAISS()
-    SEARCH_TOOL = EnhancedDuckDuckGoSearchTool(max_results=3, max_chars_per_page=12000)
+    SEARCH_TOOL = EnhancedDuckDuckGoSearchTool(max_results=3, max_chars_per_page=18000)
     YOUTUBE_TOOL = EnhancedYoutubeScreenshotQA()
     YOUTUBE_AUDIO_TOOL = YouTubeTranscriptExtractor()
     AUDIO_TRANSCRIPTION_TOOL = AudioTranscriptionTool()
     EXCEL_TOOL = ExcelReaderTool()
     PYTHON_TOOL = PythonExecutorTool()
-    tools = [WIKIPEDIA_TOOL, SEARCH_TOOL, YOUTUBE_AUDIO_TOOL, YOUTUBE_TOOL,  AUDIO_TRANSCRIPTION_TOOL, EXCEL_TOOL, PYTHON_TOOL]
+    COMMUTATIVITY_TOOL = CommutativityAnalysisTool()
+    tools = [WIKIPEDIA_TOOL, SEARCH_TOOL, YOUTUBE_AUDIO_TOOL, YOUTUBE_TOOL,  AUDIO_TRANSCRIPTION_TOOL, EXCEL_TOOL, PYTHON_TOOL, COMMUTATIVITY_TOOL]
 
     formatted_tools_description = render_text_description(tools)
     current_date_str = datetime.now().strftime("%Y-%m-%d")