muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/__tests__/cross-turn-dedup.test.js

@@ -1,175 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { CrossTurnDedup, isCrossTurnDedupEnabled, wrapToolSetWithDedup } from "../cross-turn-dedup.js";
-describe("CrossTurnDedup", () => {
-    describe("maybeDedup", () => {
-        it("returns null for the first occurrence and a stub for the second", () => {
-            const dedup = new CrossTurnDedup();
-            dedup.beginTurn();
-            const payload = "x".repeat(2_000);
-            // First call: passes through.
-            const first = dedup.maybeDedup("read_file", payload);
-            expect(first).toBeNull();
-            // Second user turn — bump counter.
-            dedup.beginTurn();
-            const second = dedup.maybeDedup("read_file", payload);
-            expect(second).not.toBeNull();
-            expect(second).toContain("[dup of");
-            expect(second).toContain("read_file");
-            expect(second).toContain("turn 1");
-        });
-        it("distinct large tool outputs do not collide on sha256-16", () => {
-            // Two large strings differing only in last char must produce different
-            // stubs (i.e. no false-positive dedup hit). Regression coverage for the
-            // sha1-12 → sha256-16 upgrade — at 48 bits the birthday bound made this
-            // theoretically plausible; at 64 bits it's astronomically unlikely.
-            const dedup = new CrossTurnDedup({ minChars: 100 });
-            dedup.beginTurn();
-            const a = "A".repeat(2_000);
-            const b = `${"A".repeat(1_999)}B`;
-            expect(dedup.maybeDedup("read_file", a)).toBeNull();
-            // Distinct content must NOT hit the cache.
-            expect(dedup.maybeDedup("read_file", b)).toBeNull();
-            // Two distinct payloads → two distinct cache entries (verified via
-            // cache size since the marker no longer embeds the hash post-G3).
-            expect(dedup.getStats().size).toBe(2);
-            // Re-emitting either payload now triggers a dedup hit.
-            const stubA = dedup.maybeDedup("read_file", a);
-            const stubB = dedup.maybeDedup("read_file", b);
-            expect(stubA).not.toBeNull();
-            expect(stubB).not.toBeNull();
-            expect(dedup.getStats().hits).toBe(2);
-        });
-        it("does not dedup different outputs", () => {
-            const dedup = new CrossTurnDedup();
-            dedup.beginTurn();
-            const a = "a".repeat(1_000);
-            const b = "b".repeat(1_000);
-            expect(dedup.maybeDedup("read_file", a)).toBeNull();
-            expect(dedup.maybeDedup("read_file", b)).toBeNull();
-            // Re-run yields a hit for a, miss for c.
-            expect(dedup.maybeDedup("read_file", a)).not.toBeNull();
-            const c = "c".repeat(1_000);
-            expect(dedup.maybeDedup("read_file", c)).toBeNull();
-        });
-        it("skips outputs below the min-chars threshold", () => {
-            const dedup = new CrossTurnDedup({ minChars: 500 });
-            dedup.beginTurn();
-            const small = "y".repeat(100);
-            expect(dedup.maybeDedup("bash", small)).toBeNull();
-            expect(dedup.maybeDedup("bash", small)).toBeNull();
-            expect(dedup.getStats().inserts).toBe(0);
-            expect(dedup.getStats().hits).toBe(0);
-        });
-        it("evicts oldest entry after exceeding maxEntries", () => {
-            const dedup = new CrossTurnDedup({ maxEntries: 3, minChars: 10 });
-            dedup.beginTurn();
-            // Insert 4 distinct payloads — first should be evicted.
-            const payloads = ["A", "B", "C", "D"].map((c) => c.repeat(50));
-            for (const p of payloads)
-                expect(dedup.maybeDedup("read_file", p)).toBeNull();
-            expect(dedup.getStats().size).toBe(3);
-            // First payload should no longer be cached (evicted) — re-running it
-            // returns null, not a stub.
-            expect(dedup.maybeDedup("read_file", payloads[0])).toBeNull();
-            // Latest payload should still be cached — re-running returns a stub.
-            expect(dedup.maybeDedup("read_file", payloads[3])).not.toBeNull();
-        });
-        it("no-ops when constructed with enabled=false", () => {
-            const dedup = new CrossTurnDedup({ enabled: false });
-            dedup.beginTurn();
-            const payload = "z".repeat(2_000);
-            expect(dedup.maybeDedup("read_file", payload)).toBeNull();
-            expect(dedup.maybeDedup("read_file", payload)).toBeNull();
-            expect(dedup.getStats().inserts).toBe(0);
-            expect(dedup.getStats().hits).toBe(0);
-        });
-    });
-    describe("isCrossTurnDedupEnabled", () => {
-        const original = process.env.MUONROI_CROSS_TURN_DEDUP;
-        afterEach(() => {
-            if (original === undefined)
-                delete process.env.MUONROI_CROSS_TURN_DEDUP;
-            else
-                process.env.MUONROI_CROSS_TURN_DEDUP = original;
-        });
-        it("defaults to enabled", () => {
-            delete process.env.MUONROI_CROSS_TURN_DEDUP;
-            expect(isCrossTurnDedupEnabled()).toBe(true);
-        });
-        it("respects MUONROI_CROSS_TURN_DEDUP=0", () => {
-            process.env.MUONROI_CROSS_TURN_DEDUP = "0";
-            expect(isCrossTurnDedupEnabled()).toBe(false);
-        });
-        it("respects MUONROI_CROSS_TURN_DEDUP=false", () => {
-            process.env.MUONROI_CROSS_TURN_DEDUP = "false";
-            expect(isCrossTurnDedupEnabled()).toBe(false);
-        });
-    });
-    describe("wrapToolSetWithDedup", () => {
-        function makeTool(returnValue) {
-            return {
-                description: "test tool",
-                inputSchema: { type: "object", properties: {} },
-                execute: async () => returnValue,
-                // biome-ignore lint: minimal AI ToolSet shape used by the wrapper only
-            };
-        }
-        it("returns the same tool set when dedup is null", () => {
-            const tools = { read_file: makeTool("payload") };
-            expect(wrapToolSetWithDedup(tools, null)).toBe(tools);
-        });
-        it("dedups string outputs across calls", async () => {
-            const dedup = new CrossTurnDedup({ minChars: 10 });
-            dedup.beginTurn();
-            const payload = "p".repeat(1_000);
-            const tools = { read_file: makeTool(payload) };
-            const wrapped = wrapToolSetWithDedup(tools, dedup);
-            const exec = wrapped.read_file.execute;
-            const first = await exec({});
-            expect(first).toBe(payload);
-            const second = (await exec({}));
-            expect(second).not.toBe(payload);
-            expect(second).toContain("[dup of");
-        });
-        it("dedups the .output field on object-shaped results", async () => {
-            const dedup = new CrossTurnDedup({ minChars: 10 });
-            dedup.beginTurn();
-            const payload = "q".repeat(1_000);
-            const tools = { read_file: makeTool({ success: true, output: payload }) };
-            const wrapped = wrapToolSetWithDedup(tools, dedup);
-            const exec = wrapped.read_file.execute;
-            const first = (await exec({}));
-            expect(first.output).toBe(payload);
-            const second = (await exec({}));
-            expect(second.output).toContain("[dup of");
-        });
-        it("dedups MCP content-array text parts across calls", async () => {
-            // MCP results are { type: "content", value: [{type:"text", text}] } — a
-            // shape the dedup previously ignored, so re-fetching the same MCP payload
-            // (e.g. the same docs page) re-billed full content every turn.
-            const dedup = new CrossTurnDedup({ minChars: 10 });
-            dedup.beginTurn();
-            const payload = "r".repeat(1_000);
-            const tools = {
-                mcp_docs__fetch: makeTool({ type: "content", value: [{ type: "text", text: payload }] }),
-            };
-            const wrapped = wrapToolSetWithDedup(tools, dedup);
-            const exec = wrapped.mcp_docs__fetch.execute;
-            const first = (await exec({}));
-            expect(first.value[0].text).toBe(payload);
-            const second = (await exec({}));
-            expect(second.value[0].text).toContain("[dup of");
-        });
-        it("leaves non-text MCP content parts (images) untouched", async () => {
-            const dedup = new CrossTurnDedup({ minChars: 10 });
-            dedup.beginTurn();
-            const image = { type: "image", data: "BASE64", mediaType: "image/png" };
-            const tools = { mcp_x__shot: makeTool({ type: "content", value: [image] }) };
-            const wrapped = wrapToolSetWithDedup(tools, dedup);
-            const exec = wrapped.mcp_x__shot.execute;
-            const out = (await exec({}));
-            expect(out.value[0]).toEqual(image);
-        });
-    });
-});
-//# sourceMappingURL=cross-turn-dedup.test.js.map

