mindroot 14.0.0__tar.gz → 14.2.0__tar.gz

{mindroot-14.0.0/src/mindroot.egg-info → mindroot-14.2.0}/PKG-INFO

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

{mindroot-14.0.0 → mindroot-14.2.0}/pyproject.toml

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

{mindroot-14.0.0 → mindroot-14.2.0}/src/mindroot/coreplugins/agent/agent.py

@@ -25,6 +25,46 @@ from lib.chatcontext import ChatContext
 from .cmd_start_example import *
 from lib.templates import render
 import nanoid
+from lib.xml_stream_events import XmlEventStream
+from lib.xml_docstring_adapter import convert_docstring_json_examples_to_xml
+
+
+def _truthy(val) -> bool:
+    return str(val).lower() in ('1', 'true', 'yes', 'on')
+
+
+def xml_streaming_enabled(context=None) -> bool:
+    """Whether XML/raw-text command streaming is active for THIS agent/turn.
+
+    Per-agent ONLY by default: the flag must be set in the agent's own env
+    overrides (context.env['MR_XML_STREAMING'], populated from agent.json
+    'env'). This deliberately does NOT honor a bare process-level
+    MR_XML_STREAMING, because that would silently switch EVERY agent (including
+    JSON/text agents and delegated mr_sip call children) into speak-everything
+    XML mode and break them.
+
+    Escape hatch for genuinely all-voice instances: set MR_XML_STREAMING_GLOBAL
+    (process env) truthy to allow the process-level MR_XML_STREAMING fallback.
+    """
+    # 1) Per-agent override (authoritative).
+    if context is not None:
+        env = getattr(context, 'env', None)
+        if isinstance(env, dict) and 'MR_XML_STREAMING' in env:
+            return _truthy(env.get('MR_XML_STREAMING'))
+
+    # 2) Opt-in process-wide fallback only when explicitly globalized.
+    #    Read the RAW environ to avoid the context-aware shim resolving these
+    #    from a nearby context.env (we already handled per-agent above).
+    raw_env = os.environ
+    try:
+        from lib.context_environ import _original_environ as _raw
+        if _raw is not None:
+            raw_env = _raw
+    except Exception:
+        pass
+    if _truthy(raw_env.get('MR_XML_STREAMING_GLOBAL', '')):
+        return _truthy(raw_env.get('MR_XML_STREAMING', ''))
+    return False
 
 
 import logging
@@ -511,6 +551,172 @@ class Agent:
  
         return results, full_cmds
 
