mindroot 9.22.0__py3-none-any.whl → 10.14.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/commands.py

@@ -1,6 +1,7 @@
 from lib.providers.commands import command, command_manager
 from lib.providers.services import service_manager
 from lib.chatcontext import ChatContext
+from lib.chatlog import ChatLog
 from .services import init_chat_session, send_message_to_agent, subscribe_to_agent_messages
 import asyncio
 import json
@@ -150,6 +151,9 @@ async def delegate_task(instructions: str, agent_name, log_id=None, retries=3, c
     (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)
+    if text is None or text == "" or text == [] or text == '[]':
+        chatlog = ChatLog(log_id=context.log_id, user=context.username, agent=agent_name)
+        text = json.dumps(chatlog.messages)
     return f"""<a href="/session/{agent_name}/{log_id}" target="_blank">Task completed with log ID: {log_id}</a>\nResults:\n\n{text}"""
 
 

mindroot/coreplugins/chat/services.py

@@ -8,6 +8,7 @@ from typing import List
 from lib.utils.dataurl import dataurl_to_pil
 from .models import MessageParts
 from coreplugins.agent import agent
+from coreplugins.agent.speech_to_speech import SpeechToSpeechAgent
 from lib.utils.debug import debug_box
 import os
 import sys
@@ -22,6 +23,10 @@ from io import BytesIO
 import base64
 import nanoid
 sse_clients = {}
+from lib.chatcontext import get_context
+
+# Track active processing tasks per session
+active_tasks = {}
 
 @service()
 async def prompt(model: str, instructions: str, temperature=0, max_tokens=400, json=False, context=None):
@@ -67,7 +72,7 @@ def results_output(results):
     text = ""
     for result in results:
         if 'output' in result['args']:
-            return result['args']['output']
+            return str(result['args']['output'])
 
 def results_text_output(results):
     text = ""
@@ -134,6 +139,9 @@ async def run_task(instructions: str, agent_name:str = None, user:str = None, lo
 
     while retried < retries:
         [results, full_results] = await send_message_to_agent(context.log_id, instructions, context=context)
+        print('#####################################################33')
+        print("Full results: ", full_results)
+        print("Results: ", results)
         text = results_output(full_results)
         if text == "":
             retried += 1
@@ -164,6 +172,11 @@ async def init_chat_session(user:str, agent_name: str, log_id: str, context=None
         print("context.agent_name: ", context.agent_name)
         await context.save_context()
     print("initiated_chat_session: ", log_id, agent_name, context.agent_name, context.agent)
+
+    if 'live' in context.agent['stream_chat'] or 'realtime' in context.agent['stream_chat']:
+        agent = SpeechToSpeechAgent(agent_name, context=context)
+        await agent.connect()
+
     return log_id
 
 @service()
@@ -216,13 +229,61 @@ def process_result(result, formatted_results):
 
     return formatted_results
 
+# Deprecated - use active_tasks instead
+in_progress = {}
+
+
+@service()
+async def cancel_and_wait(session_id: str, user:str, context=None):
+    global in_progress, active_tasks
+    existing_task = active_tasks.get(session_id)
+
+    if not in_progress.get(session_id, False):
+        print(f"SEND_MESSAGE No active processing for session {session_id} to cancel.")
+        return
+    try:
+        print(f"SEND_MESSAGE Cancelling active task for session {session_id}...")
+        existing_context = await get_context(session_id, user)
+        existing_context.data['cancel_current_turn'] = True
+        existing_context.data['finished_conversation'] = True
+        existing_context.save_context()
+        # Cancel any active command task
+        if 'active_command_task' in existing_context.data:
+            cmd_task = existing_context.data['active_command_task']
+            if cmd_task and not cmd_task.done():
+                cmd_task.cancel()
+        
+        await existing_context.save_context()
+    except Exception as e:
+        print(f"SEND_MESSAGE Error setting cancellation flags: {e}")
+    
+    # Cancel the main task
+    existing_task.cancel()
+    
+    # Wait for it to actually finish (with timeout)
+    try:
+        await asyncio.wait_for(existing_task, timeout=2.0)
+    except (asyncio.CancelledError, asyncio.TimeoutError):
+        pass  # Expected
+   
+    start_wait = time.time()
+    while in_progress.get(session_id, False) and (time.time() - start_wait) < 5.0:
+        print(f"SEND_MESSAGE Waiting for cancellation of session {session_id} to complete...")
+        await asyncio.sleep(0.025)
+
+    print(f"SEND_MESSAGE Cancellation complete for session {session_id}")
+
 @service()
 async def send_message_to_agent(session_id: str, message: str | List[MessageParts], max_iterations=35, context=None, user=None):
-    if os.environ.get("MR_MAX_ITERATIONS") is not None:
-        max_iterations = int(os.environ.get("MR_MAX_ITERATIONS"))
+    global in_progress, active_tasks
+    
+    # Check if there's an active task for this session
+    existing_task = active_tasks.get(session_id)
+
     if not user:
         # check context
         if not context.username:
+            print("SEND_MESSAGE No user provided and context has no username")
             raise Exception("User required")
         else:
             user = {"user": context.username }
@@ -230,20 +291,46 @@ async def send_message_to_agent(session_id: str, message: str | List[MessagePart
         if hasattr(user, "dict"):
             user = user.dict()
 
+    context.data['cancel_current_turn'] = False
+    context.data['finished_conversation'] = False
+    await context.save_context()
+
+    in_progress[session_id] = True
+    await asyncio.sleep(0.05)
+
+    print('b')
+    if os.environ.get("MR_MAX_ITERATIONS") is not None:
+        max_iterations = int(os.environ.get("MR_MAX_ITERATIONS"))
     try:
         if type(message) is list:
             message = [m.dict() for m in message]
 
         if session_id is None or session_id == "" or message is None or message == "":
-            print("Invalid session_id or message")
+            print("SEND_MESSAGE Invalid session_id or message")
             return []
 
+        # Create the main processing task and store it
+        processing_task = asyncio.current_task()
+        active_tasks[session_id] = processing_task
+
+        print("SEND_MESSAGE proceeding with message processing")
         print("send_message_to_agent: ", session_id, message, max_iterations)
         if context is None:
             context = ChatContext(command_manager, service_manager, user)
             await context.load_context(session_id)
 
-        agent_ = agent.Agent(agent=context.agent)
+        if 'live' in context.agent['stream_chat'] or 'realtime' in context.agent['stream_chat']:
+            agent_ = SpeechToSpeechAgent(context.agent_name, context=context)
+            print('Using SpeechToSpeechAgent for live/realtime chat')
+            print()
+            print()
+            print()
+            print('message: ', message)
+            results = await agent_.send_message(message)
+            return results, []
+        else:
+            agent_ = agent.Agent(agent=context.agent)
+
         if user is not None and hasattr(user, "keys"):
             for key in user.keys():
                 context.data[key] = user[key]
@@ -297,8 +384,8 @@ async def send_message_to_agent(session_id: str, message: str | List[MessagePart
                         context.current_model = context.data['llm']
     
                 parse_error = False
-
-                results, full_cmds = await agent_.chat_commands(context.current_model, context, messages=context.chat_log.get_recent())
+                max_tokens = os.environ.get("MR_MAX_TOKENS", 4000)
+                results, full_cmds = await agent_.chat_commands(context.current_model, context, messages=context.chat_log.get_recent(), max_tokens=max_tokens)
                 if results is not None:
                     try:
                         for result in results:
@@ -372,9 +459,12 @@ async def send_message_to_agent(session_id: str, message: str | List[MessagePart
                     context.chat_log.add_message({"role": "user", "content": formatted_results})
                     results.append(out_results) 
                 else:
-                    print("Processing iteration: ", iterations, "no message added")
+                    print("SEND_MESSAGE Processing iteration: ", iterations, "no message added")
                 if context.data.get('finished_conversation') is True:
                     termcolor.cprint("Finished conversation, exiting send_message_to_agent", "red")
+                    if context.data.get('task_result') is not None:
+                        task_result = context.data.get('task_result')
+                        full_results.append({ "cmd": "task_result", "args": { "result": task_result } })
                     continue_processing = False
             except Exception as e:
                 continue_processing = False
@@ -398,10 +488,23 @@ 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)
+        active_tasks.pop(session_id, None)
+        if len(results) == 0:
+            if context.data.get('task_result') is not None:
+                task_result = context.data.get('task_result')
+                results.append(task_result)
+        print("SEND_MESSAGE Done")
         return [results, full_results]
+    except asyncio.CancelledError:
+        print(f"Task cancelled for session {session_id}")
+        in_progress.pop(session_id, None)
+        active_tasks.pop(session_id, None)
+        raise  # Re-raise to properly handle cancellation
     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)
@@ -485,3 +588,70 @@ 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):
+    """
+    Signal the frontend to display a user message.
+    """
+    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}")
+                print(f"Removing last assistant message from chat log for session {log_id}")
+                await context.chat_log.drop_last('assistant')
+
+            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/dark.css

@@ -1,3 +1,8 @@
+/* Import JetBrains Mono from Google Fonts */
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap');
+
+/* Base styles */
+
 html, body {
   background-color: #101020;
   color: #f0f0f0;
@@ -16,7 +21,7 @@ input, * {
   background-color: transparent;
   color: #f0f0f0;
   margin: 2px 2px;
-  font-family: ui-sans-serif, -apple-system, system-ui, "Segoe UI", Roboto, Ubuntu, Cantarell, "Noto Sans", sans-serif, Helvetica, "Apple Color Emoji", Arial, "Segoe UI Emoji", "Segoe UI Symbol";
+  /*font-family: ui-sans-serif, -apple-system, system-ui, "Segoe UI", Roboto, Ubuntu, Cantarell, "Noto Sans", sans-serif, Helvetica, "Apple Color Emoji", Arial, "Segoe UI Emoji", "Segoe UI Symbol";*/
 }
 
 p {
@@ -1020,3 +1025,87 @@ tbody tr {
 .left-side {
   overflow-y: auto;
 }
+
+/* Enhanced Shell/Terminal output styling */
+pre.shellout {
+  background: linear-gradient(to bottom, #2d2d2d 0%, #1e1e1e 30px, #1a1a1a 100%);
+  border: 1px solid #404040;
+  border-radius: 12px;
+  padding: 0;
+  margin: 15px 0;
+  overflow-x: auto;
+  max-height: 50vh;
+  overflow-y: auto;
+  box-shadow: 0 8px 16px rgba(0, 0, 0, 0.4), 
+              0 0 0 1px rgba(255, 255, 255, 0.05) inset;
+  position: relative;
+}
+
+/* Mock terminal title bar */
+pre.shellout::before {
+  content: '';
+  display: block;
+  height: 30px;
+  background: linear-gradient(to bottom, #3a3a3a, #2d2d2d);
+  border-bottom: 1px solid #1a1a1a;
+  border-radius: 12px 12px 0 0;
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+/* Terminal window controls (dots) */
+pre.shellout::after {
+  content: '';
+  position: absolute;
+  top: 11px;
+  left: 12px;
+  width: 12px;
+  height: 12px;
+  background: #ff5f56;
+  border-radius: 50%;
+  box-shadow: 
+    20px 0 0 #ffbd2e,
+    40px 0 0 #27c93f,
+    0 0 0 1px rgba(0, 0, 0, 0.2);
+  z-index: 2;
+}
+
+/* Code element inside shellout pre */
+pre.shellout code {
+  background-color: transparent;
+  color: #e8e8e8;
+  font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', 'Monaco', monospace;
+  font-size: 14px;
+  line-height: 1.6;
+  padding: 15px 20px;
+  padding-top: 10px;
+  margin: 0;
+  border: none;
+  white-space: pre-wrap;
+  display: block;
+  font-weight: 400;
+  letter-spacing: 0.02em;
+}
+
+/* Custom scrollbar for terminal */
+pre.shellout::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+
+pre.shellout::-webkit-scrollbar-track {
+  background: #1a1a1a;
+  border-radius: 0 0 12px 0;
+}
+
+pre.shellout::-webkit-scrollbar-thumb {
+  background: #404040;
+  border-radius: 5px;
+  border: 2px solid #1a1a1a;
+}
+
+pre.shellout::-webkit-scrollbar-thumb:hover {
+  background: #4a4a4a;
+}
+