mindroot 8.13.0__tar.gz → 9.0.0__tar.gz

{mindroot-8.13.0/src/mindroot.egg-info → mindroot-9.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindroot
-Version: 8.13.0
+Version: 9.0.0
 Summary: MindRoot AI Agent Framework
 Requires-Python: >=3.9
 License-File: LICENSE

{mindroot-8.13.0 → mindroot-9.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mindroot"
-version = "8.13.0"
+version = "9.0.0"
 description = "MindRoot AI Agent Framework"
 requires-python = ">=3.9"
 dependencies = [

{mindroot-8.13.0 → mindroot-9.0.0}/src/mindroot/coreplugins/chat/router.py

@@ -237,7 +237,7 @@ async def get_token_count(request: Request, log_id: str):
     Returns:
     - JSON with token counts or error message if log not found
     """
-    token_counts = count_tokens_for_log_id(log_id)
+    token_counts = await count_tokens_for_log_id(log_id)
     
     if token_counts is None:
         return {"status": "error", "message": f"Chat log with ID {log_id} not found"}
@@ -301,7 +301,7 @@ async def get_token_count(request: Request, log_id: str):
     """
     from lib.token_counter import count_tokens_for_log_id
     
-    token_counts = count_tokens_for_log_id(log_id)
+    token_counts = await count_tokens_for_log_id(log_id)
     
     if token_counts is None:
         return {"status": "error", "message": f"Chat log with ID {log_id} not found"}

{mindroot-8.13.0 → mindroot-9.0.0}/src/mindroot/coreplugins/chat/services.py

@@ -76,7 +76,7 @@ async def run_task(instructions: str, agent_name:str = None, user:str = None, lo
         context.data['llm'] = llm
         context.current_model = llm
         context.chat_log = ChatLog(log_id=log_id, agent=agent_name, user=user, parent_log_id=parent_log_id)
-        context.save_context()
+        await context.save_context()
     else:
         debug_box("Context is not none")
         print(context)
@@ -132,7 +132,7 @@ async def init_chat_session(user:str, agent_name: str, log_id: str, context=None
         context.agent = await service_manager.get_agent_data(agent_name)
         context.chat_log = ChatLog(log_id=log_id, agent=agent_name, user=user)
         print("context.agent_name: ", context.agent_name)
-        context.save_context()
+        await context.save_context()
     print("initiated_chat_session: ", log_id, agent_name, context.agent_name, context.agent)
     return log_id
 
@@ -247,7 +247,7 @@ async def send_message_to_agent(session_id: str, message: str | List[MessagePart
             has_image = has_image or str(msg_to_add).find("image") > -1
             context.chat_log.add_message(msg_to_add)
 
-        context.save_context()
+        await context.save_context()
 
         continue_processing = True
         iterations = 0

{mindroot-8.13.0 → mindroot-9.0.0}/src/mindroot/lib/chatcontext.py

@@ -2,6 +2,9 @@ from .providers.services import service_manager
 from .providers.commands import command_manager
 import os
 import json
+import asyncio
+import aiofiles
+import aiofiles.os
 from .chatlog import ChatLog
 from .chatlog import extract_delegate_task_log_ids, find_child_logs_by_parent_id, find_chatlog_file
 from typing import TypeVar, Type, Protocol, runtime_checkable, Set
@@ -85,31 +88,32 @@ class ChatContext:
     def cmds(self, command_set: Type[CommandSetT]) -> CommandSetT:
         return self._commands[command_set]
 
-    def save_context_data(self):
+    async def save_context_data(self):
         if not self.log_id:
             raise ValueError('log_id is not set for the context.')
         else:
             pass
         context_file = f'data/context/{self.username}/context_{self.log_id}.json'
-        os.makedirs(os.path.dirname(context_file), exist_ok=True)
+        await aiofiles.os.makedirs(os.path.dirname(context_file), exist_ok=True)
         try:
-            with open(context_file, 'r') as f:
-                context_data = json.load(f)
+            async with aiofiles.open(context_file, 'r') as f:
+                content = await f.read()
+                context_data = json.loads(content)
         except FileNotFoundError:
             context_data = {}
         finally:
             pass
         context_data['data'] = self.data
-        with open(context_file, 'w') as f:
-            json.dump(context_data, f, indent=2)
+        async with aiofiles.open(context_file, 'w') as f:
+            await f.write(json.dumps(context_data, indent=2))
 
-    def save_context(self):
+    async def save_context(self):
         if not self.log_id:
             raise ValueError('log_id is not set for the context.')
         else:
             pass
         context_file = f'data/context/{self.username}/context_{self.log_id}.json'
-        os.makedirs(os.path.dirname(context_file), exist_ok=True)
+        await aiofiles.os.makedirs(os.path.dirname(context_file), exist_ok=True)
         self.data['log_id'] = self.log_id
         context_data = {'data': self.data, 'chat_log': self.chat_log._get_log_data()}
         if 'name' in self.agent:
@@ -124,15 +128,16 @@ class ChatContext:
             raise ValueError('Tried to save chat context, but agent name not found in context')
         else:
             pass
-        with open(context_file, 'w') as f:
-            json.dump(context_data, f, indent=2)
+        async with aiofiles.open(context_file, 'w') as f:
+            await f.write(json.dumps(context_data, indent=2))
 
     async def load_context(self, log_id):
         self.log_id = log_id
         context_file = f'data/context/{self.username}/context_{log_id}.json'
-        if os.path.exists(context_file):
-            with open(context_file, 'r') as f:
-                context_data = json.load(f)
+        if await aiofiles.os.path.exists(context_file):
+            async with aiofiles.open(context_file, 'r') as f:
+                content = await f.read()
+                context_data = json.loads(content)
                 self.data = context_data.get('data', {})
                 if 'agent_name' in context_data and context_data.get('agent_name') is not None:
                     self.agent_name = context_data.get('agent_name')
@@ -186,22 +191,23 @@ class ChatContext:
             chatlog_dir_base = os.environ.get('CHATLOG_DIR', 'data/chat')
             chatlog_file_path_current = os.path.join(chatlog_dir_base, user, agent, f'chatlog_{log_id}.json')
 
-            if os.path.exists(chatlog_file_path_current):
+            if await aiofiles.os.path.exists(chatlog_file_path_current):
                 try:
-                    with open(chatlog_file_path_current, 'r') as f:
-                        log_data = json.load(f)
+                    async with aiofiles.open(chatlog_file_path_current, 'r') as f:
+                        content = await f.read()
+                        log_data = json.loads(content)
                         messages_for_child_finding = log_data.get('messages', [])
                 except Exception as e:
                     print(f"Error reading chatlog {chatlog_file_path_current} for child finding: {e}")
             
             delegated_child_ids = extract_delegate_task_log_ids(messages_for_child_finding)
-            parented_child_ids = find_child_logs_by_parent_id(log_id)
+            parented_child_ids = await find_child_logs_by_parent_id(log_id)
             all_child_log_ids = set(delegated_child_ids) | set(parented_child_ids)
 
             for child_id in all_child_log_ids:
                 if child_id in visited_log_ids: # Check again before processing child
                     continue
-                child_log_path = find_chatlog_file(child_id) # This searches across all users/agents
+                child_log_path = await find_chatlog_file(child_id) # This searches across all users/agents
                 if child_log_path:
                     try:
                         relative_path = os.path.relpath(child_log_path, chatlog_dir_base)
@@ -222,9 +228,9 @@ class ChatContext:
         # --- Delete Current Session's Files ---
         # ChatLog File
         chatlog_file_to_delete = os.path.join(os.environ.get('CHATLOG_DIR', 'data/chat'), user, agent, f'chatlog_{log_id}.json')
-        if os.path.exists(chatlog_file_to_delete):
+        if await aiofiles.os.path.exists(chatlog_file_to_delete):
             try:
-                os.remove(chatlog_file_to_delete)
+                await aiofiles.os.remove(chatlog_file_to_delete)
                 print(f"Deleted chatlog file: {chatlog_file_to_delete}")
             except Exception as e:
                 print(f"Error deleting chatlog file {chatlog_file_to_delete}: {e}")
@@ -233,9 +239,9 @@ class ChatContext:
 
         # ChatContext File (Agent is not part of the context file path structure)
         context_file_to_delete = os.path.join('data/context', user, f'context_{log_id}.json')
-        if os.path.exists(context_file_to_delete):
+        if await aiofiles.os.path.exists(context_file_to_delete):
             try:
-                os.remove(context_file_to_delete)
+                await aiofiles.os.remove(context_file_to_delete)
                 print(f"Deleted context file: {context_file_to_delete}")
             except Exception as e:
                 print(f"Error deleting context file {context_file_to_delete}: {e}")

{mindroot-8.13.0 → mindroot-9.0.0}/src/mindroot/lib/chatlog.py

@@ -5,6 +5,9 @@ import sys
 import traceback
 import re
 import time
+import asyncio
+import aiofiles
+import aiofiles.os
 from mindroot.lib.utils.debug import debug_box
 
 class ChatLog:
@@ -32,7 +35,9 @@ class ChatLog:
         self.log_dir = os.path.join(self.log_dir, self.agent)
         if not os.path.exists(self.log_dir):
             os.makedirs(self.log_dir)
-        self.load_log()
+        # For backward compatibility, we'll load synchronously in constructor
+        # but provide async methods for new code
+        self._load_log_sync()
         
     def _get_log_data(self) -> Dict[str, any]:
         return {
@@ -45,7 +50,45 @@ class ChatLog:
     def _calculate_message_length(self, message: Dict[str, str]) -> int:
         return len(json.dumps(message)) // 3
 
+    def _load_log_sync(self, log_id=None) -> None:
+        """Synchronous version for backward compatibility"""
+        if log_id is None:
+            log_id = self.log_id
+        self.log_id = log_id
+        log_file = os.path.join(self.log_dir, f'chatlog_{log_id}.json')
+        if os.path.exists(log_file):
+            with open(log_file, 'r') as f:
+                log_data = json.load(f)
+                self.agent = log_data.get('agent')
+                self.messages = log_data.get('messages', [])
+                self.parent_log_id = log_data.get('parent_log_id', None)
+            print("Loaded log file at ", log_file)
+            print("Message length: ", len(self.messages))
+        else:
+            print("Could not find log file at ", log_file)
+            self.messages = []
+
+    def _save_log_sync(self) -> None:
+        """Synchronous version for backward compatibility"""
+        log_file = os.path.join(self.log_dir, f'chatlog_{self.log_id}.json')
+        with open(log_file, 'w') as f:
+            json.dump(self._get_log_data(), f, indent=2)
+
     def add_message(self, message: Dict[str, str]) -> None:
+        """Synchronous version for backward compatibility"""
+        should_save = self._add_message_impl(message)
+        if should_save:
+            self._save_log_sync()
+        else:
+            # Handle the image case that returned False - save synchronously
+            if (len(self.messages) > 0 and 
+                isinstance(self.messages[-1].get('content'), list) and 
+                len(self.messages[-1]['content']) > 0 and 
+                self.messages[-1]['content'][0].get('type') == 'image'):
+                self._save_log_sync()
+
+    def _add_message_impl(self, message: Dict[str, str]) -> None:
+        """Internal implementation shared by sync and async versions"""
         if len(self.messages)>0 and self.messages[-1]['role'] == message['role']:
             print("found repeat role")
             # check if messasge is str
@@ -57,8 +100,7 @@ class ChatLog:
                     if part['type'] == 'image':
                         print("found image")
                         self.messages.append(message)
-                        self.save_log()
-                        return
+                        return False  # Indicate caller should NOT save (we'll handle it)
 
             try:
                 cmd_list = json.loads(self.messages[-1]['content'][0]['text'])
@@ -90,7 +132,19 @@ class ChatLog:
                 print('roles do not repeat, last message role is ', self.messages[-1]['role'], 'new message role is ', message['role'])
             debug_box("5")
             self.messages.append(message)
-        self.save_log()
+        self._save_log_sync()
+    async def add_message_async(self, message: Dict[str, str]) -> None:
+        """Async version for new code that needs non-blocking operations"""
+        should_save = self._add_message_impl(message)
+        if should_save:
+            await self.save_log()
+        else:
+            # Handle the image case that returned False - save asynchronously
+            if (len(self.messages) > 0 and 
+                isinstance(self.messages[-1].get('content'), list) and 
+                len(self.messages[-1]['content']) > 0 and 
+                self.messages[-1]['content'][0].get('type') == 'image'):
+                await self.save_log()
 
     def get_history(self) -> List[Dict[str, str]]:
         return self.messages
@@ -112,20 +166,21 @@ class ChatLog:
         # 
         #return recent_messages
 
-    def save_log(self) -> None:
+    async def save_log(self) -> None:
         log_file = os.path.join(self.log_dir, f'chatlog_{self.log_id}.json')
-        with open(log_file, 'w') as f:
-            json.dump(self._get_log_data(), f, indent=2)
+        async with aiofiles.open(log_file, 'w') as f:
+            await f.write(json.dumps(self._get_log_data(), indent=2))
         
 
-    def load_log(self, log_id = None) -> None:
+    async def load_log(self, log_id = None) -> None:
         if log_id is None:
             log_id = self.log_id
         self.log_id = log_id
         log_file = os.path.join(self.log_dir, f'chatlog_{log_id}.json')
-        if os.path.exists(log_file):
-            with open(log_file, 'r') as f:
-                log_data = json.load(f)
+        if await aiofiles.os.path.exists(log_file):
+            async with aiofiles.open(log_file, 'r') as f:
+                content = await f.read()
+                log_data = json.loads(content)
                 self.agent = log_data.get('agent')
                 self.messages = log_data.get('messages', [])
                 self.parent_log_id = log_data.get('parent_log_id', None)
@@ -175,7 +230,7 @@ class ChatLog:
             'input_tokens_total': input_tokens_total
         }
 
-def find_chatlog_file(log_id: str) -> str:
+async def find_chatlog_file(log_id: str) -> str:
     """
     Find a chatlog file by its log_id.
     
@@ -188,14 +243,14 @@ def find_chatlog_file(log_id: str) -> str:
     chat_dir = os.environ.get('CHATLOG_DIR', 'data/chat')
     
     # Use os.walk to search through all subdirectories
-    for root, dirs, files in os.walk(chat_dir):
+    for root, dirs, files in await asyncio.to_thread(os.walk, chat_dir):
         for file in files:
             if file == f"chatlog_{log_id}.json":
                 return os.path.join(root, file)
     
     return None
 
-def find_child_logs_by_parent_id(parent_log_id: str) -> List[str]:
+async def find_child_logs_by_parent_id(parent_log_id: str) -> List[str]:
     """
     Find all chat logs that have the given parent_log_id.
     
@@ -209,12 +264,13 @@ def find_child_logs_by_parent_id(parent_log_id: str) -> List[str]:
     chat_dir = os.environ.get('CHATLOG_DIR', 'data/chat')
     
     # Search through all chatlog files
-    for root, dirs, files in os.walk(chat_dir):
+    for root, dirs, files in await asyncio.to_thread(os.walk, chat_dir):
         for file in files:
             if file.startswith("chatlog_") and file.endswith(".json"):
                 try:
-                    with open(os.path.join(root, file), 'r') as f:
-                        log_data = json.load(f)
+                    async with aiofiles.open(os.path.join(root, file), 'r') as f:
+                        content = await f.read()
+                        log_data = json.loads(content)
                         if log_data.get('parent_log_id') == parent_log_id:
                             # Extract log_id from the data
                             child_log_ids.append(log_data.get('log_id'))
@@ -263,24 +319,24 @@ def extract_delegate_task_log_ids(messages: List[Dict]) -> List[str]:
     
     return log_ids
 
-def get_cache_dir() -> str:
+async def get_cache_dir() -> str:
     """
     Get the directory for token count cache files.
     Creates the directory if it doesn't exist.
     """
     cache_dir = os.environ.get('TOKEN_CACHE_DIR', 'data/token_cache')
-    if not os.path.exists(cache_dir):
-        os.makedirs(cache_dir)
+    if not await aiofiles.os.path.exists(cache_dir):
+        await aiofiles.os.makedirs(cache_dir)
     return cache_dir
 
-def get_cache_path(log_id: str) -> str:
+async def get_cache_path(log_id: str) -> str:
     """
     Get the path to the cache file for a specific log_id.
     """
-    cache_dir = get_cache_dir()
+    cache_dir = await get_cache_dir()
     return os.path.join(cache_dir, f"tokens_{log_id}.json")
 
-def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
+async def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
     """
     Get cached token counts if available and valid.
     
@@ -291,16 +347,16 @@ def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
     Returns:
         Cached token counts if valid, None otherwise
     """
-    cache_path = get_cache_path(log_id)
+    cache_path = await get_cache_path(log_id)
     
     # If cache doesn't exist, return None
-    if not os.path.exists(cache_path):
+    if not await aiofiles.os.path.exists(cache_path):
         return None
     
     try:
         # Get modification times
-        log_mtime = os.path.getmtime(log_path)
-        cache_mtime = os.path.getmtime(cache_path)
+        log_mtime = await aiofiles.os.path.getmtime(log_path)
+        cache_mtime = await aiofiles.os.path.getmtime(cache_path)
         current_time = time.time()
         
         # If log was modified after cache was created, cache is invalid
@@ -309,28 +365,31 @@ def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
         
         # Don't recalculate sooner than 3 minutes after last calculation
         if current_time - cache_mtime < 180:  # 3 minutes in seconds
-            with open(cache_path, 'r') as f:
-                return json.load(f)
+            async with aiofiles.open(cache_path, 'r') as f:
+                content = await f.read()
+                return json.loads(content)
                 
         # For logs that haven't been modified in over an hour, consider them "finished"
         # and use the cache regardless of when it was last calculated
         if current_time - log_mtime > 3600:  # 1 hour in seconds
-            with open(cache_path, 'r') as f:
-                return json.load(f)
+            async with aiofiles.open(cache_path, 'r') as f:
+                content = await f.read()
+                return json.loads(content)
     
     except (json.JSONDecodeError, IOError) as e:
         print(f"Error reading token cache: {e}")
     
     return None
 
-def save_token_counts_to_cache(log_id: str, token_counts: Dict[str, int]) -> None:
+async def save_token_counts_to_cache(log_id: str, token_counts: Dict[str, int]) -> None:
     """
     Save token counts to cache.
     """
-    cache_path = get_cache_path(log_id)
-    with open(cache_path, 'w') as f:
-        json.dump(token_counts, f)
-def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
+    cache_path = await get_cache_path(log_id)
+    async with aiofiles.open(cache_path, 'w') as f:
+        await f.write(json.dumps(token_counts))
+
+async def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     """
     Count tokens for a chat log identified by log_id, including any delegated tasks.
     
@@ -341,12 +400,12 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
         Dictionary with token counts or None if log not found
     """
     # Find the chatlog file
-    chatlog_path = find_chatlog_file(log_id)
+    chatlog_path = await find_chatlog_file(log_id)
     if not chatlog_path:
         return None
     
     # Check cache first
-    cached_counts = get_cached_token_counts(log_id, chatlog_path)
+    cached_counts = await get_cached_token_counts(log_id, chatlog_path)
     if cached_counts:
         print(f"Using cached token counts for {log_id}")
         return cached_counts
@@ -354,8 +413,9 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     print(f"Calculating token counts for {log_id}")
     
     # Load the chat log
-    with open(chatlog_path, 'r') as f:
-        log_data = json.load(f)
+    async with aiofiles.open(chatlog_path, 'r') as f:
+        content = await f.read()
+        log_data = json.loads(content)
     
     # Get parent_log_id if it exists
     parent_log_id = log_data.get('parent_log_id')
@@ -378,7 +438,7 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     delegated_log_ids = extract_delegate_task_log_ids(temp_log.messages)
     
     # Also find child logs by parent_log_id
-    child_logs_by_parent = find_child_logs_by_parent_id(log_id)
+    child_logs_by_parent = await find_child_logs_by_parent_id(log_id)
     
     # Combine all child log IDs (delegated tasks and parent_log_id children)
     all_child_log_ids = set(delegated_log_ids) | set(child_logs_by_parent)
@@ -389,7 +449,7 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     
     # Recursively count tokens for all child tasks
     for child_id in all_child_log_ids:
-        delegated_counts = count_tokens_for_log_id(child_id)
+        delegated_counts = await count_tokens_for_log_id(child_id)
         if delegated_counts:
             combined_counts['input_tokens_sequence'] += delegated_counts['input_tokens_sequence']
             combined_counts['output_tokens_sequence'] += delegated_counts['output_tokens_sequence']
@@ -408,6 +468,6 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     }
     
     # Save to cache
-    save_token_counts_to_cache(log_id, token_counts)
+    await save_token_counts_to_cache(log_id, token_counts)
     
     return token_counts

{mindroot-8.13.0 → mindroot-9.0.0}/src/mindroot/lib/token_counter.py

@@ -2,10 +2,13 @@ import os
 import json
 import re
 import time
+import asyncio
+import aiofiles
+import aiofiles.os
 from typing import Dict, List
 from mindroot.lib.chatlog import ChatLog
 
-def find_chatlog_file(log_id: str) -> str:
+async def find_chatlog_file(log_id: str) -> str:
     """
     Find a chatlog file by its log_id.
     
@@ -18,7 +21,7 @@ def find_chatlog_file(log_id: str) -> str:
     chat_dir = os.environ.get('CHATLOG_DIR', 'data/chat')
     
     # Use os.walk to search through all subdirectories
-    for root, dirs, files in os.walk(chat_dir):
+    for root, dirs, files in await asyncio.to_thread(os.walk, chat_dir):
         for file in files:
             if file == f"chatlog_{log_id}.json":
                 return os.path.join(root, file)
@@ -65,24 +68,24 @@ def extract_delegate_task_log_ids(messages: List[Dict]) -> List[str]:
     
     return log_ids
 
-def get_cache_dir() -> str:
+async def get_cache_dir() -> str:
     """
     Get the directory for token count cache files.
     Creates the directory if it doesn't exist.
     """
     cache_dir = os.environ.get('TOKEN_CACHE_DIR', 'data/token_cache')
-    if not os.path.exists(cache_dir):
-        os.makedirs(cache_dir)
+    if not await aiofiles.os.path.exists(cache_dir):
+        await aiofiles.os.makedirs(cache_dir)
     return cache_dir
 
-def get_cache_path(log_id: str) -> str:
+async def get_cache_path(log_id: str) -> str:
     """
     Get the path to the cache file for a specific log_id.
     """
-    cache_dir = get_cache_dir()
+    cache_dir = await get_cache_dir()
     return os.path.join(cache_dir, f"tokens_{log_id}.json")
 
-def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
+async def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
     """
     Get cached token counts if available and valid.
     
@@ -93,16 +96,16 @@ def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
     Returns:
         Cached token counts if valid, None otherwise
     """
-    cache_path = get_cache_path(log_id)
+    cache_path = await get_cache_path(log_id)
     
     # If cache doesn't exist, return None
-    if not os.path.exists(cache_path):
+    if not await aiofiles.os.path.exists(cache_path):
         return None
     
     try:
         # Get modification times
-        log_mtime = os.path.getmtime(log_path)
-        cache_mtime = os.path.getmtime(cache_path)
+        log_mtime = await aiofiles.os.path.getmtime(log_path)
+        cache_mtime = await aiofiles.os.path.getmtime(cache_path)
         current_time = time.time()
         
         # If log was modified after cache was created, cache is invalid
@@ -111,29 +114,31 @@ def get_cached_token_counts(log_id: str, log_path: str) -> Dict[str, int]:
         
         # Don't recalculate sooner than 3 minutes after last calculation
         if current_time - cache_mtime < 180:  # 3 minutes in seconds
-            with open(cache_path, 'r') as f:
-                return json.load(f)
+            async with aiofiles.open(cache_path, 'r') as f:
+                content = await f.read()
+                return json.loads(content)
                 
         # For logs that haven't been modified in over an hour, consider them "finished"
         # and use the cache regardless of when it was last calculated
         if current_time - log_mtime > 3600:  # 1 hour in seconds
-            with open(cache_path, 'r') as f:
-                return json.load(f)
+            async with aiofiles.open(cache_path, 'r') as f:
+                content = await f.read()
+                return json.loads(content)
     
     except (json.JSONDecodeError, IOError) as e:
         print(f"Error reading token cache: {e}")
     
     return None
 
-def save_token_counts_to_cache(log_id: str, token_counts: Dict[str, int]) -> None:
+async def save_token_counts_to_cache(log_id: str, token_counts: Dict[str, int]) -> None:
     """
     Save token counts to cache.
     """
-    cache_path = get_cache_path(log_id)
-    with open(cache_path, 'w') as f:
-        json.dump(token_counts, f)
+    cache_path = await get_cache_path(log_id)
+    async with aiofiles.open(cache_path, 'w') as f:
+        await f.write(json.dumps(token_counts))
 
-def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
+async def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     """
     Count tokens for a chat log identified by log_id, including any delegated tasks.
     
@@ -144,12 +149,12 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
         Dictionary with token counts or None if log not found
     """
     # Find the chatlog file
-    chatlog_path = find_chatlog_file(log_id)
+    chatlog_path = await find_chatlog_file(log_id)
     if not chatlog_path:
         return None
     
     # Check cache first
-    cached_counts = get_cached_token_counts(log_id, chatlog_path)
+    cached_counts = await get_cached_token_counts(log_id, chatlog_path)
     if cached_counts:
         print(f"Using cached token counts for {log_id}")
         return cached_counts
@@ -157,8 +162,9 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     print(f"Calculating token counts for {log_id}")
     
     # Load the chat log
-    with open(chatlog_path, 'r') as f:
-        log_data = json.load(f)
+    async with aiofiles.open(chatlog_path, 'r') as f:
+        content = await f.read()
+        log_data = json.loads(content)
         
     # Create a temporary ChatLog instance to count tokens
     temp_log = ChatLog(log_id=log_id, user="system", agent=log_data.get('agent', 'unknown'))
@@ -178,7 +184,7 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     
     # Recursively count tokens for delegated tasks
     for delegated_id in delegated_log_ids:
-        delegated_counts = count_tokens_for_log_id(delegated_id)
+        delegated_counts = await count_tokens_for_log_id(delegated_id)
         if delegated_counts:
             combined_counts['input_tokens_sequence'] += delegated_counts['input_tokens_sequence']
             combined_counts['output_tokens_sequence'] += delegated_counts['output_tokens_sequence']
@@ -196,6 +202,6 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     token_counts['combined_input_tokens_total'] = combined_counts['input_tokens_total']
     
     # Save to cache
-    save_token_counts_to_cache(log_id, token_counts)
+    await save_token_counts_to_cache(log_id, token_counts)
     
     return token_counts

{mindroot-8.13.0 → mindroot-9.0.0/src/mindroot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindroot
-Version: 8.13.0
+Version: 9.0.0
 Summary: MindRoot AI Agent Framework
 Requires-Python: >=3.9
 License-File: LICENSE