mindroot 10.4.0__py3-none-any.whl → 10.6.0__py3-none-any.whl

mindroot/coreplugins/admin/static/js/agent-form.js

@@ -658,7 +658,14 @@ class AgentForm extends BaseEl {
     }
     console.log('before',this.agent)
     // Handle all other inputs
-    const inputValue = type === 'checkbox' ? checked : value;
+    let inputValue;
+    if (type === 'checkbox') {
+      inputValue = checked;
+    } else if (type === 'number') {
+      inputValue = value === '' ? null : Number(value);
+    } else {
+      inputValue = value;
+    }
     this.agent = { ...this.agent, [name]: inputValue };
     console.log('after', this.agent)
   }
@@ -1273,6 +1280,24 @@ class AgentForm extends BaseEl {
             </details>
           </div> 
 
+          <div class="form-group commands-section">
+            <details>
+              <summary>Max Tokens</summary>
+              <div class="commands-category">
+                <div class="form-group">
+                  <label>Maximum Tokens:</label>
+                  <input 
+                    type="number" 
+                    name="max_tokens" 
+                    .value=${agentForRender.max_tokens || ''}
+                    placeholder="Leave empty for model default"
+                    @input=${this.handleInputChange}
+                  >
+                </div>
+              </div>
+            </details>
+          </div>
+
           <div class="form-group commands-section">
             <details>
               <summary>Recommended Plugins</summary>

mindroot/coreplugins/admin/static/js/persona-editor.js

@@ -10,7 +10,8 @@ class PersonaEditor extends BaseEl {
     personas: { type: Array, reflect: true },
     newPersona: { type: Boolean, reflect: true },
     facerefFileName: { type: String, reflect: true },
-    avatarFileName: { type: String, reflect: true }
+    avatarFileName: { type: String, reflect: true },
+    voiceId: { type: String, reflect: true }
   };
 
   static styles = [
@@ -130,6 +131,7 @@ class PersonaEditor extends BaseEl {
     this.newPersona = false;
     this.facerefFileName = '';
     this.avatarFileName = '';
+    this.voiceId = '';
     this.fetchPersonas();
   }
 
@@ -168,13 +170,16 @@ class PersonaEditor extends BaseEl {
       if (this.scope === 'registry') {
         // For registry personas, use the full path format
         const response = await fetch(`/personas/registry/${this.name}`);
+        this.voiceId = this.persona.voice_id || '';
         this.persona = await response.json();
       } else {
         const response = await fetch(`/personas/${this.scope}/${this.name}`);
         this.persona = await response.json();
+        this.voiceId = this.persona.voice_id || '';
       }
     } else {
       this.persona = {};
+      this.voiceId = '';
     }
   }
 
@@ -194,11 +199,15 @@ class PersonaEditor extends BaseEl {
     this.persona = {};
     this.facerefFileName = '';
     this.avatarFileName = '';
+    this.voiceId = '';
   }
 
   handleInputChange(event) {
     const { name, value, type, checked } = event.target;
     const inputValue = type === 'checkbox' ? checked : value;
+    if (name === 'voice_id') {
+      this.voiceId = value;
+    }
     this.persona = { ...this.persona, [name]: inputValue };
   }
 
@@ -280,6 +289,10 @@ class PersonaEditor extends BaseEl {
             <label>Negative Appearance:</label>
             <textarea class="text_lg" name="negative_appearance" .value=${this.persona.negative_appearance || ''} @input=${this.handleInputChange}></textarea>
           </div>
+          <div class="form-group">
+            <label>Voice ID:</label>
+            <input class="text_inp" type="text" name="voice_id" .value=${this.voiceId || ''} @input=${this.handleInputChange} placeholder="Optional voice identifier for TTS" />
+          </div>
           <div class="form-group">
         <label>
           Moderated:

mindroot/coreplugins/agent/agent.py

@@ -340,7 +340,8 @@ class Agent:
                         logger.debug(f"Processing command: {cmd}")
                         await context.partial_command(cmd_name, json.dumps(cmd_args), cmd_args)
 
-                        # Create a task for the command so it can be cancelled
+                        self.handle_cmds(cmd_name, cmd_args, json_cmd=json.dumps(cmd), context=context)
+ 
                         cmd_task = asyncio.create_task(
                             self.handle_cmds(cmd_name, cmd_args, json_cmd=json.dumps(cmd), context=context)
                         )
@@ -355,6 +356,14 @@ class Agent:
                         await context.command_result(cmd_name, result)
                         sys_header = "Note: tool command results follow, not user replies" 
                         sys_header = ""
+
+                        if result == "SYSTEM: WARNING - Command interrupted!\n\n":
+                            logger.warning("Command was interrupted. Skipping any extra commands in list.")
+                            await context.chat_log.drop_last('assistant')
+                            return results, full_cmds
+                            break
+
+
                         full_cmds.append({ "SYSTEM": sys_header, "cmd": cmd_name, "args": cmd_args, "result": result})
                         if result is not None:
                             results.append({"SYSTEM": sys_header, "cmd": cmd_name, "args": { "omitted": "(see command msg.)"}, "result": result})
@@ -473,6 +482,7 @@ class Agent:
             tmp_data = { "messages": new_messages }
             debug_box("Filtering messages")
             #debug_box(tmp_data)
+
             tmp_data = await pipeline_manager.filter_messages(tmp_data, context=context)
             new_messages = tmp_data['messages']
         except Exception as e:
@@ -487,6 +497,12 @@ class Agent:
         if not isinstance(context.agent, dict):
             context.agent = await get_agent_data(context.agent, context=context)
 
+        if 'max_tokens' in context.agent and context.agent['max_tokens'] is not None and context.agent['max_tokens'] != '':
+            logger.info(f"Using agent max tokens {max_tokens}")
+            max_tokens = context.agent['max_tokens']
+        else:
+            logger.info(f"Using default max tokens {max_tokens}")
+
         if model is None:
             if 'service_models' in context.agent and context.agent['service_models'] is not None:
                 if context.agent['service_models'].get('stream_chat', None) is None:

mindroot/coreplugins/chat/edit_router.py

@@ -0,0 +1,495 @@
+from fastapi import APIRouter, HTTPException, Request, Response, Depends, Query
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
+from fastapi import File, UploadFile, Form
+from sse_starlette.sse import EventSourceResponse
+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 *
+import asyncio
+from lib.chatcontext import get_context, ChatContext
+from typing import List
+from lib.providers.services import service, service_manager
+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
+from lib.auth.api_key import verify_api_key
+from .services import active_send_tasks, cancel_active_send_task, get_active_send_tasks, cleanup_completed_tasks
+
+router = APIRouter()
+
+# Global dictionary to store tasks
+tasks = {}
+
+@router.post("/chat/{log_id}/{task_id}/cancel")
+async def cancel_chat(request: Request, log_id: str, task_id: str):
+    debug_box("cancel_chat")
+    print("Trying to cancel task", task_id)
+    user = request.state.user.username
+    context = await get_context(log_id, user)
+    debug_box(str(context))
+
+    # Cancel the active send_message_to_agent task if it exists
+    if log_id in active_send_tasks:
+        task_info = active_send_tasks[log_id]
+        task = task_info['task']
+        
+        if not task.done():
+            print(f"Cancelling active send_message_to_agent task for session {log_id}")
+            task.cancel()
+            context.data['task_cancelled'] = True
+            context.data['cancel_current_turn'] = True
+            
+            # Also cancel the router task if it exists
+            if task_id in tasks:
+                tasks[task_id].cancel()
+                del tasks[task_id]
+            
+            return {"status": "ok", "message": "Task cancelled successfully"}
+        else:
+            return {"status": "error", "message": "No active task found"}
+    else:
+        return {"status": "error", "message": "No active task found for this session"}
+
+
+@router.get("/context1/{log_id}")
+async def context1(request: Request, log_id: str):
+    user = request.state.user.username
+    context = await get_context(log_id, user)
+    print(context)
+    return "ok"
+
+
+# need to serve persona images from ./personas/local/[persona_path]/avatar.png
+@router.get("/chat/personas/{persona_path:path}/avatar.png")
+async def get_persona_avatar(persona_path: str):
+    # Check if this is a registry persona with deduplicated assets
+    if persona_path.startswith("registry/"):
+        persona_json_path = f"personas/{persona_path}/persona.json"
+        if os.path.exists(persona_json_path):
+            try:
+                with open(persona_json_path, "r") as f:
+                    persona_data = json.load(f)
+                
+                # Check if persona has asset hashes (deduplicated storage)
+                asset_hashes = persona_data.get("asset_hashes", {})
+                if "avatar" in asset_hashes:
+                    # Redirect to deduplicated asset endpoint
+                    return RedirectResponse(f"/assets/{asset_hashes['avatar']}")
+            except Exception as e:
+                print(f"Error checking for deduplicated assets: {e}")
+    
+    # Handle registry personas: registry/owner/name
+    if persona_path.startswith('registry/'):
+        file_path = f"personas/{persona_path}/avatar.png"
+    else:
+        # Legacy support: check local first, then shared
+        file_path = f"personas/local/{persona_path}/avatar.png"
+        if not os.path.exists(file_path):
+            file_path = f"personas/registry/{persona_path}/avatar.png"
+    
+    if not os.path.exists(file_path):
+        resolved =  os.path.realpath(file_path)
+        return {"error": "File not found: " + resolved}
+        
+    with open(file_path, "rb") as f:
+        image_bytes = f.read()
+    
+    return Response(
+        content=image_bytes, 
+        media_type="image/png",
+        headers={
+            "Cache-Control": "max-age=3600",
+            "Content-Disposition": "inline; filename=avatar.png"
+        }
+    )
+
+@router.get("/chat/personas/{persona_path:path}/faceref.png")
+async def get_persona_faceref(persona_path: str):
+    # Check if this is a registry persona with deduplicated assets
+    if persona_path.startswith("registry/"):
+        persona_json_path = f"personas/{persona_path}/persona.json"
+        if os.path.exists(persona_json_path):
+            try:
+                with open(persona_json_path, "r") as f:
+                    persona_data = json.load(f)
+                
+                # Check if persona has asset hashes (deduplicated storage)
+                asset_hashes = persona_data.get("asset_hashes", {})
+                if "faceref" in asset_hashes:
+                    # Redirect to deduplicated asset endpoint
+                    return RedirectResponse(f"/assets/{asset_hashes['faceref']}")
+            except Exception as e:
+                print(f"Error checking for deduplicated assets: {e}")
+    
+    # Handle registry personas: registry/owner/name
+    if persona_path.startswith('registry/'):
+        file_path = f"personas/{persona_path}/faceref.png"
+    else:
+        # Legacy support: check local first, then shared
+        file_path = f"personas/local/{persona_path}/faceref.png"
+        if not os.path.exists(file_path):
+            file_path = f"personas/registry/{persona_path}/faceref.png"
+    
+    if not os.path.exists(file_path):
+        # Fallback to avatar if faceref doesn't exist
+        return RedirectResponse(f"/chat/personas/{persona_path}/avatar.png")
+        
+    with open(file_path, "rb") as f:
+        image_bytes = f.read()
+    
+    return Response(
+        content=image_bytes, 
+        media_type="image/png",
+        headers={
+            "Cache-Control": "max-age=3600",
+            "Content-Disposition": "inline; filename=faceref.png"
+        }
+    )
+
+@router.get("/chat/{log_id}/events")
+async def chat_events(log_id: str):
+    return EventSourceResponse(await subscribe_to_agent_messages(log_id))
+
+
+@router.post("/chat/{log_id}/send")
+async def send_message(request: Request, log_id: str, message_parts: List[MessageParts] ):
+    user = request.state.user
+    debug_box("send_message")
+
+
+    context = await get_context(log_id, user.username)
+    debug_box(str(context))
+    #context = ChatContext(command_manager, service_manager, user=user.user)
+    task = asyncio.create_task(send_message_to_agent(log_id, message_parts, context=context, user=user))
+    #task = asyncio.create_task(send_message_to_agent(log_id, message_parts, user=user))
+     
+    task_id = nanoid.generate()
+    
+    
+    # Check if there's already an active task for this session and cancel it
+    if log_id in active_send_tasks:
+        existing_task_info = active_send_tasks[log_id]
+        existing_task = existing_task_info['task']
+        if not existing_task.done():
+            print(f"Cancelling existing task for session {log_id} before starting new one")
+            existing_task.cancel()
+
+    tasks[task_id] = task
+    
+    return {"status": "ok", "task_id": task_id}
+
+@router.get("/chat/{log_id}/active_tasks")
+async def get_active_tasks(request: Request, log_id: str):
+    """
+    Get information about active tasks for a session (for debugging)
+    """
+    user = request.state.user.username
+    
+    active_info = {}
+    if log_id in active_send_tasks:
+        task_info = active_send_tasks[log_id]
+        task = task_info['task']
+        active_info = {
+            "session_id": log_id,
+            "task_active": not task.done(),
+            "task_cancelled": task.cancelled() if task else False,
+            "created_at": task_info.get('created_at'),
+            "router_tasks": [tid for tid, t in tasks.items() if not t.done()]
+        }
+    
+    return {"status": "ok", "active_tasks": active_info}
+
+@router.post("/chat/{log_id}/cancel_send_task")
+async def cancel_send_task_endpoint(request: Request, log_id: str):
+    """
+    Cancel the active send_message_to_agent task for a session.
+    """
+    user = request.state.user.username
+    context = await get_context(log_id, user)
+    
+    result = await cancel_active_send_task(log_id, context=context)
+    return result
+
+@router.get("/chat/active_send_tasks")
+async def get_all_active_send_tasks(request: Request):
+    """
+    Get information about all active send_message_to_agent tasks.
+    """
+    result = await get_active_send_tasks()
+    return result
+
+@router.post("/chat/cleanup_completed_tasks")
+async def cleanup_completed_tasks_endpoint(request: Request):
+    """
+    Clean up completed tasks from memory.
+    """
+    result = await cleanup_completed_tasks()
+    return result
+
+@router.get("/agent/{agent_name}", response_class=HTMLResponse)
+async def get_chat_html(request: Request, agent_name: str, api_key: str = Query(None), embed: bool = Query(False)):
+    # Handle API key authentication if provided
+    if api_key:
+        try:
+            user_data = await verify_api_key(api_key)
+            if not user_data:
+                raise HTTPException(status_code=401, detail="Invalid API key")
+            # Create a mock user object for API key users
+            class MockUser:
+                def __init__(self, username):
+                    self.username = username
+            user = MockUser(user_data['username'])
+        except Exception as e:
+            raise HTTPException(status_code=401, detail="Invalid API key")
+    else:
+        # Use regular authentication
+        if not hasattr(request.state, "user"):
+            return RedirectResponse("/login")
+        user = request.state.user
+    
+    log_id = nanoid.generate()
+    plugins = list_enabled()
+    print("Init chat with user", user)
+    print(f"Init chat with {agent_name}")
+    await init_chat_session(user, agent_name, log_id)
+
+    if hasattr(request.state, "access_token"):
+        debug_box("Access token found in request state, saving to session file")
+        access_token = request.state.access_token
+        await save_session_data(log_id, "access_token", access_token)
+        print("..")
+        debug_box("Access token saved to session file")
+    else:
+        debug_box("No access token found in request state")
+    
+    # If embed mode is requested, redirect to embed session
+    if embed:
+        return RedirectResponse(f"/session/{agent_name}/{log_id}?embed=true")
+    
+    # Regular redirect
+    return RedirectResponse(f"/session/{agent_name}/{log_id}")
+
+@router.get("/makesession/{agent_name}")
+async def make_session(request: Request, agent_name: str):
+    """
+    Create a new chat session for the specified agent.
+    Returns a redirect to the chat session page.
+    """
+    if not hasattr(request.state, "user"):
+        return RedirectResponse("/login")
+    user = request.state.user
+    log_id = nanoid.generate()
+    
+    await init_chat_session(user, agent_name, log_id)
+    return JSONResponse({ "log_id": log_id })
+
+@router.get("/history/{agent_name}/{log_id}")
+async def chat_history(request: Request, agent_name: str, log_id: str):
+    user = request.state.user.username
+    history = await get_chat_history(agent_name, log_id, user)
+    if history is None or len(history) == 0:
+        try:
+            print("trying to load from system session")
+            history = await get_chat_history(agent_name, log_id, "system")
+        except Exception as e:
+            print("Error loading from system session:", e)
+            history = []
+            pass
+    return history
+
+@router.get("/session/{agent_name}/{log_id}")
+async def chat_session(request: Request, agent_name: str, log_id: str, embed: bool = Query(False)):
+    # Check authentication (API key or regular user)
+    plugins = list_enabled()
+    if not hasattr(request.state, "user"):
+        return RedirectResponse("/login")
+
+    user = request.state.user
+    agent = await service_manager.get_agent_data(agent_name)  
+    persona = agent['persona']['name']
+    print("persona is:", persona)
+    auth_token = None
+    try:
+        auth_token = await load_session_data(log_id, "access_token")
+    except:
+        pass
+    chat_data = {"log_id": log_id, "agent_name": agent_name, "user": user, "persona": persona }
+
+    if auth_token is not None:
+        chat_data["access_token"] = auth_token
+    
+    # Add embed mode flag
+    if embed:
+        chat_data["embed_mode"] = True
+
+    html = await render('chat', chat_data)
+    return HTMLResponse(html)
+
+# use starlette staticfiles to mount ./imgs
+    app.mount("/published", StaticFiles(directory=str(published_dir)), name="published_indices")
+
+class TaskRequest(BaseModel):
+    instructions: str
+
+@router.post("/task/{agent_name}")
+async def run_task_route(request: Request, agent_name: str, task_request: TaskRequest = None):
+    """
+    Run a task for an agent with the given instructions.
+    This endpoint allows programmatic interaction with agents without a full chat session.
+    
+    Parameters:
+    - agent_name: The name of the agent to run the task
+    - instructions: The instructions/prompt to send to the agent
+    
+    Returns:
+    - JSON with results and log_id for tracking
+    """
+    
+    user = request.state.user.username
+    
+    instructions = None
+    if task_request is not None:
+        instructions = task_request.instructions
+    
+    if not instructions:
+        return {"status": "error", "message": "No instructions provided"}
+    
+    task_result, full_results, log_id = await run_task(instructions=instructions, agent_name=agent_name, user=user)
+    print(task_result)
+    print(full_results)
+    print(log_id)
+    return {"status": "ok", "results": task_result, "full_results": full_results, "log_id": log_id}
+
+
+@router.post("/chat/{log_id}/upload")
+async def upload_file(request: Request, log_id: str, file: UploadFile = File(...)):
+    """
+    Upload a file and store it in a user-specific directory.
+    Returns the file path that can be used in messages.
+    """
+    user = request.state.user.username
+    
+    # Create user uploads directory if it doesn't exist
+    user_upload_dir = f"data/users/{user}/uploads/{log_id}"
+    os.makedirs(user_upload_dir, exist_ok=True)
+    
+    # Generate a safe filename to prevent path traversal
+    filename = os.path.basename(file.filename)
+    file_path = os.path.join(user_upload_dir, filename)
+    
+    # Save the file
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    # Return the file information
+    return {
+        "status": "ok",
+        "filename": filename,
+        "path": file_path,
+        "mime_type": file.content_type
+    }
+
+
+from lib.chatlog import count_tokens_for_log_id
+
+@router.get("/chat/{log_id}/tokens")
+async def get_token_count(request: Request, log_id: str):
+    """
+    Get token counts for a chat log identified by log_id, including any delegated tasks.
+    
+    Parameters:
+    - log_id: The log ID to count tokens for
+    
+    Returns:
+    - JSON with token counts or error message if log not found
+    """
+    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"}
+
+    
+    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_dir = os.environ.get('CHATCONTEXT_DIR', 'data/context')
+        context_file_path = f"{context_dir}/{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_alt(request: Request, log_id: str):
+    """
+    Alternative token count endpoint using token_counter module.
+    
+    Parameters:
+    - log_id: The log ID to count tokens for
+    
+    Returns:
+    - JSON with token counts or error message if log not found
+    """
+    from lib.token_counter import count_tokens_for_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"}
+
+    
+    return {"status": "ok", "token_counts": token_counts}
+
+# Include widget routes
+try:
+    from .widget_routes import router as widget_router
+    router.include_router(widget_router)
+except ImportError as e:
+    print(f"Warning: Could not load widget routes: {e}")

mindroot/coreplugins/chat/services.py

@@ -217,8 +217,25 @@ def process_result(result, formatted_results):
 
     return formatted_results
 
+in_progress = {}
+
 @service()
 async def send_message_to_agent(session_id: str, message: str | List[MessageParts], max_iterations=35, context=None, user=None):
+    global in_progress
+    existing_session = in_progress.get(session_id, False)
+    print(existing_session)
+
+    if existing_session:
+        context_ = await get_context(session_id, user)
+        context.data['finished_conversation'] = True
+        await asyncio.sleep(0.4)
+    else:
+        print('starting')
+
+    print('ok')
+    in_progress[session_id] = True
+
+    print('b')
     if os.environ.get("MR_MAX_ITERATIONS") is not None:
         max_iterations = int(os.environ.get("MR_MAX_ITERATIONS"))
     if not user:
@@ -399,10 +416,12 @@ async def send_message_to_agent(session_id: str, message: str | List[MessagePart
         print("Exiting send_message_to_agent: ", session_id, message, max_iterations)
 
         await context.finished_chat()
+        in_progress.pop(session_id, None)
         return [results, full_results]
     except Exception as e:
         print("Error in send_message_to_agent: ", e)
         print(traceback.format_exc())
+        in_progress.pop(session_id, None)
         return []
 
 @pipe(name='process_results', priority=5)
@@ -548,4 +567,4 @@ async def cancel_active_response(log_id: str, context=None):
     await context.save_context()
     
     print(f"Cancelled active response for session {log_id}")
-    return {"status": "cancelled", "log_id": log_id}
+    return {"status": "cancelled", "log_id": log_id}

mindroot/coreplugins/chat/templates/chat.jinja2

@@ -72,6 +72,10 @@
     </div>
     {% endblock %}
 
+    {% block post_content %}
+
+    {% endblock %}
+
   </div> <!-- page-container -->
   
   <script type="module" src="/chat/static/js/code-copy-button.js"></script>

mindroot/coreplugins/chat/widget_routes.py

@@ -241,7 +241,7 @@ async def get_embed_script(token: str):
                     iframe.style.cssText = "width: 100%; height: 100%; border: none; border-radius: 12px;";
                 }}
                 iframe.src = config.baseUrl + "/chat/widget/" + config.token + "/session";
-                iframe.allow = "microphone autoplay"
+                iframe.setAttribute('allow', 'microphone');
                 chatContainer.appendChild(iframe);
                 isLoaded = true;
             }}