+    async def execute_command(self, cmd_name, cmd_args, context=None, cmd_id=None):
+        """Execute a single command WITHOUT writing the assistant message.
+
+        This is the execution half of handle_cmds, used by the XML/raw-text
+        streaming path where the assistant message is persisted once per turn
+        (raw text + parsed commands) via chat_log.replace_last_assistant.
+        """
+        if context.data.get('cancel_current_turn'):
+            logger.warning("Turn cancelled, not executing command")
+            raise asyncio.CancelledError("Turn cancelled")
+        if context.data.get('finished_conversation'):
+            logger.warning("Conversation finished, not executing command")
+            return None
+
+        command_manager.context = context
+        if cmd_name == "reasoning":
+            return None
+        try:
+            if isinstance(cmd_args, list):
+                cmd_args = [x for x in cmd_args if x != '']
+                await context.running_command(cmd_name, cmd_args, cmd_id=cmd_id)
+                return await command_manager.execute(cmd_name, *cmd_args)
+            elif isinstance(cmd_args, dict):
+                await context.running_command(cmd_name, cmd_args, cmd_id=cmd_id)
+                return await command_manager.execute(cmd_name, **cmd_args)
+            else:
+                await context.running_command(cmd_name, cmd_args, cmd_id=cmd_id)
+                return await command_manager.execute(cmd_name, cmd_args)
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            trace = traceback.format_exc()
+            print("\033[96mError in execute_command: " + str(e) + "\033[0m")
+            print("\033[96m" + trace + "\033[0m")
+            logger.error("Error in execute_command", extra={
+                "error": str(e), "command": cmd_name, "traceback": trace})
+            return {"error": str(e)}
+
+    async def _persist_xml_assistant(self, context, original_buffer, collected):
+        """Authoritatively (re)write the current turn's assistant message.
+
+        Stores raw model text (format='xml') plus the parsed command list so the
+        UI / cascade deletion / token tooling never have to parse XML.
+        """
+        content = [{"type": "text", "text": original_buffer, "format": "xml"}]
+        try:
+            await context.chat_log.replace_last_assistant(content, commands=list(collected))
+        except Exception as e:
+            logger.error(f"Error persisting xml assistant message: {e}")
+
+    async def parse_xml_cmd_stream(self, stream, context):
+        """First-class XML/raw-text command stream parser.
+
+        Text outside tags is spoken (speak command). Tags are commands. No
+        XML->JSON->reparse round trip, no JSON buffer surgery, no invalid-format
+        error path (the adapter speaks unknown/incomplete tags as literal text).
+        """
+        results = []
+        full_cmds = []
+        collected = []           # parsed commands for dual representation
+        original_buffer = ""
+
+        emit_chars = 8
+        try:
+            if context.agent and context.agent.get('xml_emit_partial_on_chars') is not None:
+                emit_chars = int(context.agent.get('xml_emit_partial_on_chars'))
+        except Exception:
+            pass
+
+        ev = XmlEventStream(emit_partial_on_chars=emit_chars)
+
+        # speak segment correlation: partials + the final speak share one cmd_id
+        seg_cmd_id = None
+        # XML/raw-text mode is primarily for low-latency voice agents. Do not
+        # apply the JSON partial throttling knobs here: those exist mainly to
+        # protect the UI/event loop during large JSON/code/file outputs. For
+        # voice, every speak_partial should reach the TTS partial_command pipe
+        # immediately so Kyutai can stream input as soon as text arrives.
+
+        debug_box("Parsing XML command stream")
+
+        async def process_events(events):
+            nonlocal seg_cmd_id
+            for evt in events:
+                kind = evt.get('kind')
+
+                if context.data.get('finished_conversation') or context.data.get('cancel_current_turn'):
+                    return True  # signal stop
+
+                if kind == 'speak_partial':
+                    text = evt['text']
+                    if seg_cmd_id is None:
+                        seg_cmd_id = nanoid.generate()
+                    await context.partial_command('speak', json.dumps({'text': text}), {'text': text}, cmd_id=seg_cmd_id)
+
+                elif kind == 'speak_final':
+                    text = evt['text']
+                    if seg_cmd_id is None:
+                        seg_cmd_id = nanoid.generate()
+                    args = {'text': text}
+                    await context.partial_command('speak', json.dumps(args), args, cmd_id=seg_cmd_id)
+                    result = await self.execute_command('speak', args, context=context, cmd_id=seg_cmd_id)
+                    await context.command_result('speak', result, cmd_id=seg_cmd_id)
+                    collected.append({'speak': args})
+                    full_cmds.append({"SYSTEM": "", "cmd": "speak", "args": args, "result": result})
+                    if result is not None:
+                        results.append({"SYSTEM": "", "cmd": "speak", "args": {"omitted": "(see command msg.)"}, "result": result})
+                    seg_cmd_id = None
+                    await self._persist_xml_assistant(context, original_buffer, collected)
+
+                elif kind == 'cmd':
+                    name = evt['name']
+                    props = evt['props']
+                    cmd_id = nanoid.generate()
+                    await context.partial_command(name, json.dumps(props), props, cmd_id=cmd_id)
+                    cmd_task = asyncio.create_task(
+                        self.execute_command(name, props, context=context, cmd_id=cmd_id)
+                    )
+                    context.data['active_command_task'] = cmd_task
+                    try:
+                        result = await cmd_task
+                    except asyncio.CancelledError:
+                        raise
+                    finally:
+                        if context.data.get('active_command_task') == cmd_task:
+                            del context.data['active_command_task']
+                    await context.command_result(name, result, cmd_id=cmd_id)
+                    collected.append({name: props})
+                    full_cmds.append({"SYSTEM": "", "cmd": name, "args": props, "result": result})
+
+                    if result == "SYSTEM: WARNING - Command interrupted!\n\n":
+                        logger.warning("Command was interrupted. Stopping processing.")
+                        await context.chat_log.drop_last('assistant')
+                        await asyncio.sleep(0.5)
+                        return True
+
+                    if result is not None:
+                        results.append({"SYSTEM": "", "cmd": name, "args": {"omitted": "(see command msg.)"}, "result": result})
+                    await self._persist_xml_assistant(context, original_buffer, collected)
+            return False
+
+        stopped = False
+        try:
+            async for part in stream:
+                original_buffer += part
+                context.data['_xml_original_buffer'] = original_buffer
+                await asyncio.sleep(0)
+                stopped = await process_events(ev.feed(part))
+                if stopped:
+                    try:
+                        stream.close()
+                    except Exception:
+                        pass
+                    break
+        except asyncio.CancelledError:
+            logger.info("XML command stream parsing cancelled")
+            raise
+
+        if not stopped:
+            await process_events(ev.finish())
+
+        # Final authoritative write (captures any trailing speech).
+        await self._persist_xml_assistant(context, original_buffer, collected)
+
+        return results, full_cmds
+
     async def render_system_msg(self, context):
         t0 = time.time()
         #logger.debug("Docstrings:")
