Python: [BREAKING] cleanup of thread API and serialization (#893)

* cleanup of threads and serialization

* fix for sliding window

* fix redis test

* updated from comments

* updated context provider and threads

* updated lock

* add asyncio default

* fix redis tests

* fix tests

* fix tests

* renamed to invoking

* fixed tests

* fix for instructions

python/packages/lab/tau2/tests/test_sliding_window.py

@@ -4,20 +4,19 @@
 
 from unittest.mock import patch
 
-import pytest
 from agent_framework._types import ChatMessage, FunctionCallContent, FunctionResultContent, Role, TextContent
-from agent_framework_lab_tau2._sliding_window import SlidingWindowChatMessageList
+from agent_framework_lab_tau2._sliding_window import SlidingWindowChatMessageStore
 
 
 def test_initialization_empty():
     """Test initializing with no messages."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
 
     assert sliding_window.max_tokens == 1000
     assert sliding_window.system_message is None
     assert sliding_window.tool_definitions is None
-    assert len(sliding_window._messages) == 0
-    assert len(sliding_window._truncated_messages) == 0
+    assert len(sliding_window.messages) == 0
+    assert len(sliding_window.truncated_messages) == 0
 
 
 def test_initialization_with_parameters():
@@ -25,7 +24,7 @@ def test_initialization_with_parameters():
     system_msg = "You are a helpful assistant"
     tool_defs = [{"name": "test_tool", "description": "A test tool"}]
 
-    sliding_window = SlidingWindowChatMessageList(
+    sliding_window = SlidingWindowChatMessageStore(
         max_tokens=2000, system_message=system_msg, tool_definitions=tool_defs
     )
 
@@ -41,16 +40,15 @@ def test_initialization_with_messages():
         ChatMessage(role=Role.ASSISTANT, contents=[TextContent(text="Hi there!")]),
     ]
 
-    sliding_window = SlidingWindowChatMessageList(messages=messages, max_tokens=1000)
+    sliding_window = SlidingWindowChatMessageStore(messages=messages, max_tokens=1000)
 
-    assert len(sliding_window._messages) == 2
-    assert len(sliding_window._truncated_messages) == 2
+    assert len(sliding_window.messages) == 2
+    assert len(sliding_window.truncated_messages) == 2
 
 
-@pytest.mark.asyncio
 async def test_add_messages_simple():
     """Test adding messages without truncation."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=10000)  # Large limit
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=10000)  # Large limit
 
     new_messages = [
         ChatMessage(role=Role.USER, contents=[TextContent(text="What's the weather?")]),
@@ -65,10 +63,9 @@ async def test_add_messages_simple():
     assert messages[1].text == "I can help with that."
 
 
-@pytest.mark.asyncio
 async def test_list_all_messages_vs_list_messages():
     """Test difference between list_all_messages and list_messages."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=50)  # Small limit to force truncation
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=50)  # Small limit to force truncation
 
     # Add many messages to trigger truncation
     messages = [
@@ -89,8 +86,8 @@ async def test_list_all_messages_vs_list_messages():
 
 def test_get_token_count_basic():
     """Test basic token counting."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
-    sliding_window._truncated_messages = [ChatMessage(role=Role.USER, contents=[TextContent(text="Hello")])]
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
+    sliding_window.truncated_messages = [ChatMessage(role=Role.USER, contents=[TextContent(text="Hello")])]
 
     token_count = sliding_window.get_token_count()
 
@@ -101,13 +98,13 @@ def test_get_token_count_basic():
 def test_get_token_count_with_system_message():
     """Test token counting includes system message."""
     system_msg = "You are a helpful assistant"
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000, system_message=system_msg)
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000, system_message=system_msg)
 
     # Without messages
     token_count_empty = sliding_window.get_token_count()
 
     # Add a message
-    sliding_window._truncated_messages = [ChatMessage(role=Role.USER, contents=[TextContent(text="Hello")])]
+    sliding_window.truncated_messages = [ChatMessage(role=Role.USER, contents=[TextContent(text="Hello")])]
     token_count_with_message = sliding_window.get_token_count()
 
     # With message should be more tokens
@@ -119,8 +116,8 @@ def test_get_token_count_function_call():
     """Test token counting with function calls."""
     function_call = FunctionCallContent(call_id="call_123", name="test_function", arguments={"param": "value"})
 
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
-    sliding_window._truncated_messages = [ChatMessage(role=Role.ASSISTANT, contents=[function_call])]
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
+    sliding_window.truncated_messages = [ChatMessage(role=Role.ASSISTANT, contents=[function_call])]
 
     token_count = sliding_window.get_token_count()
     assert token_count > 0