mindroot/lib/chatlog.py

@@ -133,6 +133,7 @@ class ChatLog:
             debug_box("5")
             self.messages.append(message)
         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)
@@ -145,6 +146,13 @@ class ChatLog:
                 len(self.messages[-1]['content']) > 0 and 
                 self.messages[-1]['content'][0].get('type') == 'image'):
                 await self.save_log()
+    
+    async def drop_last(self, role) -> None:
+        if len(self.messages) == 0:
+            return
+        if self.messages[-1]['role'] == role:
+            self.messages = self.messages[:-1]
+            await self.save_log()
 
     def get_history(self) -> List[Dict[str, str]]:
         return self.messages

{mindroot-10.4.0.dist-info → mindroot-10.6.0.dist-info}/METADATA

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

{mindroot-10.4.0.dist-info → mindroot-10.6.0.dist-info}/RECORD

@@ -36,7 +36,7 @@ mindroot/coreplugins/admin/static/css/reset.css,sha256=pN9wuf7laZeIt-QjbxqJXDfu7
 mindroot/coreplugins/admin/static/css/update.css,sha256=J1lchkEY6WST1LLoyPhXjjCZ4-oqMu7ooWjJNduRmMs,3008
 mindroot/coreplugins/admin/static/js/about-info.js,sha256=CRyI5xGX3huycwseT5c80zsqQkElcdZsKMofyzyCimI,9230
 mindroot/coreplugins/admin/static/js/agent-editor.js,sha256=ZCJBNQ-l4kJj-ZufYuzEg45ZpqxwliNmxuqUa2GNiqY,2825
