muonroi-cli 1.7.2 → 1.8.0

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

@@ -39,10 +39,32 @@ describe("detectTextEmittedToolCall", () => {
         expect(detectTextEmittedToolCall('<invoke name="read_file"><parameter name="path">a</parameter></invoke>').detected).toBe(true);
         expect(detectTextEmittedToolCall("<function_calls>...").detected).toBe(true);
     });
-    it("detects the DeepSeek-native DSML leak (｜｜DSML｜｜invoke …) and extracts the tool name", () => {
+    it("detects the DeepSeek-native DSML leak (│invoke …) and extracts the tool name", () => {
         // Live: storyflow_ui explore-A/B, deepseek T3 (session 799f0508e830) emitted
         // this as text and made no real tool call → empty, silent turn. The generic
         // <invoke matcher misses it because `<` is followed by the U+FF5C sentinel.
+        const text = `<│tool_calls>
+<│invoke name="read_file">
+<│parameter name="file_path" string="true">src/app/foo.html</│parameter>
+</│invoke>
+</│tool_calls>`;
+        const r = detectTextEmittedToolCall(text);
+        expect(r.detected).toBe(true);
+        expect(r.tool).toBe("read_file");
+    });
+    it("detects the newer DeepSeek DSML format with │ DSML │ sentinel (2026-06-23+ leak)", () => {
+        // Newer DSML format where the model inserts "DSML" text between bars:
+        //   <│ DSML │invoke name="read_file">...</│ DSML │invoke>
+        const text = `<│tool_calls>
+<│ DSML │invoke name="read_file">
+<│ DSML │parameter name="file_path" string="true">D:\\sources\\Core\\muonroi-cli\\biome.json</│ DSML │parameter>
+</│ DSML │invoke>
+</│tool_calls>`;
+        const r = detectTextEmittedToolCall(text);
+        expect(r.detected).toBe(true);
+        expect(r.tool).toBe("read_file");
+    });
+    it("detects the double-bar DeepSeek DSML format with ｜｜ sentinel", () => {
         const text = `<｜｜DSML｜｜tool_calls>
 <｜｜DSML｜｜invoke name="read_file">
 <｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.html</｜｜DSML｜｜parameter>
@@ -52,6 +74,24 @@ describe("detectTextEmittedToolCall", () => {
         expect(r.detected).toBe(true);
         expect(r.tool).toBe("read_file");
     });
+    it("parses double-bar DSML blocks with ｜｜ DSML ｜｜ sentinel format", () => {
+        const text = `<｜｜DSML｜｜invoke name="read_file">
+<｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.html</｜｜DSML｜｜parameter>
+</｜｜DSML｜｜invoke>`;
+        const calls = parseDsmlToolCalls(text);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].name).toBe("read_file");
+        expect(calls[0].args.file_path).toBe("src/app/foo.html");
+    });
+    it("parses DSML blocks with │ DSML │ sentinel format", () => {
+        const text = `<│ DSML │invoke name="read_file">
+<│ DSML │parameter name="file_path" string="true">src/app.ts</│ DSML │parameter>
+</│ DSML │invoke>`;
+        const calls = parseDsmlToolCalls(text);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].name).toBe("read_file");
+        expect(calls[0].args.file_path).toBe("src/app.ts");
+    });
     it("does NOT fire on a bare inline mention of a tool name (no invocation shape)", () => {
         // Precision: a prose mention must not be flagged — it would wrongly mark a
         // legitimate final answer as a broken tool call.
@@ -60,12 +100,12 @@ describe("detectTextEmittedToolCall", () => {
         expect(detectTextEmittedToolCall("I edited the file and ran the tests; everything passes.").detected).toBe(false);
     });
     it("parseDsmlToolCalls extracts name + args from the DSML block (for targeted re-steer)", () => {
-        const text = `<｜｜DSML｜｜tool_calls>
-<｜｜DSML｜｜invoke name="read_file">
-<｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.html</｜｜DSML｜｜parameter>
-<｜｜DSML｜｜parameter name="start_line" string="false">25</｜｜DSML｜｜parameter>
-</｜｜DSML｜｜invoke>
-</｜｜DSML｜｜tool_calls>`;
+        const text = `<│tool_calls>
+<│invoke name="read_file">
+<│parameter name="file_path" string="true">src/app/foo.html</│parameter>
+<│parameter name="start_line" string="false">25</│parameter>
+</│invoke>
+</│tool_calls>`;
         const calls = parseDsmlToolCalls(text);
         expect(calls).toHaveLength(1);
         expect(calls[0].name).toBe("read_file");
@@ -73,7 +113,7 @@ describe("detectTextEmittedToolCall", () => {
         expect(calls[0].args.start_line).toBe("25");
     });
     it("parseDsmlToolCalls handles multiple invoke blocks and returns [] for non-DSML text", () => {
-        const text = `<｜｜DSML｜｜invoke name="read_file"><｜｜DSML｜｜parameter name="file_path">a.ts</｜｜DSML｜｜parameter></｜｜DSML｜｜invoke><｜｜DSML｜｜invoke name="edit_file"><｜｜DSML｜｜parameter name="path">b.ts</｜｜DSML｜｜parameter></｜｜DSML｜｜invoke>`;
+        const text = `<│invoke name="read_file"><│parameter name="file_path">a.ts</│parameter></│invoke><│invoke name="edit_file"><│parameter name="path">b.ts</│parameter></│invoke>`;
         const calls = parseDsmlToolCalls(text);
         expect(calls.map((c) => c.name)).toEqual(["read_file", "edit_file"]);
         expect(parseDsmlToolCalls("just a normal answer")).toEqual([]);
@@ -85,5 +125,23 @@ describe("detectTextEmittedToolCall", () => {
         // Angular template with self-closing/nested tags must not match a tool tag.
         expect(detectTextEmittedToolCall('<span *ngIf="!story.cover" class="placeholder">{{ title }}</span>').detected).toBe(false);
     });
+    it("detects and parses Gemini-style ASCII DSML leak with spaces and standard pipes", () => {
+        const text = `Tôi cần xác nhận ecosystem có những extension gì trước khi sửa - không đoán, phải đọc source thật.
+
+< | | DSML | | tool_calls>
+< | | DSML | | invoke name="mcp_filesystem__search_files">
+< | | DSML | | parameter name="pattern" string="true">Serilog</ | | DSML | | parameter>
+< | | DSML | | parameter name="path" string="true">D:\\sources\\Core\\muonroi-building-block\\src</ | | DSML | | parameter>
+</ | | DSML | | invoke>
+</ | | DSML | | tool_calls>`;
+        const r = detectTextEmittedToolCall(text);
+        expect(r.detected).toBe(true);
+        expect(r.tool).toBe("mcp_filesystem__search_files");
+        const calls = parseDsmlToolCalls(text);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].name).toBe("mcp_filesystem__search_files");
+        expect(calls[0].args.pattern).toBe("Serilog");
+        expect(calls[0].args.path).toBe("D:\\sources\\Core\\muonroi-building-block\\src");
+    });
 });
 //# sourceMappingURL=text-tool-call-detector.test.js.map

package/dist/src/orchestrator/tool-args-repair.js

@@ -180,7 +180,7 @@ function insertMissingCloseQuote(s) {
         const prefix = out.slice(0, m.index);
         if (!isInsideOpenString(prefix))
             continue;
-        result += out.slice(lastIndex, m.index) + m[1] + '"' + m[2] + m[3];
+        result += `${out.slice(lastIndex, m.index) + m[1]}"${m[2]}${m[3]}`;
         lastIndex = m.index + m[0].length;
         matched = true;
     }

package/dist/src/orchestrator/tool-engine.d.ts

@@ -0,0 +1,151 @@
+import { type ModelMessage } from "ai";
+import { getModelInfo } from "../models/registry.js";
+import { type resolveModelRuntime } from "../providers/runtime.js";
+import type { ProviderId } from "../providers/types.js";
+import { type SessionStore } from "../storage/index.js";
+import type { SessionInfo, StreamChunk, SubagentStatus } from "../types/index.js";
+import { type PermissionMode } from "../utils/permission-mode.js";
+import type { AbortContext } from "./abort.js";
+import type { LegacyProvider, ProcessMessageObserver } from "./agent-options.js";
+import type { CouncilManager } from "./council-manager.js";
+import type { CrossTurnDedup } from "./cross-turn-dedup.js";
+import type { PendingCallsLog } from "./pending-calls.js";
+import type { ReadPathBudget } from "./read-path-budget.js";
+import type { SafetyOverrideAskInfo, SafetyOverrideVerdict } from "./safety-askcard.js";
+import { type ToolLoopCapAsk } from "./tool-loop-cap.js";
+import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
+/**
+ * Dependency surface the MessageProcessor needs to reach back into Agent
+ * state without holding a circular reference. Properties expose array
+ * references (mutating push() must affect the same array the Agent reads on
+ * subsequent turns). Method callbacks delegate to Agent private methods.
+ */
+export interface MessageProcessorDeps extends TurnRunnerDepsBase {
+    /** Live messageSeqs array (mutated by push; parallel to messages). */
+    readonly messageSeqs: Array<number | null>;
+    /** Session bookkeeping. */
+    readonly session: SessionInfo | null;
+    readonly sessionStore: SessionStore | null;
+    readonly modelId: string;
+    readonly providerId: ProviderId;
+    readonly batchApi: boolean;
+    readonly permissionMode: PermissionMode;
+    readonly externalAbortContext: AbortContext | null;
+    readonly pendingCalls: PendingCallsLog | null;
+    readonly councilManager: CouncilManager;
+    readonly crossTurnDedup: CrossTurnDedup | null;
+    readonly readBudget: ReadPathBudget | null;
+    readonly priorWarningIdsInSession: Set<string>;
+    readonly sessionEEGuidance: Map<string, {
+        toolName: string;
+        message: string;
+        why: string;
+        confidence: number;
+    }>;
+    readonly flowReady: Promise<void> | null;
+    getAbortController(): AbortController | null;
+    setAbortController(ctrl: AbortController | null): void;
+    getSessionStartHookFired(): boolean;
+    setSessionStartHookFired(v: boolean): void;
+    getPlanContext(): string | null;
+    setPlanContext(v: string | null): void;
+    getResumeDigest(): string | null;
+    setResumeDigest(v: string | null): void;
+    getActiveRunId(): string | null;
+    getPendingCwdNote(): string | null;
+    setPendingCwdNote(v: string | null): void;
+    setPilActive(v: boolean): void;
+    setPilEnrichmentDelta(n: number): void;
+    setCurrentCallId(id: string): void;
+    setLastPromptBreakdown(b: {
+        systemChars: number;
+        staticPrefixChars: number;
+        dynamicSuffixChars: number;
+        playwrightGuidanceChars: number;
+        messagesChars: number;
+        messagesCount: number;
+        toolsChars: number;
+        toolsCount: number;
+    } | null): void;
+    setTurnUserGoalExcerpt(v: string): void;
+    setTurnAssistantReasoning(v: string): void;
+    appendTurnAssistantReasoning(delta: string): void;
+    getTurnAssistantReasoning(): string;
+    setPriorWarningIdsInSession(s: Set<string>): void;
+    setMessages(messages: ModelMessage[]): void;
+    requireProvider(): LegacyProvider;
+    emitSubagentStatus(status: SubagentStatus | null): void;
+    fireHook(input: unknown, signal?: AbortSignal): Promise<{
+        blocked: boolean;
+        blockingErrors: Array<{
+            command: string;
+            stderr: string;
+        }>;
+        preventContinuation: boolean;
+        additionalContexts: string[];
+        results: import("../hooks/types.js").HookResult[];
+        eeMatches: import("../hooks/types.js").EEMatchEntry[];
+    }>;
+    consumeBackgroundNotifications(): Promise<string[]>;
+    initOAuthProvider(): Promise<void>;
+    buildRecentTurnsSummary(): string | null;
+    estimateProjectSize(): "small" | "medium" | "large" | null;
+    countFilesTouched(): number;
+    respondToToolApproval(approvalId: string, approved: boolean): void;
+    /**
+     * Tool-loop cap askcard hook (Claude-Code-style "continue?" prompt).
+     *
+     * Fires when the streamText loop reaches `maxToolRounds`. Returning
+     * `"continue"` raises the cap by `bumpBy` and lets the loop run; `"stop"`
+     * halts gracefully (no error). When undefined the loop hard-stops as before
+     * — preserves backward compat for batch / headless paths that have no UI to
+     * surface the askcard.
+     */
+    /**
+     * Live-queue steering drain (UI-provided). Returns and CLEARS any messages
+     * the user typed while this turn is streaming, so prepareStep can inject them
+     * mid-turn. Undefined / returns [] → no steering (legacy deferred queue).
+     */
+    drainSteerMessages?: () => {
+        text: string;
+    }[];
+    appendMidTurnMessages?: (msgs: ModelMessage[]) => void;
+    askToolLoopContinue?: ToolLoopCapAsk;
+    /** Safety override handler — invoked when a tool call is blocked by the safety filter. */
+    askSafetyOverride?: (info: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>;
+    runCouncilV2(userMessage: string, opts: {
+        skipClarification: boolean;
+        observer?: ProcessMessageObserver;
+        userModelMessage: ModelMessage;
+    }): AsyncGenerator<StreamChunk, void, unknown>;
+    processMessage(userMessage: string, observer?: ProcessMessageObserver, images?: Array<{
+        path: string;
+        mediaType: string;
+        base64: string;
+    }>): AsyncGenerator<StreamChunk, void, unknown>;
+    processMessageBatchTurn(args: {
+        userModelMessage: ModelMessage;
+        userEnrichedMessage: ModelMessage;
+        observer?: ProcessMessageObserver;
+        provider: LegacyProvider;
+        subagents: unknown[];
+        system: string;
+        runtime: ReturnType<typeof resolveModelRuntime>;
+        modelInfo: ReturnType<typeof getModelInfo>;
+        signal: AbortSignal;
+    }): AsyncGenerator<StreamChunk, void, unknown>;
+}
+/**
+ * Rewrites tool-result parts in the AI SDK's final response history if the
+ * user manually approved a safety-blocked command. This ensures the model sees
+ * its own retry context accurately (as a success) rather than a repeated block
+ * message, avoiding infinite retry loops or hallucinated failures.
+ */
+export declare function rewriteSafetyApprovedToolResults<T extends {
+    role: string;
+    content?: any;
+}>(messages: T[]): T[];
+export interface ToolEngineArgs {
+    [key: string]: any;
+}
+export declare function executeToolEngine(args: ToolEngineArgs): AsyncGenerator<StreamChunk, void, unknown>;