mindroot 9.2.0__py3-none-any.whl → 9.5.0__py3-none-any.whl

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

@@ -9,7 +9,7 @@ import {markedHighlight} from 'https://cdn.jsdelivr.net/npm/marked-highlight@2.1
 
 function tryParse(markdown) {
     //return renderMarkdown(markdown)
-    return markdownRenderer.parse(markdown);
+      return markdownRenderer.parse(markdown);
 }
 
 
@@ -44,40 +44,84 @@ class ActionComponent extends BaseEl {
   static properties = {
     funcName: { type: String },
     params: { type: String },
-    result: { type: String }
+    result: { type: String },
+    isExpanded: { type: Boolean },
+    isRunning: { type: Boolean }
   }
 
   static styles = [
     css`
 :host {
   display: block;
+  width: 100%;
 }
 
-details {
-  border: none;
-  display: contents;
+.action-container {
+  width: 100%;
+  border: 1px solid #333;
+  border-radius: 8px;
+  margin: 4px 0;
+  background-color: transparent;
+}
+
+.action-container.running {
+  border-color: #4a5eff;
+  animation: pulse-border 2s infinite;
+}
+
+@keyframes pulse-border {
+  0%, 100% {
+    border-color: #4a5eff;
+    box-shadow: 0 0 5px rgba(74, 94, 255, 0.3);
+  }
+  50% {
+    border-color: #6a7eff;
+    box-shadow: 0 0 10px rgba(74, 94, 255, 0.5);
+  }
+}
+
+.action-summary {
+  padding: 8px 12px;
+  cursor: pointer;
+  background: rgba(200, 200, 255, 0.1);
+  border-radius: 8px;
+  width: 100%;
+  box-sizing: border-box;
+  display: block;
+  color: #f0f0f0;
+  user-select: none;
+}
+
+.action-summary:hover {
+  background: #444;
+}
+
+.action-content {
+  padding: 8px 12px;
+  border-top: 1px solid #333;
+  color: #f0f0f0;
+  display: none;
+}
+
+.action-content.expanded {
+  display: block;
+}
+
+.param-preview {
+  color: #ddd;
+  font-style: italic;
+  margin-left: 8px;
+}
+
+.fn_name {
+  color: #f0f0f0;
+  font-weight: normal;
 }
 
 @keyframes flash {
   0% { opacity: 0; }
   50% { opacity: 0.5; }
   100% { opacity: 0; }
-}
-/*
-.animated-element::before {
-  content: '';
-  display: inline-block;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: rgba(200,200,200,0.5);
-  animation: flash 0.2s;
-  pointer-events: none;
-} */
-
-.animated-element {
-  /* position: relative; */
 }
     `
   ];
@@ -85,25 +129,34 @@ details {
   constructor() {
     super();
     this.funcName = '';
-    //this.params = {};
     this.result = '';
+    this.isExpanded = true;
+    this.isRunning = false;
+  }
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.checkRunningState();
+  }
+
+  checkRunningState() {
+    const chatMessages = document.querySelectorAll('chat-message');
+    const lastMessage = chatMessages[chatMessages.length - 1];
+    if (lastMessage && lastMessage.getAttribute('spinning') === 'yes') {
+      this.isRunning = true;
+      setTimeout(() => {
+        this.isRunning = false;
+        this.requestUpdate();
+      }, 1000);
+    }
+  }
+
+  _toggleExpanded() {
+    this.isExpanded = !this.isExpanded;
   }
  
   _paramsHTML(params) {
     let paramshtml = '';
-/*    const format_ = (x) => {
-        // if it is a string then split, otherwise return the object
-        if (typeof(x) == 'string') {
-          return x.split('\n')[0].slice(0, 160)
-        } else {
-          if (x+"" == "[[object Object]]") {
-            return JSON.stringify(x)
-          } else {
-            return x
-          }
-        }
-      }
- */
     if (Array.isArray(params)) {
       for (let item of params) {
         paramshtml += `<span class="param_value">(${format_(item)}), </span> `;
@@ -120,6 +173,31 @@ details {
     return paramshtml;
   } 
 
+  _getFirstParamPreview(params) {
+    if (!params) return '';
+    
+    let firstValue = '';
+    if (Array.isArray(params) && params.length > 0) {
+      firstValue = params[0];
+    } else if (typeof(params) == 'object') {
+      const keys = Object.keys(params);
+      if (keys.length > 0) {
+        firstValue = params[keys[0]];
+      }
+    } else {
+      firstValue = params;
+    }
+
+    if (typeof(firstValue) === 'string') {
+      return firstValue.length > 100 ? firstValue.substring(0, 100) + '...' : firstValue;
+    } else if (typeof(firstValue) === 'object') {
+      const str = JSON.stringify(firstValue);
+      return str.length > 100 ? str.substring(0, 100) + '...' : str;
+    } else {
+      const str = String(firstValue);
+      return str.length > 100 ? str.substring(0, 100) + '...' : str;
+    }
+  }
 
   _render() {
     let {funcName, params, result} = this;
@@ -136,18 +214,8 @@ details {
     if (params.val) {
       params = params.val
     }
-    let dontTruncate = false;
-    //let format_;
-    /* if (funcName != 'write') {
-      format_ = (str) => {
-        return str
-      }
-    } else {
-      format_ = (str) => {
-        return str.split('\n')[0].slice(0, 160)
-      }
-    }
-*/
+
+    const paramPreview = this._getFirstParamPreview(params);
     paramshtml = this._paramsHTML(params)
 
     console.log('paramshtml', paramshtml)
@@ -164,7 +232,7 @@ details {
         </details>`;
       }
     }
-    if (funcName === 'write' || funcName == 'think') {
+    if (funcName === 'overwrite' || funcName === 'write' || funcName == 'think') {
       let {fname, text} = params;
       if (params.extensive_chain_of_thoughts) {
         text = params.extensive_chain_of_thoughts
@@ -173,7 +241,9 @@ details {
       console.log("Displaying file")
       if (fname?.endsWith('.md') || funcName == 'think') {
         console.log("Displaying markdown")
-        res = html`<div class="markdown-content">${unsafeHTML(tryParse(text, {breaks: true}))}</div>`;
+        if (true || Date.now() - window.lastParsed > 300) {
+           res = html`<div class="markdown-content">${unsafeHTML(tryParse(text, {breaks: true}))}</div>`;
+        }
       } else {
         console.log("Displaying code")
         const hih = hljs.highlightAuto(text).value;
@@ -183,7 +253,9 @@ details {
     } else {
       if (typeof(params) === "string") {
           try {
-            res = html`<div class="markdown-content">${unsafeHTML(tryParse(params))}</div>`;
+            if (true || Date.now() - window.lastParsed > 300) {
+              res = html`<div class="markdown-content">${unsafeHTML(tryParse(params))}</div>`;
+            }
           } catch (e) {
             res = html`<pre><code>${params}</code></pre>`;
           }
@@ -193,7 +265,9 @@ details {
           if (typeof(params[key]) === 'string' && params[key].split('\n').length > 2) {
             console.log('rendering markdown', params[key])
             try { 
-            res = html`<div class="markdown-content">${unsafeHTML(tryParse(params[key]+" "))}</div>`;
+              if (true || Date.now() - window.lastParsed > 300) {
+                res = html`<div class="markdown-content">${unsafeHTML(tryParse(params[key]+" "))}</div>`;
+              }
             } catch (e) {
               res = html`<pre><code>${params[key]}</code></pre>`;
             }
@@ -209,15 +283,18 @@ details {
     }
 
     return html`
-    <details class="animated-element-x" style="position: relative; max-width: 800px;" open >
-      <!-- we need to make sure it's open by default so we will set property to true -->
-      <summary class="fn_name">⚡ ${funcName}</summary>
-      <div class="av-x"></div>
-      <div class="action">
-        <span class="fn_name"> ${unsafeHTML(paramshtml)}</span>
-        ${res}
-      </div> 
-    </details>
+    <div class="action-container ${this.isRunning ? 'running' : ''}">
+      <div class="action-summary" @click="${this._toggleExpanded}">
+        <span class="fn_name">${funcName}</span>
+        ${paramPreview ? html`<span class="param-preview">${paramPreview}</span>` : ''}
+      </div>
+      <div class="action-content ${this.isExpanded ? 'expanded' : ''}">
+        <div class="action">
+          <span class="fn_name"> ${unsafeHTML(paramshtml)}</span>
+          ${res}
+        </div>
+      </div>
+    </div>
     `;
   }
 }

mindroot/coreplugins/chat/static/js/chat-history.js

@@ -89,6 +89,9 @@ export class ChatHistory {
                console.log('user mesage: found command')
                let parsed = cmd.result
                try {
+                 if (typeof parsed != 'string') {
+                     parsed = JSON.stringify(parsed);
+                 }
                  parsed = markdownRenderer.parse(parsed);
                  console.log("rendered command result markdown")
                } catch (e) {

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

@@ -12,6 +12,11 @@ import { SSE } from './sse.js';
 import { registerDelegate } from './delegate_task.js'
 import showNotification from './notification.js';
 
+if (!window.lastParsed) window.lastParsed = Date.now();
+if (!window.lastScrolled) window.lastScrolled = Date.now();
+
+window.lastScrolled = Date.now();
+
 const commandHandlers = {};
 
 // Function to register command handlers
@@ -26,6 +31,8 @@ function tryParse(markdown) {
     return markdownRenderer.parse(markdown);
 }
 
+const noAction = [ 'say', 'json_encoded_md', 'wait_for_user_reply', 'markdown_await_user', 'tell_and_continue', 'think' ]
+
 class Chat extends BaseEl {
   static properties = {
     sessionid: { type: String },
@@ -56,6 +63,7 @@ class Chat extends BaseEl {
     this.history = new ChatHistory(this);
     console.log(this);
   }
+
   
   exposeSubcomponents() {
     // Get all chat-message elements
@@ -136,6 +144,8 @@ class Chat extends BaseEl {
     showNotification('error', data.error);
   }
 
+  
+
   _addMessage(event) {
     const { content, sender, persona } = event.detail;
     
@@ -187,13 +197,24 @@ class Chat extends BaseEl {
     }, 100)
   }
 
-  _finished(event) {
+  async _finished(event) {
     console.log('Chat finished');
     this.task_id = null
     this.userScrolling = false;
     this._scrollToBottom()
   }
 
+  textParam (data) {
+    if (data.params.text) {
+      return data.params.text;
+      } else if (data.params.markdown) {
+      return data.params.markdown;
+      } else if (data.params.extensive_chain_of_thoughts) {
+      return data.params.extensive_chain_of_thoughts;
+      }
+    return JSON.stringify(data.params);
+  }
+
   async _partialCmd(event) {
     console.log('Event received');
     console.log(event);
@@ -211,28 +232,33 @@ class Chat extends BaseEl {
       this.startNewMsg = false
     }
 
-    if (data.command == 'say' || data.command == 'json_encoded_md' ||
-        data.command == 'wait_for_user_reply' || data.command == 'markdown_await_user' ||
-        data.command == 'tell_and_continue' || data.command=='think') {
+    if (noAction.includes(data.command)) {
       // Check if there's a registered handler for this command
       if (handler) {
         console.log('Used registered handler for', data.command);
         this.msgSoFar = null
-      } else if (data.params.text) {
-        this.msgSoFar = data.params.text
-      } else if (data.params.markdown) {
-        this.msgSoFar = data.params.markdown
-      } else if (data.params.extensive_chain_of_thoughts) {
-        this.msgSoFar = data.params.extensive_chain_of_thoughts
       } else {
-        this.msgSoFar = data.params
+        this.msgSoFar = this.textParam(data);
       }
 
       try {
+        if (!window.lastParsed) window.lastParsed = Date.now();
         if (content) {
           this.messages[this.messages.length - 1].content = content
         } else if (this.msgSoFar) {
-          this.messages[this.messages.length - 1].content = tryParse(this.msgSoFar);
+          let elapsed_ = Date.now() - window.lastParsed;
+          if (elapsed_ > 40 || this.msgSoFar + '' == '[object Object]' ) {
+            const parsed_ = tryParse(this.msgSoFar);
+            if (false && parsed_+'' == '[object Object]') {
+              console.log('msgSoFar is an object, not parsing:', this.msgSoFar);
+            } else {
+              this.messages[this.messages.length - 1].content = parsed_;
+              console.log(' parsed ', elapsed_);
+              window.lastParsed = Date.now();
+            }
+          } else {
+            console.log('********************************* only ',elapsed_);
+          }
         }
       } catch (e) {
         console.error("Could not parse markdown:", e)
@@ -263,12 +289,17 @@ class Chat extends BaseEl {
       const paramStr = JSON.stringify(data.params)
       const escaped = escapeJsonForHtml(paramStr)
       if (content) {
+        console.log('found content, not using action component')
         this.messages[this.messages.length - 1].content = content
       } else {
-        this.messages[this.messages.length - 1].content = `
-         <action-component funcName="${data.command}" params="${escaped}" 
-                             result="">
-          </action-component>`;
+        if (this.messages[this.messages.length - 1].content == '' ||
+            Date.now()- window.lastParsed > 40) {
+          window.lastParsed = Date.now();
+          this.messages[this.messages.length - 1].content = `
+           <action-component funcName="${data.command}" params="${escaped}" 
+                               result="">
+            </action-component>`; 
+        }
       }
     }
     this.requestUpdate();
@@ -308,6 +339,11 @@ class Chat extends BaseEl {
       }
     } else {
       console.warn('No handler for command:', data.command)
+      if (!noAction.includes(data.command)) {
+        this.messages[this.messages.length - 1].content = `<action-component funcName="${data.command}" params="${escapeJsonForHtml(JSON.stringify(data.args))}" result=""></action-component>`;
+      } else {
+        this.messages[this.messages.length - 1].content = tryParse(this.textParam(data));
+      }
     }
     window.initializeCodeCopyButtons();
     this.requestUpdate();
@@ -345,6 +381,7 @@ class Chat extends BaseEl {
     this.messages = [...this.messages, { content: html, sender: 'ai', spinning: 'no' }]
   }
 
+
   _scrollToBottom(forceInstant = false) {
     const chatLog = this.shadowRoot.querySelector('.chat-log');
     if (!chatLog) return;
@@ -359,6 +396,12 @@ class Chat extends BaseEl {
       if (window.access_token && window.access_token.length > 20) {
         console.log('this is an embed probably, not scrolling messages')
       } else {
+        const elapsed = Date.now() - window.lastScrolled;
+        if (elapsed < 300) {
+          console.log('Not scrolling to bottom, too soon after last scroll');
+          return;
+        }
+        window.lastScrolled = Date.now();
         lastEl.scrollIntoView({ behavior: forceInstant ? 'instant' : 'instant', block: 'end' });
       }
 

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

@@ -0,0 +1,221 @@
+diff --git a/src/mindroot/coreplugins/chat/static/js/chat.js b/src/mindroot/coreplugins/chat/static/js/chat.js
+index 0f2ce57..53e28b9 100644
+--- a/src/mindroot/coreplugins/chat/static/js/chat.js
++++ b/src/mindroot/coreplugins/chat/static/js/chat.js
+@@ -34,7 +34,8 @@ function debounce(func, delay) {
+   };
+ }
+ 
+-// Create a throttled parser that limits parsing frequency but doesn't skip updates
++// Single place to perform a safe markdown parse and update the message
++function updateParsedMessage(markdown, messageIndex, chatInstance) {
+ const throttledParse = throttle((markdown, messageIndex, chatInstance) => {
+   try {
+     const result = markdownRenderer.parse(markdown);
+@@ -46,32 +47,44 @@ const throttledParse = throttle((markdown, messageIndex, chatInstance) => {
+     }
+   } catch (e) {
+     console.error("Could not parse markdown:", e);
++    console.error(\"Could not parse markdown:\", e);
+     if (chatInstance.messages[messageIndex]) {
+       chatInstance.messages[messageIndex].content = `<pre><code>${markdown}</code></pre>`;
+       chatInstance.requestUpdate();
+     }
+   }
+-}, 100); // Throttle to max 10 updates per second
+-
+-function tryParse(markdown, useThrottle = false, messageIndex = null, chatInstance = null) {
+-  if (!useThrottle || !chatInstance || messageIndex === null) {
+-    // Immediate parsing for cases where we don't need throttling
+-    try {
+-      return markdownRenderer.parse(markdown);
+-    } catch (e) {
+-      console.error("Could not parse markdown:", e);
+-      return `<pre><code>${markdown}</code></pre>`;
++}, 350); // Throttle to max 10 updates per second
++
++// Debounced parser to ensure we always flush the last update after a quiet period
++const debouncedParse = debounce((markdown, messageIndex, chatInstance) => {
++  try {
++    const result = markdownRenderer.parse(markdown);
++    if (chatInstance.messages[messageIndex]) {
++      chatInstance.messages[messageIndex].content = result;
++      chatInstance.requestUpdate();
++      chatInstance._scrollToBottom();
++      if (typeof window.initializeCodeCopyButtons === 'function') {
++        try { window.initializeCodeCopyButtons(); } catch (_) {}
++      }
+     }
+-  } else {
+-    // Throttled parsing - will update the message in place
+-    throttledParse(markdown, messageIndex, chatInstance);
+-    // Return current content immediately (might be partially parsed)
+-    try {
+-      return markdownRenderer.parse(markdown);
+-    } catch (e) {
+-      return `<pre><code>${markdown}</code></pre>`;
++  } catch (e) {
++    console.error("Could not parse markdown:", e);
++    if (chatInstance.messages[messageIndex]) {
++      chatInstance.messages[messageIndex].content = `<pre><code>${markdown}</code></pre>`;
++      chatInstance.requestUpdate();
+     }
+   }
++}, 150);
++}
++
++function tryParse(markdown) {
++  // Immediate parse for non-streaming contexts
++  try {
++    return markdownRenderer.parse(markdown);
++  } catch (e) {
++    console.error("Could not parse markdown:", e);
++    return `<pre><code>${markdown}</code></pre>`;
++  }
+ }
+ 
+ class Chat extends BaseEl {
+@@ -103,6 +116,12 @@ class Chat extends BaseEl {
+     console.log('Chat component created');
+     this.history = new ChatHistory(this);
+     console.log(this);
++
++    // Per-message streaming schedulers (index -> state)
++    this._streamSchedulers = new Map();
++    this._lastCopyInit = 0;
++    // Throttle scroll to reduce layout thrash during streaming
++    this._scrollToBottomThrottled = throttle(() => this._scrollToBottom(), 150);
+   }
+   
+   exposeSubcomponents() {
+@@ -178,6 +197,82 @@ class Chat extends BaseEl {
+     }, 100);
+   }
+ 
++  // Hybrid scheduler: leading throttle + trailing debounce + guaranteed final flush
++  _ensureScheduler(messageIndex) {
++    if (!this._streamSchedulers.has(messageIndex)) {
++      this._streamSchedulers.set(messageIndex, {
++        lastText: '',
++        lastRun: 0,
++        leadingTimer: null,
++        trailingTimer: null,
++        running: false
++      });
++    }
++    return this._streamSchedulers.get(messageIndex);
++  }
++
++  _scheduleMarkdownUpdate(messageIndex, text, { final = false } = {}) {
++    const MIN_INTERVAL = 150;   // ms between heavy parses while streaming
++    const QUIET_DEBOUNCE = 120; // flush after quiet period
++    const state = this._ensureScheduler(messageIndex);
++    state.lastText = text ?? '';
++
++    const parseNow = (isFinal) => {
++      if (!this.messages[messageIndex]) return;
++      // Avoid overlapping parses
++      if (state.running) return;
++      state.running = true;
++      try {
++        const result = markdownRenderer.parse(state.lastText);
++        this.messages[messageIndex].content = result;
++      } catch (e) {
++        console.error('Could not parse markdown:', e);
++        this.messages[messageIndex].content = `<pre><code>${state.lastText}</code></pre>`;
++      } finally {
++        state.lastRun = Date.now();
++        state.running = false;
++      }
++      // Only initialize copy buttons occasionally or on final
++      const now = Date.now();
++      if (isFinal || now - this._lastCopyInit > 1000) {
++        if (typeof window.initializeCodeCopyButtons === 'function') {
++          try { window.initializeCodeCopyButtons(); } catch (_) {}
++        }
++        this._lastCopyInit = now;
++      }
++      this.requestUpdate();
++      this._scrollToBottomThrottled();
++    };
++
++    // Final flush: cancel timers and render immediately
++    if (final) {
++      if (state.leadingTimer) clearTimeout(state.leadingTimer);
++      if (state.trailingTimer) clearTimeout(state.trailingTimer);
++      state.leadingTimer = null;
++      state.trailingTimer = null;
++      parseNow(true);
++      return;
++    }
++
++    const now = Date.now();
++    const elapsed = now - state.lastRun;
++
++    // Leading throttle: if enough time has passed, schedule a near-immediate parse
++    if (elapsed >= MIN_INTERVAL && !state.leadingTimer) {
++      state.leadingTimer = setTimeout(() => {
++        state.leadingTimer = null;
++        parseNow(false);
++      }, 0);
++    }
++
++    // Trailing debounce: always ensure a quiet-period flush happens
++    if (state.trailingTimer) clearTimeout(state.trailingTimer);
++    state.trailingTimer = setTimeout(() => {
++      state.trailingTimer = null;
++      parseNow(false);
++    }, QUIET_DEBOUNCE);
++  }
++
+   _showError(event) {
+     console.log("NOTIFICATION", event)
+     const data = JSON.parse(event.data);
+@@ -276,18 +371,11 @@ class Chat extends BaseEl {
+         this.msgSoFar = data.params
+       }
+ 
+-      if (content) {
+-        this.messages[this.messages.length - 1].content = content
+-        this.requestUpdate();
+-        this._scrollToBottom()
+       } else if (this.msgSoFar) {
+-        // Use throttled parsing for frequent updates - this ensures all updates are shown
++      } else if (this.msgSoFar) {
++        // Hybrid scheduled parsing for frequent partial updates when no handler content
+         const messageIndex = this.messages.length - 1;
+-        const parsedContent = tryParse(this.msgSoFar, true, messageIndex, this);
+-        this.messages[messageIndex].content = parsedContent;
+-        this.requestUpdate();
+-        this._scrollToBottom();
+-        window.initializeCodeCopyButtons();
++        this._scheduleMarkdownUpdate(messageIndex, this.msgSoFar, { final: false });
+       }
+     } else {
+       console.log('partial. data.params', data.params)
+@@ -320,8 +408,7 @@ class Chat extends BaseEl {
+           </action-component>`;
+       }
+       this.requestUpdate();
+-      this._scrollToBottom()
+-      window.initializeCodeCopyButtons();
++      this._scrollToBottomThrottled();
+     }
+   }
+ 
+@@ -374,7 +461,14 @@ class Chat extends BaseEl {
+       msg.spinning = 'no'
+       console.log('Spinner set to false:', msg);
+     }
+-    window.initializeCodeCopyButtons();
++    // Ensure final flush of any in-flight partial markdown for the last AI message
++    const lastIndex = this.messages.length - 1;
++    const sched = this._streamSchedulers.get(lastIndex);
++    if (sched && typeof sched.lastText === 'string' && sched.lastText.length > 0) {
++      this._scheduleMarkdownUpdate(lastIndex, sched.lastText, { final: true });
++    } else if (typeof window.initializeCodeCopyButtons === 'function') {
++      try { window.initializeCodeCopyButtons(); } catch (_) {}
++    }
+     this.requestUpdate();
+   }
+ 

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

@@ -53,7 +53,7 @@ class ChatForm extends BaseEl {
         position: absolute;
         right: 21px; /* Original optimal position */
         margin-right: 5px;
-        bottom: 15px; /* Raised 5px to prevent bottom overlap */
+        bottom: 1.5em; /* Raised 5px to prevent bottom overlap */
         /* background: transparent; */
         background-color: #101020
 
@@ -64,7 +64,7 @@ class ChatForm extends BaseEl {
         position: absolute;
         margin-right: 5px;
         right: 61px; /* Maintains 40px spacing from send button */
-        bottom: 15px; /* Matches send button exactly */
+        bottom: 1.5em; /* Matches send button exactly */
         background: #ff4d4d;
         color: white;
         border: none;