package/dist/src/orchestrator/__tests__/current-call-id.test.d.ts

@@ -1,16 +0,0 @@
-/**
- * current-call-id.test.ts — Phase 6.9a unit tests.
- *
- * Verifies the _currentCallId state machine semantics for llm-token / llm-done
- * correlationId pairing. Instead of instantiating the full Agent class (which
- * has >20 private deps + AI SDK), this test validates the INVARIANTS that must
- * hold true in the emitted events:
- *
- * 1. correlationId on llm-done is a valid non-empty UUID.
- * 2. Two consecutive llm-done emits have DIFFERENT correlationIds.
- * 3. llm-token events emitted between start and done share the same correlationId.
- *
- * These invariants are tested by simulating the emit sequence directly —
- * the same logic the orchestrator executes at runtime.
- */
-export {};

package/dist/src/orchestrator/__tests__/current-call-id.test.js

@@ -1,138 +0,0 @@
-/**
- * current-call-id.test.ts — Phase 6.9a unit tests.
- *
- * Verifies the _currentCallId state machine semantics for llm-token / llm-done
- * correlationId pairing. Instead of instantiating the full Agent class (which
- * has >20 private deps + AI SDK), this test validates the INVARIANTS that must
- * hold true in the emitted events:
- *
- * 1. correlationId on llm-done is a valid non-empty UUID.
- * 2. Two consecutive llm-done emits have DIFFERENT correlationIds.
- * 3. llm-token events emitted between start and done share the same correlationId.
- *
- * These invariants are tested by simulating the emit sequence directly —
- * the same logic the orchestrator executes at runtime.
- */
-import { describe, expect, it } from "vitest";
-// ---------------------------------------------------------------------------
-// Simulate the _currentCallId state machine in isolation.
-// This mirrors exactly what the orchestrator does:
-//   1. _currentCallId = crypto.randomUUID()   (before streamText)
-//   2. emitEvent({ kind: "llm-token", correlationId: _currentCallId, ... })  (per token)
-//   3. emitEvent({ kind: "llm-done",  correlationId: _currentCallId, ... })  (onFinish)
-//   4. _currentCallId = ""                    (clear after done)
-// ---------------------------------------------------------------------------
-function UUID_PATTERN() {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-}
-/** Minimal simulation of one streamText call lifecycle. */
-function simulateStreamTextCall(emitEvent, tokenCount = 3) {
-    // Step 1: assign fresh correlation ID (mirrors orchestrator line 1332 / 3873)
-    let currentCallId = crypto.randomUUID();
-    const callId = currentCallId; // capture for verification
-    // Step 2: emit llm-token per delta (mirrors orchestrator lines 1384–1408)
-    for (let i = 0; i < tokenCount; i++) {
-        try {
-            emitEvent({ t: "event", kind: "llm-token", correlationId: currentCallId, delta: `tok${i}`, tokenIndex: i });
-        }
-        catch {
-            /* best-effort */
-        }
-    }
-    // Step 3: onFinish — emit llm-done then clear (mirrors orchestrator lines 1360–1374 / 3920–3930)
-    try {
-        emitEvent({
-            t: "event",
-            kind: "llm-done",
-            correlationId: currentCallId,
-            totalChars: tokenCount * 4,
-            finishReason: "stop",
-        });
-    }
-    catch {
-        /* best-effort */
-    }
-    currentCallId = ""; // cleared after done
-    // After clear, callId is "" — use the captured pre-clear value for return
-    void currentCallId; // verify it was cleared
-    return callId;
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("_currentCallId state machine — invariant 1: correlationId is a valid UUID", () => {
-    it("llm-done correlationId is a valid UUID v4", () => {
-        const emitted = [];
-        simulateStreamTextCall((e) => emitted.push(e));
-        const done = emitted.find((e) => e.kind === "llm-done");
-        expect(done).toBeDefined();
-        expect(typeof done.correlationId).toBe("string");
-        expect(done.correlationId).toMatch(UUID_PATTERN());
-        expect(done.correlationId).not.toBe("");
-    });
-    it("llm-token correlationId is a valid UUID v4", () => {
-        const emitted = [];
-        simulateStreamTextCall((e) => emitted.push(e), 2);
-        const tokens = emitted.filter((e) => e.kind === "llm-token");
-        expect(tokens.length).toBe(2);
-        for (const t of tokens) {
-            expect(t.correlationId).toMatch(UUID_PATTERN());
-        }
-    });
-});
-describe("_currentCallId state machine — invariant 2: different correlationId per call", () => {
-    it("two consecutive calls produce different correlationIds", () => {
-        const emitted = [];
-        const id1 = simulateStreamTextCall((e) => emitted.push(e));
-        const id2 = simulateStreamTextCall((e) => emitted.push(e));
-        expect(id1).not.toBe(id2);
-        expect(id1).toMatch(UUID_PATTERN());
-        expect(id2).toMatch(UUID_PATTERN());
-    });
-    it("correlationId is unique across 10 sequential calls", () => {
-        const ids = new Set();
-        for (let i = 0; i < 10; i++) {
-            const id = simulateStreamTextCall(() => { });
-            ids.add(id);
-        }
-        expect(ids.size).toBe(10); // all unique
-    });
-});
-describe("_currentCallId state machine — invariant 3: tokens share correlationId with their done", () => {
-    it("all llm-token events share the same correlationId as llm-done", () => {
-        const emitted = [];
-        simulateStreamTextCall((e) => emitted.push(e), 5);
-        const done = emitted.find((e) => e.kind === "llm-done");
-        const tokens = emitted.filter((e) => e.kind === "llm-token");
-        expect(done).toBeDefined();
-        expect(tokens.length).toBe(5);
-        for (const t of tokens) {
-            expect(t.correlationId).toBe(done.correlationId);
-        }
-    });
-    it("tokens from call1 do NOT share correlationId with call2", () => {
-        const call1 = [];
-        const call2 = [];
-        simulateStreamTextCall((e) => call1.push(e), 3);
-        simulateStreamTextCall((e) => call2.push(e), 3);
-        const call1Id = call1.find((e) => e.kind === "llm-done").correlationId;
-        const call2Id = call2.find((e) => e.kind === "llm-done").correlationId;
-        expect(call1Id).not.toBe(call2Id);
-        for (const t of call1.filter((e) => e.kind === "llm-token")) {
-            expect(t.correlationId).toBe(call1Id);
-        }
-        for (const t of call2.filter((e) => e.kind === "llm-token")) {
-            expect(t.correlationId).toBe(call2Id);
-        }
-    });
-});
-describe("_currentCallId state machine — cleared to empty after done", () => {
-    it("callId captured before done is non-empty; cleared value after done would be empty", () => {
-        // The orchestrator sets currentCallId = "" after emitting llm-done.
-        // We verify the captured callId (before clear) is non-empty and UUID-shaped.
-        const callId = simulateStreamTextCall(() => { });
-        expect(callId).toMatch(UUID_PATTERN()); // was non-empty UUID before clear
-        expect(callId).not.toBe(""); // was not already empty
-    });
-});
-//# sourceMappingURL=current-call-id.test.js.map

package/dist/src/orchestrator/__tests__/delegations.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/__tests__/delegations.test.js

@@ -1,96 +0,0 @@
-import { createHash } from "crypto";
-import { promises as fs } from "fs";
-import os from "os";
-import path from "path";
-import { describe, expect, it } from "vitest";
-import { DelegationManager } from "../delegations.js";
-function getProjectId(cwd) {
-    const base = path
-        .basename(cwd)
-        .replace(/[^a-zA-Z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "") || "project";
-    const hash = createHash("sha1").update(cwd).digest("hex").slice(0, 10);
-    return `${base}-${hash}`;
-}
-async function getDelegationsDir(cwd) {
-    const projectId = getProjectId(cwd);
-    return path.join(os.homedir(), ".muonroi-cli", "delegations", projectId);
-}
-describe("DelegationManager.kill", () => {
-    it("terminates a running delegation and updates its status to error", async () => {
-        const tempCwd = path.join(os.tmpdir(), "muonroi-test-" + Math.random().toString(36).slice(2));
-        const manager = new DelegationManager(() => tempCwd);
-        const dir = await getDelegationsDir(tempCwd);
-        await fs.mkdir(dir, { recursive: true });
-        const id = "test-amber-panda";
-        const jobPath = path.join(dir, `${id}.json`);
-        const outputPath = path.join(dir, `${id}.md`);
-        // Create a mock running delegation
-        const record = {
-            id,
-            agent: "explore",
-            description: "test delegation",
-            prompt: "noop",
-            cwd: tempCwd,
-            model: "grok-4",
-            sandboxMode: "off",
-            maxToolRounds: 10,
-            maxTokens: 4000,
-            status: "running",
-            startedAt: new Date().toISOString(),
-            outputPath,
-            pid: 99999, // dummy PID
-        };
-        await fs.writeFile(jobPath, JSON.stringify(record, null, 2), "utf8");
-        // Call cancel
-        const result = await manager.kill(id);
-        expect(result.success).toBe(true);
-        expect(result.output).toContain(`Delegation "${id}" (PID: 99999) has been terminated.`);
-        // Verify the record was updated
-        const updatedRaw = await fs.readFile(jobPath, "utf8");
-        const updated = JSON.parse(updatedRaw);
-        expect(updated.status).toBe("error");
-        expect(updated.error).toBe("Cancelled by user.");
-        // Cleanup
-        await fs.rm(jobPath, { force: true });
-        await fs.rm(outputPath, { force: true });
-        await fs.rm(dir, { recursive: true, force: true });
-    });
-    it("returns failure if the delegation ID is not found", async () => {
-        const tempCwd = path.join(os.tmpdir(), "muonroi-test-" + Math.random().toString(36).slice(2));
-        const manager = new DelegationManager(() => tempCwd);
-        const result = await manager.kill("non-existent-id");
-        expect(result.success).toBe(false);
-        expect(result.output).toContain('Delegation "non-existent-id" not found.');
-    });
-    it("returns failure if the delegation is already finished", async () => {
-        const tempCwd = path.join(os.tmpdir(), "muonroi-test-" + Math.random().toString(36).slice(2));
-        const manager = new DelegationManager(() => tempCwd);
-        const dir = await getDelegationsDir(tempCwd);
-        await fs.mkdir(dir, { recursive: true });
-        const id = "test-steady-owl";
-        const jobPath = path.join(dir, `${id}.json`);
-        const record = {
-            id,
-            agent: "explore",
-            description: "test delegation",
-            prompt: "noop",
-            cwd: tempCwd,
-            model: "grok-4",
-            sandboxMode: "off",
-            maxToolRounds: 10,
-            maxTokens: 4000,
-            status: "complete",
-            startedAt: new Date().toISOString(),
-            outputPath: path.join(dir, `${id}.md`),
-        };
-        await fs.writeFile(jobPath, JSON.stringify(record, null, 2), "utf8");
-        const result = await manager.kill(id);
-        expect(result.success).toBe(false);
-        expect(result.output).toContain(`Delegation "${id}" is not running (status: complete).`);
-        // Cleanup
-        await fs.rm(jobPath, { force: true });
-        await fs.rm(dir, { recursive: true, force: true });
-    });
-});
-//# sourceMappingURL=delegations.test.js.map

package/dist/src/orchestrator/__tests__/error-forensics.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/__tests__/error-forensics.test.js

@@ -1,93 +0,0 @@
-/**
- * Forensics envelope for opaque provider 4xx errors.
- *
- * Background: 16 occurrences in interaction_logs of
- *   "The parameter is invalid. Please check again."
- * (siliconflow / DeepSeek-V4-Flash, 2026-05-13 → 2026-05-14) were logged with
- * ONLY the friendly message. With nothing else captured — no status code,
- * no response body, no request param names — the cause is unrecoverable
- * without a repro. summarizeApiErrorForLog closes that gap.
- *
- * Test goals:
- *   1. Wire-shape we WANT to persist (statusCode, urlHost, body trunc, param keys).
- *   2. NEVER persist request param VALUES (might contain secrets / PII).
- *   3. Cap response body so a 1MB error response can't bloat interaction_logs.
- *   4. Identity null on non-APICallError so the helper is safe to call
- *      unconditionally from the log site.
- */
-import { APICallError } from "@ai-sdk/provider";
-import { describe, expect, it } from "vitest";
-import { summarizeApiErrorForLog } from "../error-utils.js";
-describe("summarizeApiErrorForLog", () => {
-    it("captures the wire envelope for an APICallError without leaking param values", () => {
-        const err = new APICallError({
-            message: "The parameter is invalid. Please check again.",
-            url: "https://api.siliconflow.com/v1/chat/completions",
-            requestBodyValues: {
-                model: "deepseek-ai/DeepSeek-V4-Flash",
-                messages: [{ role: "user", content: "secret prompt" }],
-                temperature: 0.7,
-                tools: [{ type: "function", function: { name: "read_file" } }],
-            },
-            statusCode: 400,
-            responseBody: '{"error":{"message":"The parameter is invalid. Please check again.","code":20015}}',
-            isRetryable: false,
-        });
-        const out = summarizeApiErrorForLog(err);
-        expect(out).not.toBeNull();
-        expect(out.statusCode).toBe(400);
-        expect(out.urlHost).toBe("api.siliconflow.com");
-        expect(out.responseBodyTrunc).toBe('{"error":{"message":"The parameter is invalid. Please check again.","code":20015}}');
-        // Keys ONLY — values must never reach the log.
-        expect(out.requestParamKeys).toEqual(["messages", "model", "temperature", "tools"]);
-        // Confirm no value leak by stringifying the whole envelope.
-        const serialized = JSON.stringify(out);
-        expect(serialized).not.toContain("secret prompt");
-        expect(serialized).not.toContain("DeepSeek-V4-Flash");
-        expect(serialized).not.toContain("read_file");
-        expect(out.isRetryable).toBe(false);
-    });
-    it("truncates response body over 1000 chars to keep interaction_logs bounded", () => {
-        const giantBody = `${"x".repeat(2_000)}`;
-        const err = new APICallError({
-            message: "rate limit",
-            url: "https://api.example.com/x",
-            requestBodyValues: {},
-            statusCode: 429,
-            responseBody: giantBody,
-        });
-        const out = summarizeApiErrorForLog(err);
-        expect(out).not.toBeNull();
-        expect(out.responseBodyTrunc.length).toBeLessThanOrEqual(1020);
-        expect(out.responseBodyTrunc.endsWith("…[truncated]")).toBe(true);
-    });
-    it("returns null for non-APICallError so the helper is safe to call unconditionally", () => {
-        expect(summarizeApiErrorForLog(new Error("plain"))).toBeNull();
-        expect(summarizeApiErrorForLog("string error")).toBeNull();
-        expect(summarizeApiErrorForLog(undefined)).toBeNull();
-    });
-    it("handles malformed URL without throwing — urlHost becomes undefined", () => {
-        const err = new APICallError({
-            message: "bad",
-            url: "not a url",
-            requestBodyValues: {},
-            statusCode: 500,
-        });
-        const out = summarizeApiErrorForLog(err);
-        expect(out).not.toBeNull();
-        expect(out.urlHost).toBeUndefined();
-        expect(out.statusCode).toBe(500);
-    });
-    it("handles non-object requestBodyValues without crashing — requestParamKeys becomes undefined", () => {
-        const err = new APICallError({
-            message: "x",
-            url: "https://api.example.com/x",
-            requestBodyValues: "raw json string", // pathological case
-            statusCode: 400,
-        });
-        const out = summarizeApiErrorForLog(err);
-        expect(out).not.toBeNull();
-        expect(out.requestParamKeys).toBeUndefined();
-    });
-});
-//# sourceMappingURL=error-forensics.test.js.map

package/dist/src/orchestrator/__tests__/flow-resume.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for flow-resume.ts — loadFlowResumeDigest reads .muonroi-flow/
- * state before chat transcript on cold start.
- */
-export {};

package/dist/src/orchestrator/__tests__/flow-resume.test.js

@@ -1,61 +0,0 @@
-/**
- * Tests for flow-resume.ts — loadFlowResumeDigest reads .muonroi-flow/
- * state before chat transcript on cold start.
- */
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { parseSections } from "../../flow/parser.js";
-import { createRun, setActiveRunId, updateRunFile } from "../../flow/run-manager.js";
-import { ensureFlowDir } from "../../flow/scaffold.js";
-import { loadFlowResumeDigest } from "../flow-resume.js";
-let tempDirs = [];
-async function makeTempDir(prefix) {
-    const dir = await mkdtemp(path.join(tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(async () => {
-    for (const d of tempDirs) {
-        await rm(d, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-    }
-    tempDirs = [];
-});
-describe("loadFlowResumeDigest", () => {
-    it("returns Resume Digest content from active run state.md", async () => {
-        const cwd = await makeTempDir("resume-digest-");
-        const flowDir = await ensureFlowDir(cwd);
-        const run = await createRun(flowDir);
-        await setActiveRunId(flowDir, run.id);
-        // Write Resume Digest content
-        const stateMap = parseSections("");
-        stateMap.sections.set("Resume Digest", "Working on feature X. File: src/foo.ts modified.");
-        stateMap.sections.set("Experience Snapshot", "");
-        await updateRunFile(flowDir, run.id, "state.md", stateMap);
-        const digest = await loadFlowResumeDigest(cwd);
-        expect(digest).toBe("Working on feature X. File: src/foo.ts modified.");
-    });
-    it("returns null when .muonroi-flow/ does not exist", async () => {
-        const cwd = await makeTempDir("no-flow-");
-        const digest = await loadFlowResumeDigest(cwd);
-        expect(digest).toBeNull();
-    });
-    it("returns null when no active run is set", async () => {
-        const cwd = await makeTempDir("no-active-");
-        await ensureFlowDir(cwd);
-        // Don't set active run
-        const digest = await loadFlowResumeDigest(cwd);
-        expect(digest).toBeNull();
-    });
-    it("returns null when active run has empty Resume Digest", async () => {
-        const cwd = await makeTempDir("empty-digest-");
-        const flowDir = await ensureFlowDir(cwd);
-        const run = await createRun(flowDir);
-        await setActiveRunId(flowDir, run.id);
-        // createRun initializes state.md with empty Resume Digest — don't write content
-        const digest = await loadFlowResumeDigest(cwd);
-        expect(digest).toBeNull();
-    });
-});
-//# sourceMappingURL=flow-resume.test.js.map

package/dist/src/orchestrator/__tests__/humanize-api-error.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/__tests__/humanize-api-error.test.js

@@ -1,68 +0,0 @@
-/**
- * P0 #2 — surface the ROUTED model/provider on account/auth/rate errors so a
- * cryptic provider 402 ("Insufficient Balance") tells the user WHICH model it
- * actually ran (e.g. a project-pinned deepseek model overriding their default)
- * and how to fix it, instead of leaving them guessing.
- */
-import { APICallError } from "@ai-sdk/provider";
-import { describe, expect, it } from "vitest";
-import { humanizeApiError } from "../error-utils.js";
-function apiErr(statusCode, responseBody) {
-    return new APICallError({
-        message: "provider error",
-        url: "https://api.deepseek.com/chat/completions",
-        requestBodyValues: { model: "deepseek-v4-flash" },
-        statusCode,
-        responseBody,
-        isRetryable: false,
-    });
-}
-describe("humanizeApiError — routing context (P0 #2)", () => {
-    it("adds routed model + provider + a balance hint on 402", () => {
-        const err = apiErr(402, '{"error":{"message":"Insufficient Balance"}}');
-        const msg = humanizeApiError(err, { modelId: "deepseek-v4-flash", providerId: "deepseek" });
-        expect(msg).toContain("Insufficient Balance");
-        expect(msg).toContain("deepseek-v4-flash");
-        expect(msg).toContain("deepseek");
-        expect(msg).toMatch(/-m /); // suggests switching model
-        expect(msg).toMatch(/balance|credit/i);
-    });
-    it("points to keys login on 401/403", () => {
-        const msg = humanizeApiError(apiErr(401, '{"error":{"message":"bad key"}}'), {
-            modelId: "gpt-5.4-mini",
-            providerId: "openai",
-        });
-        expect(msg).toContain("gpt-5.4-mini");
-        expect(msg).toMatch(/keys login/);
-    });
-    it("mentions rate limit + switch on 429", () => {
-        const msg = humanizeApiError(apiErr(429, '{"error":{"message":"slow down"}}'), {
-            modelId: "deepseek-v4-flash",
-            providerId: "deepseek",
-        });
-        expect(msg).toMatch(/rate.?limit/i);
-        expect(msg).toMatch(/-m /);
-    });
-    it("does NOT add a routing suffix on server-side 500 (not the user's routing)", () => {
-        const msg = humanizeApiError(apiErr(500, '{"error":{"message":"boom"}}'), {
-            modelId: "deepseek-v4-flash",
-            providerId: "deepseek",
-        });
-        expect(msg).not.toContain("routed to");
-        expect(msg).not.toContain("deepseek-v4-flash");
-    });
-    it("is unchanged when no context is supplied (backward compatible)", () => {
-        const err = apiErr(402, '{"error":{"message":"Insufficient Balance"}}');
-        const withoutCtx = humanizeApiError(err);
-        expect(withoutCtx).toBe("Insufficient Balance");
-        expect(withoutCtx).not.toContain("routed to");
-    });
-    it("flags balance even when status is unparsed but the body says so", () => {
-        // Some gateways surface the balance error without a clean statusCode.
-        const err = new Error("Insufficient Balance");
-        const msg = humanizeApiError(err, { modelId: "deepseek-v4-flash", providerId: "deepseek" });
-        expect(msg).toContain("deepseek-v4-flash");
-        expect(msg).toMatch(/balance|credit/i);
-    });
-});
-//# sourceMappingURL=humanize-api-error.test.js.map