-mindroot/coreplugins/admin/static/js/agent-form.js,sha256=eSd7I5-fl11QsAIV0QU2JavqHNrkj8rEc4UTu49Rkos,40611
+mindroot/coreplugins/admin/static/js/agent-form.js,sha256=cFyIAS6dVxvzqJgJra-a5aFtS6zau0roveDSgpUF63A,41403
 mindroot/coreplugins/admin/static/js/agent-list.js,sha256=86mqFyHspx9EnzJpgUDyeAgEq-jcqQ4v96CrgfUXoGM,2239
 mindroot/coreplugins/admin/static/js/api-key-script.js,sha256=By80j-cwgxRT96MUBiZbVJuRvr6OAhd-GPmAUdZDZ4E,11199
 mindroot/coreplugins/admin/static/js/base.js,sha256=xGCA6ngMapQ_jqMgHXg__CS3R46qprycOjkKTFDCMlA,1307
@@ -52,7 +52,7 @@ mindroot/coreplugins/admin/static/js/missing-commands.js,sha256=adNF9GWN981_KX7H
 mindroot/coreplugins/admin/static/js/model-preferences-v2.js,sha256=4SFZBia959kRrSZXzIdWB0dscg4WtVIGYuLFlLpqBBI,15669
 mindroot/coreplugins/admin/static/js/model-preferences.js,sha256=J0G7gcGACaPyslWJO42urf5wbZZsqO0LyPicAu-uV_Y,3365
 mindroot/coreplugins/admin/static/js/notification.js,sha256=296rVCr6MNtzvzdzW3bGiMa231-BnWJtwZZ_sDWX-3c,5633