@@ -539,14 +745,30 @@ class Agent:
                 print("Removing " + cmd + " from command_docs")
                 del data['command_docs'][cmd]
 
+        xml_mode = xml_streaming_enabled(context)
+        if xml_mode:
+            # Convert JSON-style command docstrings to compact XML-ish examples
+            # so a small voice model is primed to emit tags, not JSON.
+            converted = {}
+            for _cn, _doc in data['command_docs'].items():
+                try:
+                    converted[_cn] = convert_docstring_json_examples_to_xml(_doc or '')
+                except Exception:
+                    converted[_cn] = _doc
+            data['command_docs'] = converted
+
+        # Select a clean XML-output system template when XML streaming is on.
+        # No plugin defines 'system_xml', so there is no override-precedence
+        # ambiguity; the process_system_message pipe below still runs as a hook.
+        page = 'system_xml' if xml_mode else 'system'
         #self.system_message = self.sys_template.render(data)
-        self.system_message = await render('system', data)
+        self.system_message = await render(page, data)
         render_ms = (time.time() - t0) * 1000
         logger.info(f'render_system_msg took {render_ms:.1f}ms')
 
         # Allow plugins to modify the final system message text (string -> string)
         try:
-            tmp = await pipeline_manager.process_system_message({'text': self.system_message}, context=context)
+            tmp = await pipeline_manager.process_system_message({'text': self.system_message, 'data': data}, context=context)
             self.system_message = tmp.get('text', self.system_message)
         except Exception as e:
             logger.error(f"Error in process_system_message pipe: {e}")
@@ -611,7 +833,10 @@ class Agent:
                                         context=context)
         
         try:
-            ret, full_cmds = await self.parse_cmd_stream(stream, context)
+            if xml_streaming_enabled(context):
+                ret, full_cmds = await self.parse_xml_cmd_stream(stream, context)
+            else:
+                ret, full_cmds = await self.parse_cmd_stream(stream, context)
         except asyncio.CancelledError:
             logger.info("Command stream parsing cancelled")
             raise  # Propagate cancellation

mindroot-14.2.0/src/mindroot/coreplugins/agent/templates/system_xml.jinja2

@@ -0,0 +1,71 @@
+{% block sysinfo %}
+Current System Date: {{ formatted_datetime }}
+{% endblock %}
+
+{% block context %}
+{% if context_data %}
+## Context
+{% for key in context_data %}
+{{ key }}: {{ context_data[key] }}
+{% endfor %}
+{% endif %}
+{% endblock %}
+
+{% block agentid %}
+# Agent
+Name: {{ agent.name }}
+{% endblock %}
+
+{% block persona %}
+# Persona
+You are {{ persona.name }}.
+{{ persona.description }}
+{% if persona.appearance %}Appearance: {{ persona.appearance }}{% endif %}
+{% if persona.behavior %}Behavior: {{ persona.behavior }}{% endif %}
+{% if persona.speech_patterns %}Speech: {{ persona.speech_patterns }}{% endif %}
+{% endblock %}
+
+{% block agent_instr %}
+{% if agent.instructions %}
+# Instructions
+{{ agent.instructions }}
+{% endif %}
+{% endblock %}
+
+{% block output_format %}
+# How to respond
+
+You control a character by writing plain text and tags. There is no JSON.
+
+1. Anything you type that is NOT inside a tag is spoken out loud. Just write
+   what you want to say, normally.
+
+2. To take an action, write a tag. Two forms:
+
+   Simple actions use attributes:
+     <wait_for_user_reply text="How can I help?"/>
+     <send_dtmf digits="1"/>
+
+   Actions with complex/nested data put a tool call body inside:
+     <tool name="some_command">{"key": "value", "nested": {"a": 1}}</tool>
+
+3. You can mix speech and actions in order. For example, say something, then
+   act:
+
+     Sure, let me look that up for you.
+     <search_web query="weather today"/>
+
+   The words are spoken, then the action runs.
+
+4. After an action that returns a result, the result comes back to you before
+   you continue. Don't guess results of actions you haven't run yet.
+
+Keep it natural and in character. Speak like {{ persona.name }}.
+{% endblock %}
+
+{% block commands_available %}
+# Available actions
+{% for cmd in command_docs %}
+{{ cmd }}: {{ command_docs[cmd] }}
+{% endfor %}
+{% endblock %}

