muonroi-cli 1.8.0 → 1.8.3

package/dist/src/providers/__tests__/siliconflow-sse-repair.test.js

@@ -1,267 +0,0 @@
-/**
- * Regression for SiliconFlow Qwen3-30B tool_call SSE malformation
- * observed in session 44db9105b119 (2026-05-26).
- *
- * Each block pins one behavior — repair, pass-through, or boundary
- * handling — so any future provider quirk surfaces as a focused
- * failure instead of a generic stream crash.
- */
-import { describe, expect, it } from "vitest";
-import { _internals, createSiliconflowRepairFetch } from "../siliconflow-sse-repair.js";
-const { SiliconflowSseRepairer } = _internals;
-function makeSseEvent(payload) {
-    return `data: ${JSON.stringify(payload)}\n\n`;
-}
-function parseEventPayload(eventText) {
-    const m = eventText.match(/^data: (.+)$/m);
-    if (!m)
-        return null;
-    if (m[1] === "[DONE]")
-        return null;
-    return JSON.parse(m[1] ?? "{}");
-}
-describe("SiliconflowSseRepairer.repairEvent", () => {
-    it("passes through well-formed first chunk (id + name on chunk 1)", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev = makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [
-                            {
-                                index: 0,
-                                id: "call_abc",
-                                type: "function",
-                                function: { name: "grep", arguments: '{"a":' },
-                            },
-                        ],
-                    },
-                },
-            ],
-        });
-        const out = r.repairEvent(ev);
-        const payload = parseEventPayload(out);
-        const choice0 = payload?.choices?.[0];
-        const tc0 = choice0?.delta.tool_calls?.[0];
-        expect(tc0?.id).toBe("call_abc");
-        const fn = tc0?.function;
-        expect(fn?.name).toBe("grep");
-        expect(fn?.arguments).toBe('{"a":');
-    });
-    it("buffers a first chunk with no id+name, flushes when name arrives", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev1 = makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 0, function: { arguments: '{"pattern":' } }],
-                    },
-                },
-            ],
-        });
-        expect(r.repairEvent(ev1)).toBe("");
-        const ev2 = makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [
-                            {
-                                index: 0,
-                                id: "call_xyz",
-                                function: { name: "grep", arguments: '"catch"}' },
-                            },
-                        ],
-                    },
-                },
-            ],
-        });
-        const out = r.repairEvent(ev2);
-        const payload = parseEventPayload(out);
-        const tc0 = (payload?.choices)[0]?.delta.tool_calls?.[0];
-        expect(tc0.id).toBe("call_xyz");
-        const fn = tc0.function;
-        expect(fn.name).toBe("grep");
-        expect(fn.arguments).toBe('{"pattern":"catch"}');
-    });
-    it("after flush, subsequent argument deltas pass through unchanged", () => {
-        const r = new SiliconflowSseRepairer();
-        r.repairEvent(makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 0, id: "call_1", function: { name: "x", arguments: '{"' } }],
-                    },
-                },
-            ],
-        }));
-        const cont = makeSseEvent({
-            choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: 'k":1}' } }] } }],
-        });
-        const out = r.repairEvent(cont);
-        const tc0 = (parseEventPayload(out)?.choices)[0]?.delta
-            .tool_calls?.[0];
-        const fn = tc0.function;
-        expect(fn.arguments).toBe('k":1}');
-        expect(tc0.id).toBeUndefined();
-    });
-    it("handles multi-index streams independently", () => {
-        const r = new SiliconflowSseRepairer();
-        expect(r.repairEvent(makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [
-                            { index: 0, function: { arguments: "{" } },
-                            { index: 1, function: { arguments: "{" } },
-                        ],
-                    },
-                },
-            ],
-        }))).toBe("");
-        const out = r.repairEvent(makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 0, id: "c0", function: { name: "read_file", arguments: '"p":"a"}' } }],
-                    },
-                },
-            ],
-        }));
-        const tcs = (parseEventPayload(out)?.choices)[0]?.delta
-            .tool_calls;
-        expect(tcs).toHaveLength(1);
-        expect(tcs[0]?.id).toBe("c0");
-        expect((tcs[0]?.function).arguments).toBe('{"p":"a"}');
-        expect(r.repairEvent(makeSseEvent({
-            choices: [{ delta: { tool_calls: [{ index: 1, function: { arguments: '"q"' } }] } }],
-        }))).toBe("");
-        const out2 = r.repairEvent(makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 1, id: "c1", function: { name: "grep", arguments: "}" } }],
-                    },
-                },
-            ],
-        }));
-        const tcs2 = (parseEventPayload(out2)?.choices)[0]?.delta
-            .tool_calls;
-        expect(tcs2[0]?.id).toBe("c1");
-        expect((tcs2[0]?.function).arguments).toBe('{"q"}');
-    });
-    it("preserves content-only deltas unchanged", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev = makeSseEvent({ choices: [{ delta: { content: "hello" } }] });
-        expect(r.repairEvent(ev)).toBe(ev);
-    });
-    it("preserves [DONE] sentinel", () => {
-        const r = new SiliconflowSseRepairer();
-        expect(r.repairEvent("data: [DONE]\n\n")).toBe("data: [DONE]\n\n");
-    });
-    it("preserves event with finish_reason even when tool_calls is suppressed", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev = makeSseEvent({
-            choices: [
-                {
-                    delta: { tool_calls: [{ index: 0, function: { arguments: "{" } }] },
-                    finish_reason: "tool_calls",
-                },
-            ],
-        });
-        const out = r.repairEvent(ev);
-        const payload = parseEventPayload(out);
-        expect(payload).not.toBeNull();
-        const choice0 = (payload?.choices)[0];
-        expect(choice0?.finish_reason).toBe("tool_calls");
-        expect((choice0?.delta).tool_calls).toBeUndefined();
-    });
-    it("returns input unchanged on un-parseable JSON payload", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev = "data: not-json{\n\n";
-        expect(r.repairEvent(ev)).toBe(ev);
-    });
-    it("returns input unchanged when no data: line present", () => {
-        const r = new SiliconflowSseRepairer();
-        const ev = ": heartbeat\n\n";
-        expect(r.repairEvent(ev)).toBe(ev);
-    });
-});
-describe("createSiliconflowRepairFetch", () => {
-    function sseResponse(events) {
-        const body = new ReadableStream({
-            start(controller) {
-                const encoder = new TextEncoder();
-                for (const e of events)
-                    controller.enqueue(encoder.encode(e));
-                controller.close();
-            },
-        });
-        return new Response(body, {
-            status: 200,
-            headers: { "content-type": "text/event-stream" },
-        });
-    }
-    async function readAll(res) {
-        if (!res.body)
-            return "";
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let out = "";
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            out += decoder.decode(value, { stream: true });
-        }
-        return out;
-    }
-    it("repairs malformed first chunk in a real streaming response", async () => {
-        const ev1 = makeSseEvent({
-            choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '{"k":' } }] } }],
-        });
-        const ev2 = makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 0, id: "c", function: { name: "f", arguments: '"v"}' } }],
-                    },
-                },
-            ],
-        });
-        const baseFetch = async () => sseResponse([ev1, ev2, "data: [DONE]\n\n"]);
-        const wrapped = createSiliconflowRepairFetch(baseFetch);
-        const res = await wrapped("https://example.com/v1/chat/completions");
-        const text = await readAll(res);
-        expect(text).not.toContain('"arguments":"{\\"k\\":"');
-        expect(text).toContain('"id":"c"');
-        expect(text).toContain('"name":"f"');
-        expect(text).toContain('"arguments":"{\\"k\\":\\"v\\"}"');
-        expect(text).toContain("[DONE]");
-    });
-    it("passes through non-SSE responses unchanged", async () => {
-        const baseFetch = async () => new Response('{"ok":true}', { headers: { "content-type": "application/json" } });
-        const wrapped = createSiliconflowRepairFetch(baseFetch);
-        const res = await wrapped("https://example.com/v1/models");
-        const txt = await res.text();
-        expect(txt).toBe('{"ok":true}');
-    });
-    it("handles events split across multiple reader chunks", async () => {
-        const ev = makeSseEvent({
-            choices: [
-                {
-                    delta: {
-                        tool_calls: [{ index: 0, id: "c", function: { name: "g", arguments: '"x"' } }],
-                    },
-                },
-            ],
-        });
-        const half = Math.floor(ev.length / 2);
-        const baseFetch = async () => sseResponse([ev.slice(0, half), ev.slice(half)]);
-        const wrapped = createSiliconflowRepairFetch(baseFetch);
-        const res = await wrapped("https://example.com/v1/chat/completions");
-        const text = await readAll(res);
-        expect(text).toContain('"id":"c"');
-        expect(text).toContain('"name":"g"');
-    });
-});
-//# sourceMappingURL=siliconflow-sse-repair.test.js.map

