mindroot 8.9.0__tar.gz → 8.10.0__tar.gz

{mindroot-8.9.0/src/mindroot.egg-info → mindroot-8.10.0}/PKG-INFO

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

{mindroot-8.9.0 → mindroot-8.10.0}/pyproject.toml

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

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/coreplugins/admin/static/js/agent-form.js

@@ -67,6 +67,10 @@ class AgentForm extends BaseEl {
       background: rgba(255, 255, 255, 0.02);
     }
 
+    .form-hidden-when-no-agent {
+      display: none !important;
+    }
+
     .form-group {
       margin-bottom: 15px;
     }
@@ -1030,13 +1034,26 @@ class AgentForm extends BaseEl {
   }
 
   _render() {
+    // Default structure for rendering when this.agent is null
+    // This ensures the DOM structure is present but hidden.
+    const agentForRender = this.agent || {
+      name: '',
+      persona: '',
+      instructions: '',
+      technicalInstructions: '',
+      uncensored: false,
+      thinking_level: 'off',
+      // commands, preferred_providers, etc., are handled by helper functions
+      // which use optional chaining (this.agent?.property) and are safe.
+    };
+
     return html`
       <div class="agent-selector">
         <select @change=${this.handleAgentChange} 
                 .value=${this.selectedAgentName || ''}>
           <option value="">Select an agent</option>
           ${this.agents.map(agent => html`
-            <option value=${agent.name} ?selected=${agent.name === this.selectedAgentName}>${agent.name}</option>
+            <option .value=${agent.name} ?selected=${agent.name === this.selectedAgentName}>${agent.name}</option>
           `)}
         </select>
         <button class="btn btn-secondary" @click=${this.handleNewAgent}>
@@ -1044,23 +1061,22 @@ class AgentForm extends BaseEl {
         </button>
       </div>
 
-      ${this.agent ? html`
-        <form class="agent-form" @submit=${this.handleSubmit}>
+      <form class="agent-form ${!this.agent ? 'form-hidden-when-no-agent' : ''}" @submit=${this.handleSubmit}>
           <div class="form-group">
             <label class="required">Name:</label>
             <input type="text" name="name" 
-                   .value=${this.agent.name || ''} 
+                   .value=${agentForRender.name || ''} 
                    @input=${this.handleInputChange}>
           </div>
 
           <div class="form-group">
             <label class="required">Persona:</label>
             <select name="persona" 
-                    value=${this.agent.persona || ''}
+                    .value=${agentForRender.persona || ''}
                     @change=${this.handleInputChange}>
               <option value="">Select a persona</option>
               ${this.personas.map(persona => html`
-                <option value="${persona.name}" ?selected=${persona.name === this.agent.persona}>${persona.name}</option>
+                <option value="${persona.name}" ?selected=${persona.name === agentForRender.persona}>${persona.name}</option>
               `)}
             </select>
           </div>
@@ -1084,11 +1100,11 @@ class AgentForm extends BaseEl {
             </div>
             ${this.showInstructionsEditor ? html`
               <textarea name="instructions" 
-                      .value=${this.agent.instructions || ''}
+                      .value=${agentForRender.instructions || ''}
                       @input=${this.handleInputChange}></textarea>
             ` : html`
               <div class="markdown-preview">
-                ${unsafeHTML(this.renderMarkdown(this.agent.instructions || ''))}
+                ${unsafeHTML(this.renderMarkdown(agentForRender.instructions || ''))}
               </div>
             `}
           </div>
@@ -1112,11 +1128,11 @@ class AgentForm extends BaseEl {
             </div>
             ${this.showTechnicalInstructionsEditor ? html`
               <textarea name="technicalInstructions" 
-                      .value=${this.agent.technicalInstructions || ''}
+                      .value=${agentForRender.technicalInstructions || ''}
                       @input=${this.handleInputChange}></textarea>
             ` : html`
               <div class="markdown-preview">
-                ${unsafeHTML(this.renderMarkdown(this.agent.technicalInstructions || ''))}
+                ${unsafeHTML(this.renderMarkdown(agentForRender.technicalInstructions || ''))}
               </div>
             `}
           </div>
@@ -1125,7 +1141,7 @@ class AgentForm extends BaseEl {
             <label>
               Uncensored:
               <toggle-switch 
-                .checked=${this.agent.uncensored || false}
+                .checked=${agentForRender.uncensored || false}
                 @toggle-change=${(e) => this.handleInputChange({ 
                   target: { 
                     name: 'uncensored', 
@@ -1140,22 +1156,22 @@ class AgentForm extends BaseEl {
           <div class="form-group reasoning-level-group">
             <label>Reasoning Effort:</label>
             <select name="thinking_level" 
-                   value=${this.agent.thinking_level || 'off'}
+                   .value=${agentForRender.thinking_level || 'off'}
                    @change=${this.handleInputChange}>
               <option value="off" 
-                     ?selected=${(this.agent.thinking_level || 'off') === 'off'}>
+                     ?selected=${(agentForRender.thinking_level || 'off') === 'off'}>
                 Off
               </option> 
               <option value="low" 
-                     ?selected=${(this.agent.thinking_level || 'off') === 'low'}>
+                     ?selected=${(agentForRender.thinking_level || 'off') === 'low'}>
                 Low
               </option>
               <option value="medium" 
-                     ?selected=${(this.agent.thinking_level || 'off') === 'medium'}>
+                     ?selected=${(agentForRender.thinking_level || 'off') === 'medium'}>
                 Medium
               </option>
               <option value="high" 
-                     ?selected=${(this.agent.thinking_level || 'off') === 'high'}>
+                     ?selected=${(agentForRender.thinking_level || 'off') === 'high'}>
                 High
               </option>
             </select>
@@ -1184,11 +1200,11 @@ class AgentForm extends BaseEl {
             </details>
           </div>
 
-          ${this.agent.name && this.missingCommands && Object.keys(this.missingCommands).length > 0 ? html`
+          ${this.agent?.name && this.missingCommands && Object.keys(this.missingCommands).length > 0 ? html`
             <div class="form-group commands-section">
               <details>
                 <summary>Missing Commands (${Object.keys(this.missingCommands).length})</summary>
-                <missing-commands .agentName=${this.agent.name}></missing-commands>
+                <missing-commands .agentName=${this.agent.name}></missing-commands> <!-- this.agent.name is safe due to condition -->
               </details>
             </div>
           ` : ''}
@@ -1203,13 +1219,13 @@ class AgentForm extends BaseEl {
           <button class="btn" type="submit" ?disabled=${this.loading}>
             ${this.loading ? 'Saving...' : 'Save'}
           </button>
-          
-        </form>
-      ` : html`
+      </form>
+
+      ${!this.agent ? html`
         <div class="no-agent-message">
           Select an agent from the dropdown above or click "New Agent" to create one.
         </div>
-      `}
+      ` : ''}
     `;
    }
 }

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/coreplugins/agent/templates/system.jinja2

@@ -357,3 +357,21 @@ If you do not do this, then your reasoning will not make it into the chat histor
 and you will end up repeating the same thought process after every command!
 
 {% endblock %}
+
+{% block reasoning_reminder_3 %}
+
+# Reasonable Reasoning for Commands
+
+IMPORTANT: 
+
+If you have a built-in thinking/reasoning stage and are handling a multiple step
+or iterative process, **DO NOT TRY TO PLAN THE DETAILS OF ALL STEPS IN ADVANCE**.
+Your built-in reasoning efforts are discarded after each batch of commands you output.
+So planning all of the remaining steps in advance each time is very wasteful.
+Instead, you should **only plan for the next few commands that you need to execute**.
+Then you can adjust based on the output of your commands which will be returned
+by the system.
+
+{% endblock %}
+
+

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/coreplugins/chat/commands.py

@@ -127,7 +127,15 @@ async def delegate_task(instructions: str, agent_name, log_id=None, retries=3, c
     Note: do not specify any other arguments than those in the example.
     In particular, 'context' is not a valid argument!
 
-    Use something unique for the log_id.
+    log_id is optional, if you specify it you must use something unique.
+
+    You can also let the system assign log_id automatically:
+
+    Example:
+
+    { "delegate_task": { "instructions": "Write a poem about the moon", "agent_name": "poet" } }
+
+
     """
     print("in delegate task, context is:")
     print(context)
@@ -140,8 +148,9 @@ async def delegate_task(instructions: str, agent_name, log_id=None, retries=3, c
         elif 'llm' in context.data:
             llm = context.data['llm']
     (text, full_results, xx) = await service_manager.run_task(instructions, user=context.username, log_id=log_id,
+                                                              parent_log_id = context.log_id,
                                                               llm=llm, agent_name=agent_name, retries=retries, context=None)
-    return f"""<a href="/session/{agent_name}/{log_id}" target="_blank">Task completed in log ID: {log_id}</a>\nResults:\n\n{text}"""
+    return f"""<a href="/session/{agent_name}/{log_id}" target="_blank">Task completed with log ID: {log_id}</a>\nResults:\n\n{text}"""
 
 
 @command()

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/coreplugins/chat/router.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Request, Response
+from fastapi import APIRouter, HTTPException, Request, Response, Depends
 from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi import File, UploadFile, Form
 from sse_starlette.sse import EventSourceResponse
@@ -6,6 +6,7 @@ from .models import MessageParts
 from lib.providers.services import service, service_manager
 from .services import init_chat_session, send_message_to_agent, subscribe_to_agent_messages, get_chat_history, run_task
 from lib.templates import render
+from lib.auth.auth import require_user
 from lib.plugins import list_enabled
 import nanoid
 from lib.providers.commands import *
@@ -17,6 +18,8 @@ from lib.providers.commands import command_manager
 from lib.utils.debug import debug_box
 from lib.session_files import load_session_data, save_session_data
 import os
+import json
+from lib.chatcontext import ChatContext
 import shutil
 from pydantic import BaseModel
 
@@ -241,6 +244,50 @@ async def get_token_count(request: Request, log_id: str):
     
     return {"status": "ok", "token_counts": token_counts}
 
+@router.get("/chat/del_session/{log_id}")
+async def delete_chat_session(request: Request, log_id: str, user=Depends(require_user)):
+    """
+    Delete a chat session by log_id, including chat logs, context files, and all child sessions.
+    
+    Parameters:
+    - log_id: The log ID of the session to delete
+    
+    Returns:
+    - JSON with success status and message
+    """
+    try:
+        # Try to determine the agent name from the context file first
+        agent_name = "unknown"
+        context_file_path = f"data/context/{user.username}/context_{log_id}.json"
+        
+        if os.path.exists(context_file_path):
+            try:
+                with open(context_file_path, 'r') as f:
+                    context_data = json.load(f)
+                    agent_name = context_data.get('agent_name', 'unknown')
+                    print(f"Found agent name '{agent_name}' from context file for log_id {log_id}")
+            except Exception as e:
+                print(f"Error reading context file {context_file_path}: {e}")
+        
+        # If we still don't have the agent name, try to find the chatlog file
+        if agent_name == "unknown":
+            from lib.chatlog import find_chatlog_file
+            chatlog_path = find_chatlog_file(log_id)
+            if chatlog_path:
+                # Extract agent from path: data/chat/{user}/{agent}/chatlog_{log_id}.json
+                path_parts = chatlog_path.split(os.sep)
+                if len(path_parts) >= 3:
+                    agent_name = path_parts[-2]  # Agent is the second-to-last part
+                    print(f"Found agent name '{agent_name}' from chatlog file path for log_id {log_id}")
+        
+        await ChatContext.delete_session_by_id(log_id=log_id, user=user.username, agent=agent_name, cascade=True)
+        
+        return {"status": "ok", "message": f"Chat session {log_id} deleted successfully"}
+    except Exception as e:
+        print(f"Error deleting chat session {log_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Error deleting chat session: {str(e)}")
+
+
 @router.get("/chat/{log_id}/tokens")
 async def get_token_count(request: Request, log_id: str):
     """

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/coreplugins/chat/services.py

@@ -50,7 +50,8 @@ def results_text_output(results):
 
     
 @service()
-async def run_task(instructions: str, agent_name:str = None, user:str = None, log_id=None, llm=None, retries=3, context=None):
+async def run_task(instructions: str, agent_name:str = None, user:str = None, log_id=None, 
+                   parent_log_id=None, llm=None, retries=3, context=None):
     """
     Run a task with the given instructions
     IMPORTANT NOTE: agent must have the task_result() command enabled.
@@ -70,10 +71,11 @@ async def run_task(instructions: str, agent_name:str = None, user:str = None, lo
         context.username = user
         context.name = agent_name
         context.log_id = log_id
+        context.parent_log_id = parent_log_id
         context.agent = await service_manager.get_agent_data(agent_name)
         context.data['llm'] = llm
         context.current_model = llm
-        context.chat_log = ChatLog(log_id=log_id, agent=agent_name, user=user)
+        context.chat_log = ChatLog(log_id=log_id, agent=agent_name, user=user, parent_log_id=parent_log_id)
         context.save_context()
     else:
         debug_box("Context is not none")

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/lib/chatcontext.py

@@ -3,7 +3,8 @@ from .providers.commands import command_manager
 import os
 import json
 from .chatlog import ChatLog
-from typing import TypeVar, Type, Protocol, runtime_checkable
+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
 from .utils.debug import debug_box
 contexts = {}
 
@@ -29,7 +30,7 @@ CommandSetT = TypeVar('CommandSetT', bound=BaseCommandSet)
 
 class ChatContext:
 
-    def __init__(self, command_manager_=None, service_manager_=None, user=None, log_id=None):
+    def __init__(self, command_manager_=None, service_manager_=None, user=None, log_id=None, parent_log_id=None):
         if not user:
             raise ValueError('User is required to create a chat context')
         else:
@@ -39,6 +40,7 @@ class ChatContext:
         self._commands = command_manager.functions
         self._services = service_manager.functions
         self.response_started = False
+        self.current_model = None
         self.uncensored = False
         if user is None:
             raise ValueError('User is required to create a chat context. Use SYSTEM if no user')
@@ -66,6 +68,7 @@ class ChatContext:
         self.agent_name = None
         self.name = None
         self.log_id = None
+        self.parent_log_id = None
         if log_id is not None:
             self.log_id = log_id
         else:
@@ -142,7 +145,10 @@ class ChatContext:
                 pass
             self.flags = self.agent.get('flags', [])
             self.data['log_id'] = log_id
-            self.chat_log = ChatLog(log_id=log_id, agent=self.agent_name, user=self.username)
+            parent_log_id = None
+            if self.parent_log_id:
+                parent_log_id = self.parent_log_id
+            self.chat_log = ChatLog(log_id=log_id, agent=self.agent_name, user=self.username, parent_log_id=parent_log_id)
             self.uncensored = True
         else:
             raise ValueError('Context file not found for id:', log_id)
@@ -160,5 +166,95 @@ class ChatContext:
         if name in self._commands:
             self.command_manager.context = self
             return getattr(self.command_manager, name)
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    @classmethod
+    async def delete_session_by_id(cls, log_id: str, user: str, agent: str, cascade: bool = True, visited_log_ids: Set[str] = None):
+        if visited_log_ids is None:
+            visited_log_ids = set()
+
+        if log_id in visited_log_ids:
+            print(f"Skipping already visited log_id for deletion: {log_id}")
+            return
+        visited_log_ids.add(log_id)
+
+        print(f"Attempting to delete session: log_id={log_id}, user={user}, agent={agent}")
+
+        # --- Cascading Deletion ---
+        if cascade:
+            messages_for_child_finding = []
+            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):
+                try:
+                    with open(chatlog_file_path_current, 'r') as f:
+                        log_data = json.load(f)
+                        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)
+            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
+                if child_log_path:
+                    try:
+                        relative_path = os.path.relpath(child_log_path, chatlog_dir_base)
+                        path_components = relative_path.split(os.sep)
+                        # Expecting {user}/{agent}/chatlog_{child_id}.json
+                        if len(path_components) >= 3 and path_components[-1] == f"chatlog_{child_id}.json":
+                            child_user = path_components[0]
+                            child_agent = path_components[1]
+                            print(f"Recursively deleting child session: log_id={child_id}, user={child_user}, agent={child_agent}")
+                            await cls.delete_session_by_id(child_id, child_user, child_agent, cascade=True, visited_log_ids=visited_log_ids)
+                        else:
+                            print(f"Could not parse user/agent from child log path: {child_log_path} relative to {chatlog_dir_base}")
+                    except Exception as e:
+                        print(f"Error processing child log {child_id} (path: {child_log_path}): {e}")
+                else:
+                    print(f"Could not find chatlog file for child_id: {child_id} during cascade.")
+
+        # --- 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):
+            try:
+                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}")
         else:
-            pass
+            print(f"Chatlog file not found for deletion: {chatlog_file_to_delete}")
+
+        # 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):
+            try:
+                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}")
+        else:
+            print(f"Context file not found for deletion: {context_file_to_delete}")
+            
+        # --- Clear In-Memory Cache ---
+        if log_id in contexts: # 'contexts' is the global dict at module level
+            try:
+                del contexts[log_id]
+                print(f"Removed log_id {log_id} from in-memory contexts cache.")
+            except Exception as e:
+                print(f"Error removing log_id {log_id} from in-memory contexts cache: {e}")
+
+    async def delete(self, cascade: bool = True):
+        if not self.log_id or not self.username or not self.agent_name:
+            error_msg = "log_id, username, or agent_name not set on ChatContext instance. Cannot call instance delete."
+            print(f"Error: {error_msg}")
+            raise ValueError(error_msg)
+        
+        print(f"Instance delete called for log_id={self.log_id}, user={self.username}, agent={self.agent_name}")
+        await ChatContext.delete_session_by_id(self.log_id, self.username, self.agent_name, cascade=cascade)

{mindroot-8.9.0 → mindroot-8.10.0}/src/mindroot/lib/chatlog.py

@@ -8,9 +8,10 @@ import time
 from mindroot.lib.utils.debug import debug_box
 
 class ChatLog:
-    def __init__(self, log_id=0, agent=None, context_length: int = 4096, user: str = None):
+    def __init__(self, log_id=0, agent=None, parent_log_id=None, context_length: int = 4096, user: str = None):
         self.log_id = log_id
         self.messages = []
+        self.parent_log_id = parent_log_id
         self.agent = agent
         if user is None or user == '' or user == 'None':
             raise ValueError('User must be provided')
@@ -32,10 +33,13 @@ class ChatLog:
         if not os.path.exists(self.log_dir):
             os.makedirs(self.log_dir)
         self.load_log()
+        
     def _get_log_data(self) -> Dict[str, any]:
         return {
             'agent': self.agent,
-            'messages': self.messages
+            'log_id': self.log_id,
+            'messages': self.messages,
+            'parent_log_id': self.parent_log_id
         }
 
     def _calculate_message_length(self, message: Dict[str, str]) -> int:
@@ -124,20 +128,13 @@ class ChatLog:
                 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 delete_log(self) -> None:
-        log_file = os.path.join(self.log_dir, f'chatlog_{self.log_id}.json')
-        if os.path.exists(log_file):
-            os.remove(log_file)
-            print("Deleted log file at ", log_file)
-        else:
-            print("Could not find log file at ", log_file)
-
     def count_tokens(self) -> Dict[str, int]:
         """
         Count tokens in the chat log, providing both sequence totals and cumulative request totals.
@@ -198,6 +195,34 @@ def find_chatlog_file(log_id: str) -> str:
     
     return None
 
+def find_child_logs_by_parent_id(parent_log_id: str) -> List[str]:
+    """
+    Find all chat logs that have the given parent_log_id.
+    
+    Args:
+        parent_log_id: The parent log ID to search for
+        
+    Returns:
+        List of log IDs that have this parent_log_id
+    """
+    child_log_ids = []
+    chat_dir = os.environ.get('CHATLOG_DIR', 'data/chat')
+    
+    # Search through all chatlog files
+    for root, dirs, files in 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)
+                        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'))
+                except (json.JSONDecodeError, IOError):
+                    continue
+    
+    return child_log_ids
+
 def extract_delegate_task_log_ids(messages: List[Dict]) -> List[str]:
     """
     Extract log IDs from delegate_task commands in messages.
@@ -331,6 +356,9 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Load the chat log
     with open(chatlog_path, 'r') as f:
         log_data = json.load(f)
+    
+    # Get parent_log_id if it exists
+    parent_log_id = log_data.get('parent_log_id')
         
     # Create a temporary ChatLog instance to count tokens
     temp_log = ChatLog(log_id=log_id, user="system", agent=log_data.get('agent', 'unknown'))
@@ -349,9 +377,19 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Find delegated task log IDs
     delegated_log_ids = extract_delegate_task_log_ids(temp_log.messages)
     
-    # Recursively count tokens for delegated tasks
-    for delegated_id in delegated_log_ids:
-        delegated_counts = count_tokens_for_log_id(delegated_id)
+    # Also find child logs by parent_log_id
+    child_logs_by_parent = 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)
+    
+    # If this log has a parent_log_id, we should not double-count it
+    # (it will be counted as part of its parent's cumulative total)
+    # But we still want to count its own children
+    
+    # Recursively count tokens for all child tasks
+    for child_id in all_child_log_ids:
+        delegated_counts = 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']
@@ -372,4 +410,4 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Save to cache
     save_token_counts_to_cache(log_id, token_counts)
     
-    return token_counts
+    return token_counts

{mindroot-8.9.0 → mindroot-8.10.0/src/mindroot.egg-info}/PKG-INFO

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