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

mindroot/coreplugins/chat/buwidget_routes.py

@@ -0,0 +1,287 @@
+from fastapi import APIRouter, HTTPException, Request, Response
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from typing import Optional, List
+from .widget_manager import widget_manager
+from lib.auth.api_key import verify_api_key
+from lib.providers.services import service_manager
+from lib.route_decorators import public_route
+import nanoid
+from .services import init_chat_session
+from lib.session_files import save_session_data
+import traceback
+
+router = APIRouter()
+
+class WidgetTokenCreate(BaseModel):
+    api_key: str
+    agent_name: str
+    base_url: str
+    description: Optional[str] = ""
+    styling: Optional[dict] = None
+
+class WidgetTokenResponse(BaseModel):
+    token: str
+    agent_name: str
+    base_url: str
+    description: str
+    created_at: str
+    created_by: str
+    styling: dict
+
+@router.post("/widgets/create")
+async def create_widget_token(request: Request, widget_request: WidgetTokenCreate):
+    """Create a new widget token."""
+    try:
+        # Verify the API key is valid
+        api_key_data = await verify_api_key(widget_request.api_key)
+        if not api_key_data:
+            raise HTTPException(status_code=400, detail="Invalid API key")
+        
+        # Verify the agent exists
+        try:
+            agent_data = await service_manager.get_agent_data(widget_request.agent_name)
+            if not agent_data:
+                raise HTTPException(status_code=400, detail="Agent not found")
+        except Exception:
+            raise HTTPException(status_code=400, detail="Agent not found")
+        
+        # Get the current user
+        user = request.state.user
+        
+        # Create the widget token
+        token = widget_manager.create_widget_token(
+            api_key=widget_request.api_key,
+            agent_name=widget_request.agent_name,
+            base_url=widget_request.base_url,
+            created_by=user.username,
+            description=widget_request.description,
+            styling=widget_request.styling
+        )
+        
+        return {
+            "success": True,
+            "token": token,
+            "embed_url": f"{widget_request.base_url}/chat/embed/{token}"
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/widgets/list")
+async def list_widget_tokens(request: Request):
+    """List widget tokens for the current user."""
+    try:
+        user = request.state.user
+        widgets = widget_manager.list_widget_tokens(created_by=user.username)
+        return {"success": True, "data": widgets}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/widgets/delete/{token}")
+async def delete_widget_token(request: Request, token: str):
+    """Delete a widget token."""
+    try:
+        # Verify the widget exists and belongs to the user
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        user = request.state.user
+        if widget_config.get("created_by") != user.username:
+            raise HTTPException(status_code=403, detail="Not authorized to delete this widget")
+        
+        success = widget_manager.delete_widget_token(token)
+        if success:
+            return {"success": True, "message": "Widget token deleted successfully"}
+        else:
+            raise HTTPException(status_code=500, detail="Failed to delete widget token")
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/chat/embed/{token}")
+@public_route()
+async def get_embed_script(token: str):
+    """Generate the secure embed script for a widget token."""
+    try:
+        # Validate the widget token
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        # Generate the embed JavaScript
+        base_url = widget_config["base_url"]
+        styling = widget_config.get("styling", {})
+        
+        # Create the embed script that doesn't expose the API key
+        embed_script = f'''
+(function() {{
+    const config = {{
+        baseUrl: "{base_url}",
+        token: "{token}",
+        position: "{styling.get('position', 'bottom-right')}",
+        width: "{styling.get('width', '400px')}",
+        height: "{styling.get('height', '600px')}",
+        theme: "{styling.get('theme', 'dark')}"
+    }};
+    
+    let chatContainer = null;
+    let chatIcon = null;
+    let isLoaded = false;
+    
+    function createChatIcon() {{
+        if (chatIcon) return;
+        
+        chatIcon = document.createElement("div");
+        chatIcon.id = "mindroot-chat-icon-" + config.token;
+        chatIcon.innerHTML = "💬";
+        
+        const iconStyles = {{
+            position: "fixed",
+            bottom: "20px",
+            right: config.position.includes("left") ? "auto" : "20px",
+            left: config.position.includes("left") ? "20px" : "auto",
+            width: "60px",
+            height: "60px",
+            background: "#2196F3",
+            borderRadius: "50%",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            cursor: "pointer",
+            boxShadow: "0 4px 12px rgba(0, 0, 0, 0.3)",
+            zIndex: "10000",
+            fontSize: "24px",
+            color: "white",
+            transition: "all 0.3s ease"
+        }};
+        
+        Object.assign(chatIcon.style, iconStyles);
+        chatIcon.addEventListener("click", toggleChat);
+        document.body.appendChild(chatIcon);
+    }}
+    
+    function createChatContainer() {{
+        if (chatContainer) return;
+        
+        chatContainer = document.createElement("div");
+        chatContainer.id = "mindroot-chat-container-" + config.token;
+        
+        const containerStyles = {{
+            position: "fixed",
+            bottom: "90px",
+            right: config.position.includes("left") ? "auto" : "20px",
+            left: config.position.includes("left") ? "20px" : "auto",
+            width: config.width,
+            height: config.height,
+            background: "white",
+            borderRadius: "12px",
+            boxShadow: "0 8px 32px rgba(0, 0, 0, 0.3)",
+            zIndex: "10001",
+            display: "none",
+            overflow: "hidden"
+        }};
+        
+        Object.assign(chatContainer.style, containerStyles);
+        document.body.appendChild(chatContainer);
+    }}
+    
+    function toggleChat() {{
+        if (!chatContainer) createChatContainer();
+        
+        const isVisible = chatContainer.style.display !== "none";
+        
+        if (isVisible) {{
+            chatContainer.style.display = "none";
+        }} else {{
+            if (!isLoaded) {{
+                // Create iframe and load the secure session
+                const iframe = document.createElement("iframe");
+                iframe.style.cssText = "width: 100%; height: 100%; border: none; border-radius: 12px;";
+                iframe.src = config.baseUrl + "/chat/widget/" + config.token + "/session";
+                chatContainer.appendChild(iframe);
+                isLoaded = true;
+            }}
+            chatContainer.style.display = "block";
+        }}
+    }}
+    
+    function init() {{
+        if (document.readyState === "loading") {{
+            document.addEventListener("DOMContentLoaded", function() {{
+                createChatIcon();
+            }});
+        }} else {{
+            createChatIcon();
+        }}
+    }}
+    
+    init();
+}})();
+'''
+        
+        return Response(
+            content=embed_script,
+            media_type="application/javascript",
+            headers={
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                "Pragma": "no-cache",
+                "Expires": "0"
+            }
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/chat/widget/{token}/session")
+@public_route()
+async def create_widget_session(token: str):
+    """Create a secure chat session for a widget token."""
+    try:
+        # Validate the widget token
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        # Verify the API key from the widget config
+        api_key_data = await verify_api_key(widget_config["api_key"])
+        if not api_key_data:
+            raise HTTPException(status_code=401, detail="Invalid API key in widget configuration")
+        
+        # Create mock user and generate session ID
+        class MockUser:
+            def __init__(self, username):
+                self.username = username
+        user = MockUser(api_key_data['username'])
+        session_id = nanoid.generate()
+        agent_name = widget_config["agent_name"]
+        
+        # Initialize the chat session (this was missing!)
+        await init_chat_session(user, agent_name, session_id)
+        
+        # Create and save access token for authentication
+        from coreplugins.jwt_auth.middleware import create_access_token
+        token_data = create_access_token({"sub": api_key_data['username']})
+        await save_session_data(session_id, "access_token", token_data)
+        
+        # Now redirect to the session WITHOUT exposing the API key
+        redirect_url = f"/session/{agent_name}/{session_id}?embed=true"
+        
+        return Response(
+            status_code=302,
+            headers={"Location": redirect_url}
+        )
+    
+    except Exception as e:
+        trace = traceback.format_exc()
+        print(e, trace)
+        raise HTTPException(status_code=500, detail=str(e))
+        

mindroot/coreplugins/chat/services.py

@@ -22,6 +22,7 @@ from io import BytesIO
 import base64
 import nanoid
 sse_clients = {}
+from lib.chatcontext import get_context
 
 @service()
 async def prompt(model: str, instructions: str, temperature=0, max_tokens=400, json=False, context=None):
@@ -485,3 +486,66 @@ async def command_result(command: str, result, context=None):
     agent_ = context.agent
     await context.agent_output("command_result", { "command": command, "result": result, "persona": agent_['persona']['name'] })
 
+@service()
+async def backend_user_message(message: str, context=None):
+    """
+    Insert a user message from the backend and signal the frontend to display it.
+    This allows backend processes to inject messages into the chat without user interaction.
+    """
+    agent_ = context.agent
+    persona = 'user'
+    await context.agent_output("backend_user_message", { 
+        "content": message, 
+        "sender": "user",
+        "persona": persona
+    })
+
+@service()
+async def cancel_active_response(log_id: str, context=None):
+    """
+    Cancel active AI response for eager end of turn processing.
+    Sets the finished_conversation flag to stop the agent processing loop.
+    """
+    if context is None:
+        # Get context from log_id - we need the username, but for SIP calls it might be 'system'
+        # Try to load context, fallback to system user if needed
+        try:
+            context = await get_context(log_id, 'system')
+        except Exception as e:
+            print(f"Error getting context for cancellation: {e}")
+            return {"status": "error", "message": f"Could not load context: {e}"}
+    
+    # Set flag to stop current processing loop iteration
+    # But don't permanently mark conversation as finished - just this turn
+    context.data['cancel_current_turn'] = True
+    
+    # DEBUG TRACE
+    print("\033[91;107m[DEBUG TRACE 5/6] Core cancel_active_response service executed.\033[0m")
+    
+    # Cancel any active TTS streams (ElevenLabs)
+    try:
+        # Import here to avoid circular dependency
+        from mr_eleven_stream.mod import _active_tts_streams
+        for stream_id, stop_event in list(_active_tts_streams.items()):
+            stop_event.set()
+            logger.info(f"Cancelled TTS stream {stream_id}")
+            print("\033[91;107m[DEBUG TRACE 5.5/6] Cancelled active TTS stream.\033[0m")
+    except ImportError:
+        logger.debug("ElevenLabs TTS plugin not available for cancellation")
+    
+    # Also, cancel any active command task (like speak())
+    if 'active_command_task' in context.data:
+        active_task = context.data['active_command_task']
+        if active_task and not active_task.done():
+            try:
+                active_task.cancel()
+                # DEBUG TRACE
+                print("\033[91;107m[DEBUG TRACE 6/6] Active command task found and cancelled.\033[0m")
+                print(f"Cancelled active command task for session {log_id}")
+            except Exception as e:
+                print(f"Error cancelling active command task: {e}")
+    
+    await context.save_context()
+    
+    print(f"Cancelled active response for session {log_id}")
+    return {"status": "cancelled", "log_id": log_id}

mindroot/coreplugins/chat/static/css/mobile.css

@@ -1,4 +1,5 @@
 /* Mobile-specific styles */
+
 @media screen and (max-width: 768px) {
   .page-container {
     position: relative;
@@ -132,6 +133,42 @@
     padding: 8px 12px;
   }
 
+  /* Fix for mobile chat layout - ensure chat form is visible */
+  html, body {
+    height: 100%;
+    overflow: hidden;
+  }
+  
+  .page-container {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+  }
+  
+  .main {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+  
+  chat-ai {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+    padding-top: 60px; /* Space for hamburger menu */
+    padding-bottom: 10px;
+  }
+  
+  .chat-log {
+    flex: 1;
+    overflow-y: auto;
+  }
+  
+  chat-form {
+    flex-shrink: 0;
+  }
+  
   /* Ensure images in markdown content are also responsive */
   .message p img {
     max-width: 100%;

mindroot/coreplugins/chat/static/js/chat.js

@@ -117,6 +117,7 @@ class Chat extends BaseEl {
     this.sse.addEventListener('command_result', e => thisResult(e).catch(console.error));
     this.sse.addEventListener('finished_chat', e => thisFinished(e).catch(console.error));
     this.sse.addEventListener('system_error', e=> thisError(e).catch(console.error));
+    this.sse.addEventListener('backend_user_message', this._backendUserMessage.bind(this));
 
     // when the user scrolls in the chat log, stop auto-scrolling to the bottom
     const chatLog = this.shadowRoot.querySelector('.chat-log');
@@ -144,6 +145,27 @@ class Chat extends BaseEl {
     showNotification('error', data.error);
   }
 
+  _backendUserMessage(event) {
+    console.log('Backend user message received:', event);
+    const data = JSON.parse(event.data);
+    const { content, sender, persona } = data;
+    
+    // Parse the content as markdown
+    const parsed = tryParse(content);
+    
+    // Add the message to the chat log
+    this.messages = [...this.messages, { 
+      content: parsed, 
+      spinning: 'no', 
+      sender: sender || 'user', 
+      persona: persona || 'user' 
+    }];
+    
+    // Scroll to show the new message
+    setTimeout(() => {
+      this._scrollToBottom();
+    }, 100);
+  }
   
 
   _addMessage(event) {

mindroot/coreplugins/chat/templates/chat.jinja2

@@ -36,7 +36,7 @@
 
   {% block head_extra %}{% endblock %}
 </head>
-<body>
+<body{% if embed_mode %} class="embedded"{% endif %}>
   {% block body_init %}
   <script>
     // print a big colorful header annoucing data init section

mindroot/coreplugins/chat/widget_routes.py

@@ -133,6 +133,12 @@ async def get_embed_script(token: str):
     let chatContainer = null;
     let chatIcon = null;
     let isLoaded = false;
+    let isMobile = false;
+
+    function detectMobile() {{
+        const userAgent = navigator.userAgent || navigator.vendor || window.opera || "";
+        return /android|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent.toLowerCase());
+    }}
     
     function createChatIcon() {{
         if (chatIcon) return;
@@ -141,13 +147,15 @@ async def get_embed_script(token: str):
         chatIcon.id = "mindroot-chat-icon-" + config.token;
         chatIcon.innerHTML = "💬";
         
+        const iconSize = isMobile ? 80 : 60;
+        const fontSize = isMobile ? 28 : 24;
         const iconStyles = {{
             position: "fixed",
-            bottom: "20px",
+            bottom: isMobile ? "30px" : "20px",
             right: config.position.includes("left") ? "auto" : "20px",
             left: config.position.includes("left") ? "20px" : "auto",
-            width: "60px",
-            height: "60px",
+            width: iconSize + "px",
+            height: iconSize + "px",
             background: "#2196F3",
             borderRadius: "50%",
             display: "flex",
@@ -156,7 +164,7 @@ async def get_embed_script(token: str):
             cursor: "pointer",
             boxShadow: "0 4px 12px rgba(0, 0, 0, 0.3)",
             zIndex: "10000",
-            fontSize: "24px",
+            fontSize: fontSize + "px",
             color: "white",
             transition: "all 0.3s ease"
         }};
@@ -172,7 +180,22 @@ async def get_embed_script(token: str):
         chatContainer = document.createElement("div");
         chatContainer.id = "mindroot-chat-container-" + config.token;
         
-        const containerStyles = {{
+        const containerStyles = isMobile ? {{
+            position: "fixed",
+            top: "0px",
+            left: "0",
+            right: "0",
+            bottom: "0",
+            width: "100vw",
+            height: "100vh",
+            background: "white",
+            borderRadius: "0",
+            boxShadow: "none",
+            zIndex: "10001",
+            display: "none",
+            flexDirection: "column",
+            overflow: "hidden"
+        }} : {{
             position: "fixed",
             bottom: "90px",
             right: config.position.includes("left") ? "auto" : "20px",
@@ -198,26 +221,47 @@ async def get_embed_script(token: str):
         
         if (isVisible) {{
             chatContainer.style.display = "none";
+            if (isMobile) {{
+                document.body.style.removeProperty("overflow");
+            }}
         }} else {{
             if (!isLoaded) {{
                 // Create iframe and load the secure session
                 const iframe = document.createElement("iframe");
-                iframe.style.cssText = "width: 100%; height: 100%; border: none; border-radius: 12px;";
+                if (isMobile) {{
+                    iframe.style.cssText = "width: 100%; height: 100%; border: none; position: absolute; top: 0; left: 0; right: 0; bottom: 0;";
+                    // Add viewport meta tag if not present
+                    if (!document.querySelector('meta[name="viewport"]')) {{
+                        const meta = document.createElement('meta');
+                        meta.name = 'viewport';
+                        meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no';
+                        document.head.appendChild(meta);
+                    }}
+                }} else {{
+                    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"
                 chatContainer.appendChild(iframe);
                 isLoaded = true;
             }}
             chatContainer.style.display = "block";
+            if (isMobile) {{
+                document.body.style.overflow = "hidden";
+            }}
         }}
     }}
     
     function init() {{
+        const boot = () => {{
+            isMobile = detectMobile();
+            createChatIcon();
+        }};
+
         if (document.readyState === "loading") {{
-            document.addEventListener("DOMContentLoaded", function() {{
-                createChatIcon();
-            }});
+            document.addEventListener("DOMContentLoaded", boot);
         }} else {{
-            createChatIcon();
+            boot();
         }}
     }}
     

mindroot/coreplugins/check_list/mod.py

@@ -593,3 +593,55 @@ You are working on {task_context}."""
     
     return await command_manager.delegate_task(instructions, agent_name, context=context)
 
+
+
+@command()
+async def create_checklist(tasks, title=None, replace=True, context=None):
+    """
+    Create a new checklist dynamically from a list of task descriptions.
+    
+    Parameters:
+    - tasks: Required. List of task description strings
+    - title: Optional. Title for the checklist (for display purposes)
+    - replace: Optional. Whether to replace existing checklist (default: True)
+    
+    Example:
+    { "create_checklist": { 
+        "tasks": [
+            "Research the topic",
+            "Create outline", 
+            "Write first draft",
+            "Review and edit"
+        ],
+        "title": "Article Writing Process"
+    }}
+    """
+    if context is None:
+        return "_Context is required._"
+    
+    if not tasks or not isinstance(tasks, list):
+        return "_Tasks parameter must be a non-empty list of task descriptions._"
+    
+    # Check if we should replace existing checklist
+    st = _state(context)
+    if not replace and st["tasks"]:
+        return "_Checklist already exists. Use replace=True to overwrite it._"
+    
+    # Convert task list to markdown checklist format
+    markdown_lines = []
+    if title:
+        markdown_lines.append(f"# {title}\n")
+    
+    for task_desc in tasks:
+        if not isinstance(task_desc, str):
+            return "_All tasks must be strings._"
+        markdown_lines.append(f"- [ ] {task_desc.strip()}")
+    
+    markdown_text = "\n".join(markdown_lines)
+    
+    # Use existing load_checklist function to parse and store
+    load_checklist(markdown_text, context)
+    
+    # Build response
+    title_text = f" '{title}'" if title else ""
+    return f"Created checklist{title_text} with {len(tasks)} tasks.\n\n{_format_checklist_status(context)}"