-mindroot/coreplugins/admin/static/js/persona-editor.js,sha256=bVp-d1y3HPocmVkHpqsVh0HiRUf77vJ43kargj1iPHk,9830
+mindroot/coreplugins/admin/static/js/persona-editor.js,sha256=emJSPBXDk54ztWDYOcs-bHAf1qQSIpq11RjV9bt5adA,10382
 mindroot/coreplugins/admin/static/js/plugin-advanced-install.js,sha256=-HDJ3lVuDwj6R-74TfVUo4dUxB8efl13m3R_sUicnJI,8038
 mindroot/coreplugins/admin/static/js/plugin-base.js,sha256=KWp5DqueHtyTxYKbuHMoFpoFXrfMbIjzK4M1ulAR9m8,5095
 mindroot/coreplugins/admin/static/js/plugin-index-browser.js,sha256=P-V4wqlYGxjr7oF2LiD5ti8Is3wtSsKPwpRgRJpT0VI,10028
@@ -439,7 +439,7 @@ mindroot/coreplugins/admin/static/js/lit-html/node/directives/when.js,sha256=NLe
 mindroot/coreplugins/admin/static/js/lit-html/node/directives/when.js.map,sha256=tOonih_-EaqrunhNGshA9xN--WIVdGikjg8MkVp0itQ,1534
 mindroot/coreplugins/admin/templates/admin.jinja2,sha256=H_oDqoWWk0Da0Jre67LIKvB3h30fmjcZz2T5knUyz0k,13272
 mindroot/coreplugins/admin/templates/model-preferences-v2.jinja2,sha256=5J3rXYmtp_yMTFCk85SYN03gc4lbidF0Nip6YcqcIW4,891
