muonroi-cli 1.7.2 → 1.8.1

package/dist/src/orchestrator/subagent-compactor.js

@@ -104,11 +104,12 @@ export function isHighValueToolResult(toolName, preview, explicitKeepIds, toolCa
         const p = preview.toLowerCase();
         if (/error|fail|todo|plan|done|✔|blocked|critical/.test(p))
             return true;
-        if (/\.(ts|tsx|js|md|json|test|spec)\b/.test(p) || p.includes("src/") || p.includes("PLAN"))
-            return true;
-        if (preview.length > 1500)
-            return true;
-        return true; // read_file/grep etc on source are presumptively high-value
+        if (/\.(ts|tsx|js|md|json|test|spec)\b/.test(p) || p.includes("src/") || p.includes("PLAN")) {
+            // For source code/plans, only keep verbatim if it is relatively small (under 12000 chars)
+            // to prevent large file reads from leaking memory/tokens indefinitely in long sessions.
+            return preview.length <= 12000;
+        }
+        return false;
     }
     if (toolCallId && explicitKeepIds?.has(toolCallId))
         return true;
@@ -126,6 +127,7 @@ function resolveOpts(o) {
         contextFillRatio: Math.min(0.95, Math.max(0.1, o?.contextFillRatio ?? 0.5)),
         keepToolIds: keepIds,
         persistArtifact: o?.persistArtifact,
+        stripOldReasoning: o?.stripOldReasoning ?? false,
     };
 }
 /**
@@ -324,22 +326,25 @@ function rewriteOlderToolMessage(msg, previewChars, label, keepToolIds, persistA
 export function compactSubAgentMessages(messages, opts = {}) {
     const resolved = resolveOpts(opts);
     const { outputPreviewChars, label, envelopeChars } = resolved;
-    // F2 — threshold check uses TRUE prompt size (messages + system + tools).
-    // The envelope (system prompt + JSON-schema for every tool) is re-sent on
-    // every step and was previously invisible to the compactor, so a session
-    // with 20-50K of fixed overhead would never trip the messages-only check.
+    // Step 4: Hard-limit message history sent to the model to prevent token bloating
+    // When input (messages + envelope) exceeds 50K characters and messages array is > 30,
+    // we slice the history to keep at most 30 messages (preserving system and user start).
+    let processedMessages = messages;
     const messagesTotal = cumulativeMessageChars(messages);
     const total = messagesTotal + envelopeChars;
-    // G1 + G2 — derive effective threshold and keepLastTurns from context
-    // window utilization. Falls back to static char threshold + keepLast
-    // when no contextWindowTokens supplied (preserves old behaviour).
-    const { effectiveThresholdChars, effectiveKeepLastTurns } = computeDynamicParams(total, resolved);
+    if (total > 50_000 && messages.length > 30) {
+        processedMessages = sliceMessageHistory(messages, 30);
+    }
+    // Calculate effective thresholds and keep last turns using the processed messages
+    const processedMessagesTotal = cumulativeMessageChars(processedMessages);
+    const processedTotal = processedMessagesTotal + envelopeChars;
+    const { effectiveThresholdChars, effectiveKeepLastTurns } = computeDynamicParams(processedTotal, resolved);
     // No-op: return the input BY REFERENCE (contract above) so `compacted === input`.
-    if (total < effectiveThresholdChars)
-        return messages;
-    const keepFrom = findKeepFromIndex(messages, effectiveKeepLastTurns);
+    if (processedTotal < effectiveThresholdChars)
+        return processedMessages;
+    const keepFrom = findKeepFromIndex(processedMessages, effectiveKeepLastTurns);
     if (keepFrom <= 0)
-        return messages;
+        return processedMessages;
     // Walk older messages; rewrite fresh tool results into stubs, super-shrink
     // already-stubbed results (F1), and strip args off older assistant
     // tool-call shells (F1). The 1:1 assistant↔tool pairing required by the AI
@@ -347,8 +352,8 @@ export function compactSubAgentMessages(messages, opts = {}) {
     // structure or count.
     let firstUserSeen = false;
     const out = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
+    for (let i = 0; i < processedMessages.length; i++) {
+        const msg = processedMessages[i];
         if (i >= keepFrom) {
             out.push(msg);
             continue;
@@ -378,17 +383,43 @@ export function compactSubAgentMessages(messages, opts = {}) {
             continue;
         }
         if (msg.role === "assistant" && Array.isArray(msg.content)) {
-            // F1 — strip args off older assistant tool-call shells. 50+ of these
-            // accumulate ~10-30K chars of args (file paths, bash commands) that
-            // the model does not need once the matching result has been elided.
-            // We keep toolCallId + toolName so pairing with tool-result is intact.
-            out.push(stripAssistantToolCallArgs(msg));
+            // T1.1 — strip reasoning parts from older assistant turns. DeepSeek V4
+            // Flash / R1 emit 2K-5K reasoning tokens per turn that accumulate
+            // across the multi-step loop. These are never re-read by the model
+            // but cost full input billing on every subsequent round. Strip them
+            // from turns older than keepLastTurns to cut ~30-50% of input tokens.
+            // Then F1 — strip args off older assistant tool-call shells.
+            let processed = resolved.stripOldReasoning ? stripAssistantReasoning(msg) : msg;
+            processed = stripAssistantToolCallArgs(processed);
+            out.push(processed);
             continue;
         }
         out.push(msg);
     }
     return out;
 }
+/**
+ * T1.1 — strip reasoning parts from an assistant message. Reasoning tokens
+ * (CoT / `<think>`) from older turns have zero re-read value for the model
+ * on subsequent steps but they accumulate O(N) chars per turn and are billed
+ * as full input tokens. Removing them from turns older than keepLastTurns
+ * cuts ~30-50% of cumulative input in multi-step loops with reasoning models
+ * (DeepSeek V4 Flash, R1, etc.).
+ *
+ * Preserves text + tool-call parts (the structural skeleton the model needs
+ * to maintain coherent tool-call↔tool-result pairing).
+ */
+function stripAssistantReasoning(msg) {
+    if (!Array.isArray(msg.content))
+        return msg;
+    const parts = msg.content;
+    const filtered = parts.filter((part) => part.type !== "reasoning");
+    if (filtered.length === parts.length)
+        return msg; // nothing stripped
+    // Edge case: if ALL parts were reasoning (no text/tool-call), keep the
+    // message with an empty content array to preserve message-count pairing.
+    return { ...msg, content: filtered };
+}
 function stripAssistantToolCallArgs(msg) {
     if (!Array.isArray(msg.content))
         return msg;
@@ -424,4 +455,97 @@ function stripAssistantToolCallArgs(msg) {
         return msg;
     return { ...msg, content: next };
 }
+/**
+ * Injects Anthropic prompt caching (cacheControl) into the last message's content
+ * block(s) if the model is Claude (starts with 'claude').
+ * Creates a copy of the messages array and the last message to avoid mutating in-place.
+ */
+export function applyAnthropicPromptCaching(messages, modelId) {
+    if (!modelId.startsWith("claude")) {
+        return messages;
+    }
+    if (messages.length === 0) {
+        return messages;
+    }
+    const newMessages = [...messages];
+    const lastIndex = newMessages.length - 1;
+    const originalLastMsg = newMessages[lastIndex];
+    if (!originalLastMsg)
+        return messages;
+    const lastMsg = { ...originalLastMsg };
+    if (typeof lastMsg.content === "string") {
+        lastMsg.content = [
+            {
+                type: "text",
+                text: lastMsg.content,
+                providerOptions: {
+                    anthropic: { cacheControl: { type: "ephemeral" } },
+                },
+            },
+        ];
+    }
+    else if (Array.isArray(lastMsg.content)) {
+        const content = [...lastMsg.content];
+        const lastBlockIndex = content.length - 1;
+        if (lastBlockIndex >= 0) {
+            const lastBlock = { ...content[lastBlockIndex] };
+            lastBlock.providerOptions = {
+                ...lastBlock.providerOptions,
+                anthropic: { cacheControl: { type: "ephemeral" } },
+            };
+            content[lastBlockIndex] = lastBlock;
+            lastMsg.content = content;
+        }
+    }
+    newMessages[lastIndex] = lastMsg;
+    return newMessages;
+}
+/**
+ * Safely slice message history to keep at most `maxMessages` messages.
+ * Preserves the system message(s) at the front and ensures that the slice
+ * starts with a "user" message and does not split assistant tool calls and
+ * corresponding tool results.
+ */
+export function sliceMessageHistory(messages, maxMessages = 30) {
+    if (messages.length <= maxMessages)
+        return messages;
+    // Find all user message indices (excluding system messages)
+    const userIndices = [];
+    for (let idx = 0; idx < messages.length; idx++) {
+        if (messages[idx]?.role === "user") {
+            userIndices.push(idx);
+        }
+    }
+    if (userIndices.length === 0) {
+        return messages;
+    }
+    // Group messages into turns.
+    // Each turn is a range [start, end] inclusive.
+    const turns = [];
+    for (let idx = 0; idx < userIndices.length; idx++) {
+        const start = userIndices[idx];
+        const end = idx + 1 < userIndices.length ? userIndices[idx + 1] - 1 : messages.length - 1;
+        turns.push({ start, end });
+    }
+    // Accumulate turns from the end, up to maxMessages
+    let keptMessagesCount = 0;
+    let keepFromIndex = -1;
+    for (let idx = turns.length - 1; idx >= 0; idx--) {
+        const turn = turns[idx];
+        const turnLength = turn.end - turn.start + 1;
+        if (keptMessagesCount === 0 || keptMessagesCount + turnLength <= maxMessages) {
+            keptMessagesCount += turnLength;
+            keepFromIndex = turn.start;
+        }
+        else {
+            break;
+        }
+    }
+    if (keepFromIndex === -1) {
+        return messages;
+    }
+    const kept = messages.slice(keepFromIndex);
+    const systemMessages = messages.filter((m) => m.role === "system");
+    return [...systemMessages, ...kept];
+}
 //# sourceMappingURL=subagent-compactor.js.map

package/dist/src/orchestrator/subagent-compactor.spec.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "vitest";
-import { compactSubAgentMessages, cumulativeMessageChars } from "./subagent-compactor.js";
+import { compactSubAgentMessages, cumulativeMessageChars, sliceMessageHistory } from "./subagent-compactor.js";
 function bigText(label, kb) {
     const block = `${label}:${"x".repeat(kb * 1000)}`;
     return block;
@@ -384,5 +384,253 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
         }
         expect(keptExplicit).toBe(true);
     });