package/dist/src/providers/__tests__/strategies-registry.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Phase 12.2-G4 — Strategy registry contract tests.
- *
- * Verifies each ProviderId maps to a stable strategy instance whose
- * capabilities object matches the capabilities registry singleton, and
- * that createFactory succeeds with a minimal config for every provider.
- */
-export {};

package/dist/src/providers/__tests__/strategies-registry.test.js

@@ -1,49 +0,0 @@
-/**
- * Phase 12.2-G4 — Strategy registry contract tests.
- *
- * Verifies each ProviderId maps to a stable strategy instance whose
- * capabilities object matches the capabilities registry singleton, and
- * that createFactory succeeds with a minimal config for every provider.
- */
-import { describe, expect, test } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-import { getProviderStrategy } from "../strategies/registry.js";
-const PROVIDER_IDS = [
-    "anthropic",
-    "openai",
-    "google",
-    "deepseek",
-    "siliconflow",
-    "xai",
-    "ollama",
-];
-describe("strategy registry", () => {
-    test("each ProviderId yields a stable singleton instance", () => {
-        for (const id of PROVIDER_IDS) {
-            const first = getProviderStrategy(id);
-            const second = getProviderStrategy(id);
-            expect(first).toBe(second);
-            expect(first.id).toBe(id);
-        }
-    });
-    test("each strategy.capabilities matches getProviderCapabilities(id)", () => {
-        for (const id of PROVIDER_IDS) {
-            const strategy = getProviderStrategy(id);
-            expect(strategy.capabilities).toBe(getProviderCapabilities(id));
-        }
-    });
-    test("unknown provider id throws — no silent fallback", () => {
-        // Silent fallback used to mask registry desync. Now throws loudly so
-        // adding a new ProviderId to types.ts without registering a strategy
-        // fails fast at the first dispatch instead of silently using anthropic.
-        expect(() => getProviderStrategy("unknown-provider")).toThrow(/No provider strategy registered/);
-    });
-    test("createFactory does not throw for any provider with a stub api key", () => {
-        for (const id of PROVIDER_IDS) {
-            const strategy = getProviderStrategy(id);
-            const factory = strategy.createFactory({ apiKey: "test-key-long-enough" });
-            expect(typeof factory).toBe("function");
-        }
-    });
-});
-//# sourceMappingURL=strategies-registry.test.js.map