-mindroot/coreplugins/agent/agent.py,sha256=gPw82QbQYlWvJxy-FEg1kcVu1da04MhDYCZGv9YMEbk,21629
+mindroot/coreplugins/agent/agent.py,sha256=k3G3VaRjGwd1TNYQloytE4NV5cXyVxiuUl1GaMfdTEE,22335
 mindroot/coreplugins/agent/agent.py.bak,sha256=X-EmtrpEpdfo-iUw9gj7mLveRVzAApsDWPTwMAuv7Ww,20715
 mindroot/coreplugins/agent/cmd_start_example.py,sha256=Mdcd9st6viI6-M7a0-zqkw3IxR9FAxIiZ_8G-tLdIJk,1416
 mindroot/coreplugins/agent/command_parser.py,sha256=dgMqtVLPQWE2BU7iyjqwKGy5Gh74jcZkiy1JDs07t4E,13166
@@ -463,15 +463,16 @@ mindroot/coreplugins/api_keys/static/js/api-key-manager.js,sha256=imqlhd85Z-1e7u
 mindroot/coreplugins/chat/__init__.py,sha256=qVdTF1fHZJHwY_ChnPvNFx2Nlg07FHvK0V_JmzfWzdw,230
 mindroot/coreplugins/chat/buwidget_routes.py,sha256=MtwaPX2vEGDylifWOqcx7EAhDw0y1Y3Y91z58EJaLsc,9982
 mindroot/coreplugins/chat/commands.py,sha256=vlgGOvwvjpCbSsW25x4HaeFzeRNWXoEKrdqNpwX_EGg,17077
