mindroot 10.5.0__tar.gz → 10.6.0__tar.gz

{mindroot-10.5.0/src/mindroot.egg-info → mindroot-10.6.0}/PKG-INFO

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

{mindroot-10.5.0 → mindroot-10.6.0}/pyproject.toml

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

{mindroot-10.5.0 → mindroot-10.6.0}/src/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-10.5.0 → mindroot-10.6.0}/src/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-10.5.0 → mindroot-10.6.0}/src/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-10.6.0/src/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}")