package/dist/src/providers/__tests__/strategies-resolve.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * Phase 12.2-G4 — Strategy.resolve contract tests.
- *
- * Verifies the base.resolve() body honors capability decisions:
- *   - usesResponsesAPI(true) → factory.responses() invoked
- *   - usesResponsesAPI(false) → factory(modelId) invoked
- *   - buildProviderOptions output propagates onto ResolvedModelRuntime
- *   - factory.unsupportedParams propagates onto ResolvedModelRuntime
- *
- * Also pins the OpenAI api-key store:true policy migrated in G4.
- */
-export {};

package/dist/src/providers/__tests__/strategies-resolve.test.js

@@ -1,128 +0,0 @@
-/**
- * Phase 12.2-G4 — Strategy.resolve contract tests.
- *
- * Verifies the base.resolve() body honors capability decisions:
- *   - usesResponsesAPI(true) → factory.responses() invoked
- *   - usesResponsesAPI(false) → factory(modelId) invoked
- *   - buildProviderOptions output propagates onto ResolvedModelRuntime
- *   - factory.unsupportedParams propagates onto ResolvedModelRuntime
- *
- * Also pins the OpenAI api-key store:true policy migrated in G4.
- */
-import { describe, expect, test, vi } from "vitest";
-import { OpenAIStrategy } from "../strategies/openai.strategy.js";
-import { getProviderStrategy } from "../strategies/registry.js";
-function makeFactory() {
-    const chat = vi.fn((id) => ({ kind: "chat", id }));
-    const resp = vi.fn((id) => ({ kind: "resp", id }));
-    const factory = ((id) => chat(id));
-    factory.responses = (id) => resp(id);
-    return { factory, chat, resp };
-}
-describe("strategy.resolve()", () => {
-    test("anthropic thinkingType=enabled → providerOptions.anthropic.thinking set", () => {
-        const strategy = getProviderStrategy("anthropic");
-        const { factory, chat, resp } = makeFactory();
-        const modelInfo = {
-            id: "claude-3-7-sonnet-latest",
-            name: "Claude 3.7 Sonnet",
-            contextWindow: 200_000,
-            inputPrice: 3,
-            outputPrice: 15,
-            reasoning: true,
-            description: "",
-            provider: "anthropic",
-            thinkingType: "enabled",
-        };
-        const result = strategy.resolve({
-            factory,
-            modelId: modelInfo.id,
-            modelInfo,
-        });
-        expect(chat).toHaveBeenCalledWith("claude-3-7-sonnet-latest");
-        expect(resp).not.toHaveBeenCalled();
-        expect(result.providerOptions?.anthropic?.thinking).toEqual({
-            type: "enabled",
-            budgetTokens: 8_000,
-        });
-    });
-    test("openai reasoning model → factory.responses() invoked, NOT factory()", () => {
-        const strategy = getProviderStrategy("openai");
-        const { factory, chat, resp } = makeFactory();
-        const modelInfo = {
-            id: "gpt-5.4",
-            name: "GPT-5.4",
-            contextWindow: 400_000,
-            inputPrice: 5,
-            outputPrice: 15,
-            reasoning: true,
-            description: "",
-            provider: "openai",
-            supportsReasoningEffort: true,
-            defaultReasoningEffort: "medium",
-        };
-        const result = strategy.resolve({
-            factory,
-            modelId: modelInfo.id,
-            modelInfo,
-        });
-        expect(resp).toHaveBeenCalledWith("gpt-5.4");
-        expect(chat).not.toHaveBeenCalled();
-        expect(result.providerOptions?.openai?.reasoningEffort).toBe("medium");
-    });
-    test("openai non-reasoning model → factory() chat path", () => {
-        const strategy = getProviderStrategy("openai");
-        const { factory, chat, resp } = makeFactory();
-        const modelInfo = {
-            id: "gpt-4o-mini",
-            name: "GPT-4o Mini",
-            contextWindow: 128_000,
-            inputPrice: 0.15,
-            outputPrice: 0.6,
-            reasoning: false,
-            description: "",
-            provider: "openai",
-        };
-        const result = strategy.resolve({
-            factory,
-            modelId: modelInfo.id,
-            modelInfo,
-        });
-        expect(chat).toHaveBeenCalledWith("gpt-4o-mini");
-        expect(resp).not.toHaveBeenCalled();
-        expect(result.providerOptions).toBeUndefined();
-    });
-    test("unsupportedParams from factory propagates onto runtime", () => {
-        const strategy = getProviderStrategy("openai");
-        const { factory } = makeFactory();
-        factory.unsupportedParams = ["maxOutputTokens"];
-        const modelInfo = {
-            id: "gpt-5.4",
-            name: "GPT-5.4",
-            contextWindow: 400_000,
-            inputPrice: 5,
-            outputPrice: 15,
-            reasoning: true,
-            description: "",
-            provider: "openai",
-        };
-        const result = strategy.resolve({ factory, modelId: modelInfo.id, modelInfo });
-        expect(result.unsupportedParams).toEqual(["maxOutputTokens"]);
-    });
-});
-describe("OpenAIStrategy.createFactory store:true policy (G4 migration)", () => {
-    test("api-key path seeds factory.defaultProviderOptions.store=true", () => {
-        const strategy = new OpenAIStrategy();
-        const factory = strategy.createFactory({ apiKey: "sk-test-1234567890abcdef" });
-        expect(factory.defaultProviderOptions).toEqual({ store: true });
-    });
-    test("OAuth path (headers provided) does NOT seed store:true — auth registry sets store:false", () => {
-        const strategy = new OpenAIStrategy();
-        const factory = strategy.createFactory({
-            apiKey: "oauth",
-            headers: { Authorization: "Bearer test" },
-        });
-        expect(factory.defaultProviderOptions).toBeUndefined();
-    });
-});
-//# sourceMappingURL=strategies-resolve.test.js.map