+mindroot/coreplugins/chat/edit_router.py,sha256=25BStzAIvGhULb_07bZw2aNxnpqabKV6CZHl9xrYdbQ,18629
 mindroot/coreplugins/chat/format_result_msgs.py,sha256=daEdpEyAJIa8b2VkCqSKcw8PaExcB6Qro80XNes_sHA,2
 mindroot/coreplugins/chat/mod.py,sha256=Xydjv3feKJJRbwdiB7raqiQnWtaS_2GcdC9bXYQX3nE,425
 mindroot/coreplugins/chat/models.py,sha256=GRcRuDUAJFpyWERPMxkxUaZ21igNlWeeamriruEKiEQ,692
 mindroot/coreplugins/chat/router.py,sha256=vq9UwYoFoGQMVmDC0TkjH7TWivFwkIe6OU0Scu-dtHg,15998
 mindroot/coreplugins/chat/router_dedup_patch.py,sha256=lDSpVMSd26pXJwrrdirUmR1Jv_N5VHiDzTS8t3XswDU,918
-mindroot/coreplugins/chat/services.py,sha256=UJl4Ri2Aj_F0Pzvh-Ztde0CaRPhbyA8g2KcONckpACk,21842
+mindroot/coreplugins/chat/services.py,sha256=cODRoNjE0lrraYBR5fwzMAwB-Y-GBQTr8VCMTzsejlY,22325
 mindroot/coreplugins/chat/utils.py,sha256=BiE14PpsAcQSO5vbU88klHGm8cAXJDXxgVgva-EXybU,155
 mindroot/coreplugins/chat/widget_manager.py,sha256=LrMbZlHqpxbLwdN4XZ4GkLxORwxa1o6IVCrlUDBmGQs,4786