{mindroot-14.0.0 → mindroot-14.2.0}/src/mindroot/coreplugins/chat/services.py

@@ -688,3 +688,172 @@ async def cancel_active_response(log_id: str, context=None):
         pass
     await context.save_context()
     return {'status': 'cancelled', 'log_id': log_id}
+
+
+# Commands whose 'text' argument is voiced aloud by TTS.
+_SPEAK_COMMAND_KEYS = ('speak', 'say')
+
+
+def _word_boundary_truncate(text: str, n: int) -> str:
+    """Truncate text to at most n chars, preferring the last word boundary."""
+    if n <= 0:
+        return ''
+    if n >= len(text):
+        return text
+    cut = text[:n]
+    sp = cut.rfind(' ')
+    if sp > 0:
+        return cut[:sp]
+    return cut
+
+
+@service()
+async def truncate_last_assistant_speech(spoken_seconds: float,
+                                         chars_per_second: float = None,
+                                         marker: str = ' ...[interrupted]',
+                                         context=None):
+    """Rewrite the last assistant message so its voiced ('speak'/'say') text
+    reflects roughly how much was ACTUALLY spoken before a barge-in.
+
+    On a phone call the LLM generates a whole sentence in a fraction of a
+    second, but TTS plays it out over real-time seconds. If the caller barges
+    in, only the audio is cut - the stored assistant message still contains the
+    full intended text, so the model thinks it finished and skips ahead. This
+    service truncates the persisted speak text to approximately
+    `spoken_seconds * chars_per_second` characters (word-boundary aligned) and
+    appends `marker`, so the next turn's context reflects what was really said.
+
+    `spoken_seconds` is normally obtained from a TTS/SIP backend (e.g.
+    mr_sip's sip_response_spoken_seconds). It is TTS-agnostic: any backend that
+    paces audio to real time works.
+
+    No-op if nothing was meaningfully cut (budget >= total voiced length).
+    """
+    if context is None or getattr(context, 'chat_log', None) is None:
+        return {'status': 'no_context'}
+    try:
+        cps = chars_per_second
+        if cps is None:
+            # Default tuned for ElevenLabs flash (eleven_flash_v2_5) English
+            # speech, which runs a touch faster than the generic ~14 cps.
+            # Override per-instance with MR_SPEECH_CHARS_PER_SEC.
+            cps = float(os.environ.get('MR_SPEECH_CHARS_PER_SEC', '16'))
+        budget = max(0, int(float(spoken_seconds) * cps))
+
+        messages = context.chat_log.messages
+        idx = None
+        for i in range(len(messages) - 1, -1, -1):
+            if messages[i].get('role') == 'assistant':
+                idx = i
+                break
+        if idx is None:
+            return {'status': 'no_assistant_message'}
+        msg = messages[idx]
+
+        # ---- Resolve the parsed command list + raw content text ----
+        commands = msg.get('commands') if isinstance(msg.get('commands'), list) else None
+        content = msg.get('content')
+        raw_text = None
+        if isinstance(content, list) and content and isinstance(content[0], dict) and 'text' in content[0]:
+            raw_text = content[0]['text']
+        elif isinstance(content, str):
+            raw_text = content
+
+        json_mode = False
+        if commands is None:
+            # JSON command-list agents: content text is the JSON list.
+            if raw_text is not None:
+                try:
+                    parsed = json.loads(raw_text)
+                    if isinstance(parsed, dict):
+                        parsed = [parsed]
+                    if isinstance(parsed, list):
+                        commands = parsed
+                        json_mode = True
+                except Exception:
+                    commands = None
+
+        # Gather voiced text in order.
+        def _is_speak(cmd):
+            if not isinstance(cmd, dict) or len(cmd) != 1:
+                return (None, None)
+            name = next(iter(cmd))
+            args = cmd[name]
+            if name in _SPEAK_COMMAND_KEYS and isinstance(args, dict) and isinstance(args.get('text'), str):
+                return (name, args)
+            return (None, None)
+
+        total_voiced = 0
+        if commands is not None:
+            for cmd in commands:
+                name, args = _is_speak(cmd)
+                if name is not None:
+                    total_voiced += len(args['text'])
+        elif raw_text is not None:
+            # Unstructured: treat whole content as voiced text.
+            total_voiced = len(raw_text)
+
+        if total_voiced == 0:
+            return {'status': 'no_voiced_text'}
+        if budget >= total_voiced:
+            # Not meaningfully interrupted (or barge-in after speech finished).
+            return {'status': 'noop', 'budget': budget, 'total_voiced': total_voiced}
+
+        # ---- Structured (XML or JSON) path ----
+        if commands is not None:
+            remaining = budget
+            new_commands = []
+            search_pos = 0
+            edited_raw = raw_text
+            for cmd in commands:
+                name, args = _is_speak(cmd)
+                if name is None:
+                    new_commands.append(cmd)
+                    continue
+                text = args['text']
+                if remaining >= len(text):
+                    remaining -= len(text)
+                    new_commands.append(cmd)
+                    if edited_raw is not None and not json_mode:
+                        found = edited_raw.find(text, search_pos)
+                        if found != -1:
+                            search_pos = found + len(text)
+                elif remaining > 0:
+                    kept = _word_boundary_truncate(text, remaining)
+                    new_text = kept + marker
+                    if edited_raw is not None and not json_mode:
+                        found = edited_raw.find(text, search_pos)
+                        if found != -1:
+                            edited_raw = edited_raw[:found] + new_text + edited_raw[found + len(text):]
+                            search_pos = found + len(new_text)
+                    new_args = dict(args)
+                    new_args['text'] = new_text
+                    new_commands.append({name: new_args})
+                    remaining = 0
+                else:
+                    # Budget exhausted: this speak was never voiced - drop it.
+                    if edited_raw is not None and not json_mode:
+                        found = edited_raw.find(text, search_pos)
+                        if found != -1:
+                            edited_raw = edited_raw[:found] + edited_raw[found + len(text):]
+                    # do not append (dropped)
+
+            if json_mode:
+                new_text_content = json.dumps(new_commands)
+                await context.chat_log.replace_last_assistant(
+                    [{'type': 'text', 'text': new_text_content}])
+            else:
+                new_content = [{'type': 'text', 'text': edited_raw if edited_raw is not None else '',
+                                'format': 'xml'}]
+                await context.chat_log.replace_last_assistant(new_content, commands=new_commands)
+            return {'status': 'truncated', 'budget': budget, 'total_voiced': total_voiced,
+                    'mode': 'json' if json_mode else 'xml'}
+
+        # ---- Unstructured fallback: truncate whole content as speech ----
+        kept = _word_boundary_truncate(raw_text, budget) + marker
+        await context.chat_log.replace_last_assistant([{'type': 'text', 'text': kept}])
+        return {'status': 'truncated', 'budget': budget, 'total_voiced': total_voiced, 'mode': 'raw'}
+    except Exception as e:
+        print(f'truncate_last_assistant_speech error: {e}')
+        print(traceback.format_exc())
+        return {'status': 'error', 'error': str(e)}