package/dist/src/providers/__tests__/wire-debug.test.d.ts

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

package/dist/src/providers/__tests__/wire-debug.test.js

@@ -1,39 +0,0 @@
-/**
- * Verifies the wire-debug message summarizer redacts content but preserves
- * structural shape needed to diagnose provider-specific failures
- * (e.g. SiliconFlow reasoning_content round-trip).
- */
-import { describe, expect, it } from "vitest";
-import { _internals } from "../wire-debug.js";
-const { summarizeMessage } = _internals;
-describe("wire-debug summarizeMessage", () => {
-    it("captures role + string content length", () => {
-        expect(summarizeMessage({ role: "user", content: "hello world" })).toEqual({
-            role: "user",
-            contentKind: "string",
-            textChars: 11,
-        });
-    });
-    it("captures parts-array role + part types + tool call ids", () => {
-        const m = {
-            role: "assistant",
-            content: [
-                { type: "text", text: "thinking..." },
-                { type: "tool-call", toolCallId: "call_1", toolName: "read_file" },
-                { type: "reasoning", text: "internal monologue" },
-            ],
-        };
-        const shape = summarizeMessage(m);
-        expect(shape.role).toBe("assistant");
-        expect(shape.contentKind).toBe("parts");
-        expect(shape.partTypes).toEqual(["text", "tool-call", "reasoning"]);
-        expect(shape.toolCallIds).toEqual(["call_1"]);
-        expect(shape.textChars).toBe("thinking...".length + "internal monologue".length);
-    });
-    it("handles missing/unknown role gracefully", () => {
-        const shape = summarizeMessage({ content: "" });
-        expect(shape.role).toBe("?");
-        expect(shape.textChars).toBe(0);
-    });
-});
-//# sourceMappingURL=wire-debug.test.js.map