-mindroot/coreplugins/chat/widget_routes.py,sha256=q_gD7Wxc0WnTU7S159dwe9-IJ2EYG4CC5Z6JbKpIrWU,11795
+mindroot/coreplugins/chat/widget_routes.py,sha256=iV3OwLFnvLDsMHdckJnmVXcUgyyng-zIPNXyK2LAUjc,11802
 mindroot/coreplugins/chat/static/assistant.png,sha256=oAt1ctkFKLSPBoAZGNnSixooW9ANVIk1GwniauVWDXo,215190
 mindroot/coreplugins/chat/static/mindgen.png,sha256=fN3E3oOFvAGYjJq-Pvg2f75jIMv7kg5WRU0EeEbxCWg,235353
 mindroot/coreplugins/chat/static/mindroot_logo.png,sha256=ZfPlCqCjU0_TXte5gvEx81zRKge--l_z2y0AArKl0as,17823
@@ -887,7 +888,7 @@ mindroot/coreplugins/chat/static/js/lit-html/node/directives/until.js,sha256=j1W
 mindroot/coreplugins/chat/static/js/lit-html/node/directives/until.js.map,sha256=7xiwSZ7_fGtr5XwW-10Dzs8n9QE2VUfXaZ0Sd6d82L0,6567
 mindroot/coreplugins/chat/static/js/lit-html/node/directives/when.js,sha256=NLe0NJ-6jqjVDUrT_DzmSpREsRaLo1yarzdYcV_5xHY,181
 mindroot/coreplugins/chat/static/js/lit-html/node/directives/when.js.map,sha256=tOonih_-EaqrunhNGshA9xN--WIVdGikjg8MkVp0itQ,1534