+    it("elides low-value large read_file results while keeping high-value ones", () => {
+        // Turn 1: large low-value read_file output (15000 chars of 'x', no ts/src/PLAN/error keywords)
+        const lowValueOutput = "x".repeat(15000);
+        // Turn 2: large high-value read_file output containing 'error'
+        const highValueOutputWithError = "error: failed to load module\n" + "x".repeat(15000);
+        // Turn 3: small source file read (5000 chars of 'x' containing 'src/index.ts')
+        const highValueSourceOutput = "src/index.ts\n" + "x".repeat(5000);
+        const msgs = [
+            { role: "system", content: "You are the agent." },
+            { role: "user", content: "perform task" },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_low", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_low",
+                        toolName: "read_file",
+                        output: { type: "text", value: lowValueOutput },
+                    },
+                ],
+            },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_err", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_err",
+                        toolName: "read_file",
+                        output: { type: "text", value: highValueOutputWithError },
+                    },
+                ],
+            },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_src", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_src",
+                        toolName: "read_file",
+                        output: { type: "text", value: highValueSourceOutput },
+                    },
+                ],
+            },
+            // Add a couple of low-value turns to push past threshold and keepLast turns (keepLast=1)
+            ...toolTurn(9, 10),
+        ];
+        // Force low value on the final kept turn
+        msgs[msgs.length - 1].content[0].toolName = "other_tool";
+        const out = compactSubAgentMessages(msgs, { thresholdChars: 10_000, keepLastTurns: 1 });
+        // low-value large read_file MUST be elided
+        const lowValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_low");
+        expect((lowValMsg?.content)[0].output.value).toMatch(/elided by sub-agent compactor/);
+        // high-value large error read_file MUST NOT be elided
+        const errValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_err");
+        expect((errValMsg?.content)[0].output.value).toBe(highValueOutputWithError);
+        // high-value small source read_file MUST NOT be elided
+        const srcValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_src");
+        expect((srcValMsg?.content)[0].output.value).toBe(highValueSourceOutput);
+    });
+    it("T1.1 — strips reasoning parts from old assistant turns when stripOldReasoning is enabled", () => {
+        // Build history with reasoning parts in assistant messages
+        const msgs = [
+            { role: "system", content: "You are an agent." },
+            { role: "user", content: "fix the bug" },
+        ];
+        // Add 6 tool turns with reasoning in assistant messages
+        for (let i = 1; i <= 6; i++) {
+            msgs.push({
+                role: "assistant",
+                content: [
+                    { type: "reasoning", text: `Thinking about step ${i}... ${"x".repeat(3000)}` },
+                    { type: "text", text: `Step ${i} analysis` },
+                    { type: "tool-call", toolCallId: `call_${i}`, toolName: "bash", input: `echo ${i}` },
+                ],
+            });
+            msgs.push({
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: `call_${i}`,
+                        toolName: "bash",
+                        output: { type: "text", value: bigText(`R${i}`, 2) },
+                    },
+                ],
+            });
+        }
+        const out = compactSubAgentMessages(msgs, {
+            thresholdChars: 1000, // force compaction
+            keepLastTurns: 2,
+            stripOldReasoning: true,
+        });
+        // Old turns (1-4) should have reasoning stripped
+        const oldAssistants = out.filter((m, idx) => m.role === "assistant" && idx < out.length - 4);
+        for (const m of oldAssistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(false);
+        }
+        // Recent turns (last 2) should still have reasoning
+        const recentAssistants = out.filter((m, idx) => m.role === "assistant" && idx >= out.length - 4);
+        for (const m of recentAssistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(true);
+        }
+    });
+    it("T1.1 — does NOT strip reasoning when stripOldReasoning is false (default)", () => {
+        const msgs = [
+            { role: "system", content: "You are an agent." },
+            { role: "user", content: "fix the bug" },
+        ];
+        for (let i = 1; i <= 4; i++) {
+            msgs.push({
+                role: "assistant",
+                content: [
+                    { type: "reasoning", text: `Thinking... ${"x".repeat(3000)}` },
+                    { type: "tool-call", toolCallId: `call_${i}`, toolName: "bash", input: `echo ${i}` },
+                ],
+            });
+            msgs.push({
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: `call_${i}`,
+                        toolName: "bash",
+                        output: { type: "text", value: bigText(`R${i}`, 2) },
+                    },
+                ],
+            });
+        }
+        const out = compactSubAgentMessages(msgs, {
+            thresholdChars: 1000,
+            keepLastTurns: 1,
+            stripOldReasoning: false, // explicitly off
+        });
+        // All assistant messages should still have reasoning parts
+        const assistants = out.filter((m) => m.role === "assistant");
+        for (const m of assistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(true);
+        }
+    });
+    describe("sliceMessageHistory & Step 4 truncation", () => {
+        it("preserves system prompt and user start while slicing excess messages", () => {
+            const msgs = [
+                { role: "system", content: "system prompt" },
+                { role: "user", content: "first prompt" },
+                { role: "assistant", content: "first answer" },
+                { role: "user", content: "second prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-1", toolName: "bash", input: "ls" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-1", toolName: "bash", output: "file1" }],
+                },
+                { role: "assistant", content: "second answer" },
+                { role: "user", content: "third prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-2", toolName: "bash", input: "pwd" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-2", toolName: "bash", output: "/dir" }],
+                },
+                { role: "assistant", content: "third answer" },
+            ];
+            // Slicing to max 5 messages should start cleanly at a user message
+            const sliced = sliceMessageHistory(msgs, 5);
+            expect(sliced[0].role).toBe("system");
+            expect(sliced[1].role).toBe("user");
+            // Slicing walked backward to find a user message start that satisfies max 5.
+            // Last messages:
+            // assistant: third answer (idx 10) -> tool result 2 (idx 9) -> assistant call 2 (idx 8) -> user third prompt (idx 7).
+            // That is 4 messages. Since kept must start with user, it stops at idx 7.
+            // So kept messages are from idx 7 onwards: [user third prompt, assistant call 2, tool result 2, assistant third answer]
+            expect(sliced).toHaveLength(5); // 1 system + 4 kept messages
+            expect(sliced[1].content).toBe("third prompt");
+        });
+        it("does not orphaned tool-calls and tool-results", () => {
+            const msgs = [
+                { role: "system", content: "system prompt" },
+                { role: "user", content: "prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-99", toolName: "bash", input: "whoami" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-99", toolName: "bash", output: "root" }],
+                },
+                { role: "assistant", content: "hello" },
+            ];
+            // Even if maxMessages is 2, it shouldn't split assistant call-99 and tool result-99.
+            // Walking backward:
+            // - assistant: hello (count 1)
+            // - tool: result-99 (count 2, pendingToolCalls = {call-99})
+            // - assistant: call-99 (count 3, pendingToolCalls = {})
+            // - user: prompt (count 4, clean user start)
+            // So it must keep 4 messages + 1 system = 5 messages.
+            const sliced = sliceMessageHistory(msgs, 2);
+            expect(sliced).toHaveLength(5);
+            expect(sliced[1].role).toBe("user");
+        });
+        it("triggers slicing in compactSubAgentMessages when total exceeds 50K and messages count is > 30", () => {
+            const msgs = [
+                { role: "system", content: "system" },
+                { role: "user", content: "start" },
+            ];
+            // Push 40 messages to exceed 30 messages limit
+            for (let i = 0; i < 20; i++) {
+                msgs.push({ role: "assistant", content: `helper ${i}` });
+                msgs.push({ role: "user", content: `next question ${i}` });
+            }
+            // Generate a massive envelope size or message content to exceed 50K total chars
+            const out = compactSubAgentMessages(msgs, {
+                envelopeChars: 60_000, // force exceeds 50K
+                thresholdChars: 200_000, // high threshold to prevent compaction from running on top
+            });
+            // The message history should have been sliced (will be much fewer than 42 messages)
+            expect(out.length).toBeLessThan(msgs.length);
+            expect(out[0].role).toBe("system");
+            expect(out[1].role).toBe("user");
+        });
+    });
 });
 //# sourceMappingURL=subagent-compactor.spec.js.map