package/dist/src/providers/adapter.test.d.ts

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

package/dist/src/providers/adapter.test.js

@@ -1,19 +0,0 @@
-/**
- * Tests for src/providers/adapter.ts
- * Verifies createAdapter factory dispatches to all 6 provider IDs.
- */
-import { describe, expect, it } from "vitest";
-import { ALL_PROVIDER_IDS, createAdapter } from "./adapter.js";
-describe("createAdapter", () => {
-    it("creates an adapter for each ProviderId", () => {
-        const ids = ["anthropic", "openai", "google", "deepseek", "siliconflow", "xai", "ollama"];
-        for (const id of ids) {
-            const adapter = createAdapter(id, { model: "test-model", apiKey: "test-key-long-enough-for-test" });
-            expect(typeof adapter.stream).toBe("function");
-        }
-    });
-    it("ALL_PROVIDER_IDS contains all 7 providers", () => {
-        expect(ALL_PROVIDER_IDS).toEqual(["anthropic", "openai", "google", "deepseek", "siliconflow", "xai", "ollama"]);
-    });
-});
-//# sourceMappingURL=adapter.test.js.map

package/dist/src/providers/auth/__tests__/browser-flow.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for src/providers/auth/browser-flow.ts
- *
- * buildAuthorizeUrl structure, PKCE roundtrip,
- * exchangeBrowserCode and refreshBrowserTokens mock HTTP.
- * No live network calls.
- */
-export {};