{mindroot-14.0.0 → mindroot-14.2.0}/src/mindroot/coreplugins/chat/static/js/chat-history.js

@@ -62,7 +62,7 @@ export class ChatHistory {
             if (msg.role === 'user') {
                 this._processUserMessage(part, msg.persona);
             } else {
-                this._processAssistantMessage(part, msg.persona);
+                this._processAssistantMessage(part, msg.persona, msg);
             }
         }
     }
@@ -115,11 +115,19 @@ export class ChatHistory {
         }
     }
 
-    _processAssistantMessage(part, persona) {
+    _processAssistantMessage(part, persona, msg) {
         if (part.type === 'image') return;
 
         try {
-            const cmds = JSON.parse(part.text);
+            // Prefer the pre-parsed command list when present (XML/raw-text
+            // mode stores raw text in content + parsed commands in msg.commands).
+            // Fall back to JSON-parsing the text (legacy JSON command logs).
+            let cmds = null;
+            if (msg && Array.isArray(msg.commands)) {
+                cmds = msg.commands;
+            } else {
+                cmds = JSON.parse(part.text);
+            }
             for (let cmd of cmds) {
                 let markdown = null;
                 if (cmd.wait_for_user_reply) {

{mindroot-14.0.0 → mindroot-14.2.0}/src/mindroot/lib/chatlog.py

@@ -236,6 +236,33 @@ class ChatLog:
             self.messages = self.messages[:-1]
             await self.save_log()
 
+    async def replace_last_assistant(self, content, commands=None) -> None:
+        """Set the last assistant message authoritatively (one write per turn).
+
+        Used by the XML/raw-text streaming path so we don't rely on the
+        repeat-role JSON-merge heuristic in _add_message_impl. If the last
+        message is an assistant message, replace it in place; otherwise append
+        a new assistant message.
+
+        Args:
+            content: canonical content (list of {type,text,...} parts) or a str.
+            commands: optional pre-parsed command list [{name: args}, ...] stored
+                      alongside content as message['commands'] so the UI and
+                      cascade/token tooling never need to parse XML.
+        """
+        if isinstance(content, str):
+            content = [{'type': 'text', 'text': content}]
+        message = {'role': 'assistant', 'content': content}
+        if commands is not None:
+            message['commands'] = commands
+        if len(self.messages) > 0 and self.messages[-1]['role'] == 'assistant':
+            self.messages[-1] = message
+        else:
+            self.messages.append(message)
+        self.last_modified = time.time()
+        await self._save_log_async()
+        self._fire_message_added_hook(message)
+
     def get_history(self) -> List[Dict[str, str]]:
         return self.messages
 
@@ -244,6 +271,10 @@ class ChatLog:
         commands = []
         filtered = [m for m in self.messages if m['role'] == 'assistant']
         for message in filtered:
+            # XML/raw-text messages carry a pre-parsed command list.
+            if isinstance(message.get('commands'), list):
+                commands.extend(message['commands'])
+                continue
             content = message['content']
             if isinstance(content, list) and len(content) > 0 and 'text' in content[0]:
                 text = content[0]['text']
@@ -402,6 +433,19 @@ def extract_delegate_task_log_ids(messages: List[Dict]) -> List[str]:
     
     for message in messages:
         if message['role'] == 'assistant':
+            # XML/raw-text messages carry a pre-parsed command list; use it
+            # directly so cascade deletion finds delegated children.
+            if isinstance(message.get('commands'), list):
+                for cmd in message['commands']:
+                    try:
+                        for key, value in cmd.items():
+                            if key == 'delegate_task' and isinstance(value, dict) and 'log_id' in value:
+                                log_ids.append(value['log_id'])
+                            elif key == 'delegate_subtask' and isinstance(value, dict) and 'log_id' in value:
+                                log_ids.append(value['log_id'])
+                    except Exception:
+                        pass
+                continue
             content = message['content']
             # Handle both string and list content formats
             if isinstance(content, str):

{mindroot-14.0.0 → mindroot-14.2.0}/src/mindroot/lib/pipelines/pipelines.py

@@ -14,7 +14,11 @@ class PipelineManager:
             'implementation': implementation,
             'docstring': docstring,
             'priority': priority,
-            'signature': signature
+            'signature': signature,
+            # Cache the coroutine-ness once at registration so the per-call
+            # hot path (e.g. partial_command/process_stream run once per token)
+            # doesn't pay inspect.iscoroutinefunction() on every invocation.
+            'is_async': asyncio.iscoroutinefunction(implementation),
         })
         print(termcolor.colored(f"Registering pipe '{name}' with priority {priority}", 'yellow'))
         self.pipes[name].sort(key=lambda x: x['priority'])
@@ -30,7 +34,7 @@ class PipelineManager:
             implementation = pipe_info['implementation']
             #print(termcolor.colored(f"Executing step with priority {pipe_info['priority']}", 'yellow'))
             try:
-                if asyncio.iscoroutinefunction(implementation):
+                if pipe_info['is_async']:
                     data = await implementation(data, context)
                 else:
                     data = implementation(data, context)