package/dist/src/orchestrator/text-tool-call-detector.d.ts

@@ -42,12 +42,16 @@ export declare function detectTextEmittedToolCall(text: string): TextToolCallDet
  * Parse the DeepSeek-native DSML tool-call markup into a structured list so the
  * re-steer can restate the model's EXACT intent (much more effective than a
  * generic "use the tool interface" nudge). Pure — no execution. Recognizes:
- *   <｜｜DSML｜｜invoke name="read_file">
- *     <｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.ts</｜｜DSML｜｜parameter>
- *   </｜｜DSML｜｜invoke>
+ *   Old format:  <│invoke name="read_file">
+ *                  <│parameter name="file_path" string="true">src/app/foo.ts</│parameter>
+ *                </│invoke>
+ *   New format:  <│ DSML │invoke name="read_file">
+ *                  <│ DSML │parameter name="file_path" string="true">src/app/foo.ts</│ DSML │parameter>
+ *                </│ DSML │invoke>
+ * Both U+2502 (box-drawing │) and U+FF5C (fullwidth ｜) bars are recognized.
  * Returns one entry per invoke block; args preserve insertion order. Tolerant of
- * missing close tags (cheap models truncate) — captures whatever parameters are
- * present. Returns [] when no parseable invoke block exists.
+ * missing close tags (cheap models truncate). Returns [] when no parseable invoke
+ * block exists.
  */
 export interface ParsedDsmlCall {
     name: string;

package/dist/src/orchestrator/text-tool-call-detector.js

@@ -90,16 +90,18 @@ const PARAM_ALTERNATION = PARAM_TAGS.join("|");
 // is the Anthropic XML style; `<tool_call>` / `<function_calls>` are Qwen/other.
 // These are matched directly (the wrapper itself is the signal).
 const GENERIC_WRAPPER_RE = /<\/?(?:tool_call|function_calls|tool_use)\b|<invoke\b[^>]*\bname\s*=|<function\b[^>]*\bname\s*=/i;
-// DeepSeek native tool-call markup leaking into text content. Signature is the
-// fullwidth-bar sentinel `｜｜DSML｜｜` (U+FF5C, NOT ASCII pipes) wrapping
-// invoke/tool_calls/parameter tokens, e.g. `<｜｜DSML｜｜invoke name="read_file">`.
+// DeepSeek native tool-call markup leaking into text content. Signature is a
+// vertical-bar sentinel — either U+FF5C fullwidth `｜` or U+2502 box-drawing `│`
+// — wrapping invoke/tool_calls/parameter tokens, e.g.:
+//   Old format:  <｜invoke name="read_file">   (U+FF5C, single bar)
+//   New format:  <│ DSML │invoke name="…">   (U+2502, with optional DSML label)
 // Live: storyflow_ui explore-A/B, deepseek T3 (session 799f0508e830) emitted a
-// full `<｜｜DSML｜｜invoke name="read_file">…` block as text and made no real tool
-// call → empty, silent turn. The generic `<invoke` matcher misses it because the
-// `<` is followed by the sentinel, not `invoke`. (BUG-A telemetry already flags
-// the `｜｜DSML｜｜` substring; this wires it into detect → re-steer/surface.)
-const DSML_WRAPPER_RE = /｜｜DSML｜｜\s*(?:invoke|tool_calls?|parameter)\b/i;
-const DSML_INVOKE_NAME_RE = /｜｜DSML｜｜\s*invoke\s+name\s*=\s*"([^"]+)"/i;
+// full DSML invoke block as text and made no real tool call → empty, silent turn.
+// The generic `<invoke` matcher misses it because `<` is followed by the sentinel.
+// Updated 2026-06-24 to cover both U+2502 and U+FF5C (tests use U+2502).
+const DSML_BAR = "[\\s]*[│｜|]+[│｜|\\s]*"; // matches U+2502 (box-drawing), U+FF5C (fullwidth), ASCII pipe |, and spaces
+const DSML_WRAPPER_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?(?:invoke|tool_calls?|parameter)\\b`, "i");
+const DSML_INVOKE_NAME_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s+name\\s*=\\s*"([^"]+)"`, "i");
 /** Build a per-tool detector: `<tool>` then (within a small gap) a `<param>` or `</tool>`. */
 function buildToolRegexes() {
     return TOOL_TAGS.map((tag) => 
@@ -136,10 +138,12 @@ function normalizeWrapperName(raw) {
     const m = raw.match(/tool_call|function_calls|tool_use|invoke|function/i);
     return m ? m[0].toLowerCase() : "tool_call";
 }
-const DSML_INVOKE_BLOCK_RE = /｜｜DSML｜｜\s*invoke\s+name\s*=\s*"([^"]+)"([\s\S]*?)(?=｜｜DSML｜｜\s*invoke\s|$)/gi;
-const DSML_PARAM_RE = /｜｜DSML｜｜\s*parameter\s+name\s*=\s*"([^"]+)"[^>]*>([\s\S]*?)<\/?｜｜DSML｜｜\s*parameter/gi;
+// Guard regex: at least one DSML-bar sentinel must exist before we bother scanning
+const DSML_GUARD_RE = /[│｜|]/;
+const DSML_INVOKE_BLOCK_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s+name\\s*=\\s*"([^"]+)"([\\s\\S]*?)(?=${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s|$)`, "gi");
+const DSML_PARAM_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?parameter\\s+name\\s*=\\s*"([^"]+)"[^>]*>([\\s\\S]*?)<\\/?${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?parameter`, "gi");
 export function parseDsmlToolCalls(text) {
-    if (!text || !text.includes("｜｜DSML｜｜"))
+    if (!text || !DSML_GUARD_RE.test(text))
         return [];
     const calls = [];
     DSML_INVOKE_BLOCK_RE.lastIndex = 0;