clean up logs

Author: sattensil

agents/ld_agent_helpers.py

@@ -240,12 +240,19 @@ async def ainvoke(self, request_data: dict) -> dict:
                                 tool_name = tool_call.name
                                 tool_calls_summary.append(tool_name)
 
-                                # Try to extract details
+                                # Try to extract details with search query
                                 if hasattr(tool_call, 'args'):
-                                    tool_details.append({
-                                        "tool": tool_name,
+                                    detail = {
+                                        "name": tool_name,
                                         "args": tool_call.args
-                                    })
+                                    }
+                                    # Extract search query from args if present
+                                    if isinstance(tool_call.args, dict):
+                                        if 'query' in tool_call.args:
+                                            detail["search_query"] = tool_call.args['query']
+                                        elif 'search_query' in tool_call.args:
+                                            detail["search_query"] = tool_call.args['search_query']
+                                    tool_details.append(detail)
 
                 return {
                     "user_input": user_input,

agents/supervisor_agent.py

@@ -124,8 +124,8 @@ def create_supervisor_agent(supervisor_config, support_config, security_config,
     # Create child agents with config manager
     support_agent = create_support_agent(support_config, config_manager)
     security_agent = create_security_agent(security_config, config_manager)
-    
-    log_student(f"SUPERVISOR INSTRUCTIONS: {supervisor_config.instructions}")
+
+    log_debug(f"SUPERVISOR INSTRUCTIONS: {supervisor_config.instructions}")
 
     def pii_prescreen_node(state: SupervisorState):
         """

test_semantic_scholar_timeout.py

@@ -0,0 +1,96 @@
+"""Test Semantic Scholar with timeout controls"""
+import asyncio
+import sys
+import os
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+from tools_impl.mcp_research_tools import get_mcp_research_tools
+
+async def test_with_timeout(timeout_seconds: int):
+    """Test Semantic Scholar with a specific timeout"""
+    print(f"\n{'='*60}")
+    print(f"Testing with {timeout_seconds} second timeout")
+    print(f"{'='*60}\n")
+
+    try:
+        # Initialize MCP tools
+        print("Initializing MCP tools...")
+        mcp_tools = await get_mcp_research_tools()
+
+        # Get Semantic Scholar tool
+        semantic_tool = mcp_tools.get_tool("semantic_scholar")
+        if not semantic_tool:
+            print("❌ Semantic Scholar tool not found!")
+            print(f"Available tools: {mcp_tools.get_available_tools()}")
+            return False
+
+        print(f"✅ Semantic Scholar tool found: {semantic_tool.name}")
+        print(f"Description: {semantic_tool.description}\n")
+
+        # Test with timeout
+        print(f"Executing search with {timeout_seconds}s timeout...")
+        print(f"Query: 'transformer models natural language processing'")
+        print(f"Num results: 5\n")
+
+        start_time = asyncio.get_event_loop().time()
+
+        try:
+            # Run with timeout
+            result = await asyncio.wait_for(
+                semantic_tool.ainvoke({
+                    "query": "transformer models natural language processing",
+                    "num_results": 5
+                }),
+                timeout=timeout_seconds
+            )
+
+            elapsed = asyncio.get_event_loop().time() - start_time
+            print(f"\n✅ Completed in {elapsed:.2f} seconds")
+            print(f"Results returned: {len(result) if isinstance(result, list) else 'N/A'}")
+            return True
+
+        except asyncio.TimeoutError:
+            elapsed = asyncio.get_event_loop().time() - start_time
+            print(f"\n⏱️  TIMEOUT after {elapsed:.2f} seconds")
+            print(f"Expected timeout: {timeout_seconds}s")
+            return False
+
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        import traceback
+        print(traceback.format_exc())
+        return False
+
+async def main():
+    """Run timeout tests"""
+    print("\n" + "="*60)
+    print("SEMANTIC SCHOLAR TIMEOUT TEST")
+    print("="*60)
+
+    # Test 1: 30 second timeout (should fail with rate limiting)
+    print("\nTest 1: 30 second timeout (likely to hit rate limits)")
+    result_30s = await test_with_timeout(30)
+
+    # Wait a bit between tests
+    await asyncio.sleep(2)
+
+    # Test 2: 120 second timeout (should complete despite rate limiting)
+    print("\n\nTest 2: 120 second timeout (should handle rate limits)")
+    result_120s = await test_with_timeout(120)
+
+    # Summary
+    print("\n" + "="*60)
+    print("TEST SUMMARY")
+    print("="*60)
+    print(f"30s timeout:  {'PASSED' if result_30s else 'FAILED (EXPECTED)'}")
+    print(f"120s timeout: {'PASSED' if result_120s else 'FAILED'}")
+    print("\nRecommendation: Use 120s timeout for Semantic Scholar to handle rate limiting")
+
+if __name__ == "__main__":
+    asyncio.run(main())

ui/chat_interface.py

@@ -789,9 +789,13 @@ def process_tool_display(tools, tool_details):
 
     if selected_user_id != st.session_state.user_id:
         st.session_state.user_id = selected_user_id
+        # Clear both message histories when switching users
+        st.session_state.messages = []
+        st.session_state.sanitized_messages = []
         st.rerun()
 
     if st.button("Clear Chat"):
         st.session_state.messages = []
+        st.session_state.sanitized_messages = []
         st.rerun()