-mindroot/coreplugins/chat/templates/chat.jinja2,sha256=6mPBxZRcTCfCybhQvVIuRfcnkLiVd4Us3UbsMyoTMxM,3206
+mindroot/coreplugins/chat/templates/chat.jinja2,sha256=54yUJ7v-fE2r8iuXYleqznChApXKNQSuEJgIlZgyrCk,3256
 mindroot/coreplugins/chat_avatar/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
 mindroot/coreplugins/chat_avatar/inject/chat.jinja2,sha256=TDSSt_SdOOW4EJMQK7fA_L2W5GNbDICRmXyqSsw0wuE,1093
 mindroot/coreplugins/check_list/__init__.py,sha256=SaaGvnpz37xRM7DjGWBz5CD27Jh2UVdPLGoVUAFrUSY,77
@@ -2196,7 +2197,7 @@ mindroot/lib/buchatlog2.py,sha256=Va9FteBWePEjWD9OZcw-OtQfEb-IoCVGTmJeMRaX9is,13
 mindroot/lib/buchatlog3.py,sha256=SAvcK2m_CW0Jw8p1pqnbrTexcx24PotrsJTqvQ_D290,24573
 mindroot/lib/butemplates.py,sha256=gfHGPTOjvoEenXsR7xokNuqMjOAPuC2DawheH1Ae4bU,12196
 mindroot/lib/chatcontext.py,sha256=CXk-pX-7RG3NiRFsAZWERWxnuFJOHH7FHtOLm-kGRXE,12437
-mindroot/lib/chatlog.py,sha256=JuUffRUhs966d7MhE_xt8iSviZCULSRpwCtvnpjNd4Y,26139
+mindroot/lib/chatlog.py,sha256=ACdixKTn_GlVVfB00fNlphNPMFnRrum_za_mQfGPQoQ,26372
 mindroot/lib/chatlog_optimized.py,sha256=rL7KBP-V4_cGgMLihxPm3HoKcjFEyA1uEtPtqvkOa3A,20011
 mindroot/lib/json_escape.py,sha256=5cAmAdNbnYX2uyfQcnse2fFtNI0CdB-AfZ23RwaDm-k,884
 mindroot/lib/model_selector.py,sha256=Wz-8NZoiclmnhLeCNnI3WCuKFmjsO5HE4bK5F8GpZzU,1397
@@ -2250,9 +2251,9 @@ mindroot/protocols/services/stream_chat.py,sha256=fMnPfwaB5fdNMBLTEg8BXKAGvrELKH
 mindroot/registry/__init__.py,sha256=40Xy9bmPHsgdIrOzbtBGzf4XMqXVi9P8oZTJhn0r654,151
 mindroot/registry/component_manager.py,sha256=WZFNPg4SNvpqsM5NFiC2DpgmrJQCyR9cNhrCBpp30Qk,995
 mindroot/registry/data_access.py,sha256=81In5TwETpaqnnY1_-tBQM7rfWvUxZUZkG7lEelRUfU,5321
-mindroot-10.4.0.dist-info/licenses/LICENSE,sha256=8plAmZh8y9ccuuqFFz4kp7G-cO_qsPgAOoHNvabSB4U,1070
-mindroot-10.4.0.dist-info/METADATA,sha256=OBn4gxCPRrMB6oyPLB8dGQxp0nIUhIlCG0NqiKETVTo,1035
-mindroot-10.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mindroot-10.4.0.dist-info/entry_points.txt,sha256=0bpyjMccLttx6VcjDp6zfJPN0Kk0rffor6IdIbP0j4c,50
-mindroot-10.4.0.dist-info/top_level.txt,sha256=gwKm7DmNjhdrCJTYCrxa9Szne4lLpCtrEBltfsX-Mm8,9
-mindroot-10.4.0.dist-info/RECORD,,
+mindroot-10.6.0.dist-info/licenses/LICENSE,sha256=8plAmZh8y9ccuuqFFz4kp7G-cO_qsPgAOoHNvabSB4U,1070
+mindroot-10.6.0.dist-info/METADATA,sha256=B_jgoqAFx9YKO_ddBGR0_rVBewpVyTae8JJhUxQI_LY,1035
+mindroot-10.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mindroot-10.6.0.dist-info/entry_points.txt,sha256=0bpyjMccLttx6VcjDp6zfJPN0Kk0rffor6IdIbP0j4c,50
+mindroot-10.6.0.dist-info/top_level.txt,sha256=gwKm7DmNjhdrCJTYCrxa9Szne4lLpCtrEBltfsX-Mm8,9
+mindroot-10.6.0.dist-info/RECORD,,