mindroot 10.5.0__py3-none-any.whl → 10.7.0__py3-none-any.whl

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

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

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

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

mindroot/coreplugins/agent/agent.py

@@ -143,9 +143,14 @@ class Agent:
 
     async def handle_cmds(self, cmd_name, cmd_args, json_cmd=None, context=None):
         # Check both permanent finish and temporary cancellation
-        if context.data.get('finished_conversation') or context.data.get('cancel_current_turn'):
-            logger.warning("Conversation is finished, not executing command")
-            print("\033[91mConversation is finished, not executing command\033[0m")
+        if context.data.get('cancel_current_turn'):
+            logger.warning("Turn cancelled, not executing command")
+            print("\033[91mTurn cancelled, not executing command\033[0m")
+            raise asyncio.CancelledError("Turn cancelled")
+        
+        if context.data.get('finished_conversation'):
+            logger.warning("Conversation finished, not executing command")
+            print("\033[91mConversation finished, not executing command\033[0m")
             return None
 
         logger.info("Command execution: {command}", command=cmd_name)
@@ -298,19 +303,23 @@ class Agent:
 
             # Check for cancellation (either permanent or current turn)
             if context.data.get('finished_conversation') or context.data.get('cancel_current_turn'):
-                # Clear the temporary cancel flag so next turn can proceed
-                if 'cancel_current_turn' in context.data:
-                    del context.data['cancel_current_turn']
                 logger.warning("Conversation is finished or halted, exiting stream parsing")
                 debug_box(f"""Conversation is finished or halted, exiting stream""")
                 debug_box(str(context))
-                # stream is actually a generator
+                
+                # Add partial command to chat log if present
                 if partial_cmd is not None:
                     cmd_name = next(iter(partial_cmd))
                     if cmd_name in ["say", "json_encoded_md", "think"]:
                         context.chat_log.add_message({"role": "assistant", "content": str(partial_cmd[cmd_name])})
                     else:
                         context.chat_log.add_message({"role": "assistant", "content": str(partial_cmd) + "(Interrupted)"})
+                
+                # Clear the temporary cancel flag so next turn can proceed
+                if 'cancel_current_turn' in context.data:
+                    del context.data['cancel_current_turn']
+                    await context.save_context()
+                
                 try:
                     stream.close()
                 except Exception as e:
@@ -339,14 +348,15 @@ class Agent:
                         cmd_args = cmd[cmd_name]
                         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
+ 
                         cmd_task = asyncio.create_task(
                             self.handle_cmds(cmd_name, cmd_args, json_cmd=json.dumps(cmd), context=context)
                         )
                         context.data['active_command_task'] = cmd_task
                         try:
                             result = await cmd_task
+                        except asyncio.CancelledError:
+                            raise  # Propagate cancellation up
                         finally:
                             # Clear the task from context once it's done or cancelled
                             if context.data.get('active_command_task') == cmd_task:
@@ -355,6 +365,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. Stopping processing.")
+                            await context.chat_log.drop_last('assistant')
+                            break
+                            return results, full_cmds
+
+
                         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 +491,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,18 +506,30 @@ 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:
                     model = os.environ.get("DEFAULT_LLM_MODEL")
-
+        
+        # we need to be able to abort this task if necessary
         stream = await context.stream_chat(model,
                                         temperature=temperature,
                                         max_tokens=max_tokens,
                                         messages=new_messages,
                                         context=context)
-
-        ret, full_cmds = await self.parse_cmd_stream(stream, context)
+        
+        try:
+            ret, full_cmds = await self.parse_cmd_stream(stream, context)
+        except asyncio.CancelledError:
+            logger.info("Command stream parsing cancelled")
+            raise  # Propagate cancellation
+        
         logger.debug("System message was:")
         logger.debug(await self.render_system_msg())