@@ -130,8 +127,8 @@ def test_get_token_count_function_result():
     """Test token counting with function results."""
     function_result = FunctionResultContent(call_id="call_123", result={"success": True, "data": "result"})
 
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
-    sliding_window._truncated_messages = [ChatMessage(role=Role.TOOL, contents=[function_result])]
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
+    sliding_window.truncated_messages = [ChatMessage(role=Role.TOOL, contents=[function_result])]
 
     token_count = sliding_window.get_token_count()
     assert token_count > 0
@@ -140,7 +137,7 @@ def test_get_token_count_function_result():
 @patch("agent_framework_lab_tau2._sliding_window.logger")
 def test_truncate_messages_removes_old_messages(mock_logger):
     """Test that truncation removes old messages when token limit exceeded."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=20)  # Very small limit
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=20)  # Very small limit
 
     # Create messages that will exceed the limit
     messages = [
@@ -155,11 +152,11 @@ def test_truncate_messages_removes_old_messages(mock_logger):
         ChatMessage(role=Role.USER, contents=[TextContent(text="Short msg")]),
     ]
 
-    sliding_window._truncated_messages = messages.copy()
+    sliding_window.truncated_messages = messages.copy()
     sliding_window.truncate_messages()
 
     # Should have fewer messages after truncation
-    assert len(sliding_window._truncated_messages) < len(messages)
+    assert len(sliding_window.truncated_messages) < len(messages)
 
     # Should have logged warnings
     assert mock_logger.warning.called
@@ -168,18 +165,18 @@ def test_truncate_messages_removes_old_messages(mock_logger):
 @patch("agent_framework_lab_tau2._sliding_window.logger")
 def test_truncate_messages_removes_leading_tool_messages(mock_logger):
     """Test that truncation removes leading tool messages."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=10000)  # Large limit
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=10000)  # Large limit
 
     # Create messages starting with tool message
     tool_message = ChatMessage(role=Role.TOOL, contents=[FunctionResultContent(call_id="call_123", result="result")])
     user_message = ChatMessage(role=Role.USER, contents=[TextContent(text="Hello")])
 
-    sliding_window._truncated_messages = [tool_message, user_message]
+    sliding_window.truncated_messages = [tool_message, user_message]
     sliding_window.truncate_messages()
 
     # Tool message should be removed from the beginning
-    assert len(sliding_window._truncated_messages) == 1
-    assert sliding_window._truncated_messages[0].role == Role.USER
+    assert len(sliding_window.truncated_messages) == 1
+    assert sliding_window.truncated_messages[0].role == Role.USER
 
     # Should have logged warning about removing tool message
     mock_logger.warning.assert_called()
@@ -187,7 +184,7 @@ def test_truncate_messages_removes_leading_tool_messages(mock_logger):
 
 def test_estimate_any_object_token_count_dict():
     """Test token counting for dictionary objects."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
 
     test_dict = {"key": "value", "number": 42}
     token_count = sliding_window.estimate_any_object_token_count(test_dict)
@@ -197,7 +194,7 @@ def test_estimate_any_object_token_count_dict():
 
 def test_estimate_any_object_token_count_string():
     """Test token counting for string objects."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
 
     test_string = "This is a test string"
     token_count = sliding_window.estimate_any_object_token_count(test_string)
@@ -207,7 +204,7 @@ def test_estimate_any_object_token_count_string():
 
 def test_estimate_any_object_token_count_non_serializable():
     """Test token counting for non-JSON-serializable objects."""
-    sliding_window = SlidingWindowChatMessageList(max_tokens=1000)
+    sliding_window = SlidingWindowChatMessageStore(max_tokens=1000)
 
     # Create an object that can't be JSON serialized
     class CustomObject:
@@ -221,10 +218,9 @@ def test_estimate_any_object_token_count_non_serializable():
     assert token_count > 0
 
 
-@pytest.mark.asyncio
 async def test_real_world_scenario():
     """Test a realistic conversation scenario."""
-    sliding_window = SlidingWindowChatMessageList(
+    sliding_window = SlidingWindowChatMessageStore(
         max_tokens=30,
         system_message="You are a helpful assistant",  # Moderate limit
     )