muonroi-cli 1.8.0 → 1.8.3

package/dist/src/providers/__tests__/capabilities.test.d.ts

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

package/dist/src/providers/__tests__/capabilities.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-describe("ProviderCapabilities", () => {
-    describe("supportsResponseTool — reliable providers", () => {
-        for (const id of ["openai", "anthropic", "google", "xai"]) {
-            it(`${id} reports true for all task types`, () => {
-                const caps = getProviderCapabilities(id);
-                expect(caps.supportsResponseTool("general")).toBe(true);
-                expect(caps.supportsResponseTool("analyze")).toBe(true);
-                expect(caps.supportsResponseTool("plan")).toBe(true);
-                expect(caps.supportsResponseTool("debug")).toBe(true);
-            });
-        }
-    });
-    describe("supportsResponseTool — DeepSeek family", () => {
-        for (const id of ["deepseek", "siliconflow"]) {
-            it(`${id} reports false for general (token leak), true for structured`, () => {
-                const caps = getProviderCapabilities(id);
-                expect(caps.supportsResponseTool("general")).toBe(false);
-                expect(caps.supportsResponseTool("analyze")).toBe(true);
-                expect(caps.supportsResponseTool("plan")).toBe(true);
-                expect(caps.supportsResponseTool("debug")).toBe(true);
-            });
-        }
-    });
-    describe("supportsResponseTool — Ollama (conservative)", () => {
-        it("reports false for general, true for structured", () => {
-            const caps = getProviderCapabilities("ollama");
-            expect(caps.supportsResponseTool("general")).toBe(false);
-            expect(caps.supportsResponseTool("analyze")).toBe(true);
-        });
-    });
-    describe("unknown provider id", () => {
-        it("falls back to reliable defaults", () => {
-            const caps = getProviderCapabilities("does-not-exist");
-            expect(caps.supportsResponseTool("general")).toBe(true);
-            expect(caps.supportsResponseTool("analyze")).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=capabilities.test.js.map

package/dist/src/providers/__tests__/provider-coverage.test.d.ts

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

package/dist/src/providers/__tests__/provider-coverage.test.js

@@ -1,45 +0,0 @@
-/**
- * Cross-registry coverage test.
- *
- * Single source of truth for "what providers exist" is `ALL_PROVIDER_IDS`
- * in src/providers/types.ts. Every other registry (strategies, adapter
- * factories, capabilities) MUST cover every id in `ALL_PROVIDER_IDS` —
- * otherwise we get silent desync where adding a provider to the union
- * type works at compile time but blows up at runtime for one code path.
- *
- * This test fails loudly when a new ProviderId is added to types.ts
- * without matching entries in all dispatch tables.
- */
-import { describe, expect, it } from "vitest";
-import { createAdapter } from "../adapter.js";
-import { getProviderCapabilities } from "../capabilities.js";
-import { getProviderStrategy } from "../strategies/registry.js";
-import { ALL_PROVIDER_IDS } from "../types.js";
-describe("provider registry coverage", () => {
-    it("every ProviderId has a strategy", () => {
-        for (const id of ALL_PROVIDER_IDS) {
-            expect(() => getProviderStrategy(id), `strategy missing for ${id}`).not.toThrow();
-            const s = getProviderStrategy(id);
-            expect(s.id, `strategy.id mismatch for ${id}`).toBe(id);
-        }
-    });
-    it("every ProviderId has an adapter factory", () => {
-        for (const id of ALL_PROVIDER_IDS) {
-            const adapter = createAdapter(id, { model: "test-model", apiKey: "test-key-long-enough-for-test" });
-            expect(adapter.id, `adapter.id mismatch for ${id}`).toBe(id);
-            expect(typeof adapter.stream, `adapter.stream missing for ${id}`).toBe("function");
-        }
-    });
-    it("every ProviderId has a capability entry", () => {
-        for (const id of ALL_PROVIDER_IDS) {
-            const caps = getProviderCapabilities(id);
-            expect(caps, `capabilities missing for ${id}`).toBeDefined();
-            // Sanity-check one method to make sure it is a real instance, not a default fallback.
-            expect(typeof caps.acceptsParam).toBe("function");
-        }
-    });
-    it("strategy registry rejects unknown ids loudly", () => {
-        expect(() => getProviderStrategy("nonexistent-provider")).toThrow(/No provider strategy registered/);
-    });
-});
-//# sourceMappingURL=provider-coverage.test.js.map

package/dist/src/providers/__tests__/reasoning-roundtrip.test.d.ts

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

package/dist/src/providers/__tests__/reasoning-roundtrip.test.js

@@ -1,216 +0,0 @@
-/**
- * Real-fix proof for the "reasoning_content must be passed back" rejection
- * that previously hit DeepSeek/SiliconFlow (HTTP 400 code 20015).
- *
- * The previous workaround (commit 42d5440, May 2026) disabled thinking mode
- * entirely because @ai-sdk/openai-compatible reportedly did not serialize
- * assistant reasoning parts as `reasoning_content`. This test asserts the
- * opposite for the version pinned in package.json (2.0.42) by capturing the
- * actual outgoing request body through a stub `fetch` and inspecting the
- * serialized payload.
- *
- * If this test passes, the workaround is unnecessary and reasoning_content
- * round-trips natively — which is what removed the `thinking-disabled`
- * unconditional gate. If it ever fails (upstream regression), put the gate
- * back in DeepSeekProviderCapabilities.buildProviderOptions.
- *
- * Reference: dist/index.js:257-263 in
- *   node_modules/.bun/@ai-sdk+openai-compatible@2.0.42/.../dist/index.js
- */
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { streamText } from "ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { transformThinkingModeBody } from "../strategies/thinking-mode.js";
-function makeStubProvider(name, capture) {
-    return createOpenAICompatible({
-        name,
-        baseURL: "https://example.test/v1",
-        apiKey: "stub-key",
-        fetch: (async (input, init) => {
-            const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-            const bodyText = typeof init?.body === "string" ? init.body : "";
-            capture.current = {
-                url,
-                body: bodyText ? JSON.parse(bodyText) : {},
-            };
-            const sse = [
-                'data: {"id":"x","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":"ok"}}]}\n\n',
-                "data: [DONE]\n\n",
-            ].join("");
-            return new Response(sse, {
-                status: 200,
-                headers: { "content-type": "text/event-stream" },
-            });
-        }),
-    });
-}
-async function drain(stream) {
-    for await (const _ of stream) {
-        /* drain */
-    }
-}
-describe("reasoning_content round-trip — AI SDK 2.0.42 wire shape", () => {
-    it("siliconflow: serializes assistant reasoning part as reasoning_content in request body", async () => {
-        const capture = { current: null };
-        const provider = makeStubProvider("siliconflow", capture);
-        const model = provider("deepseek-ai/DeepSeek-V4-Flash");
-        const result = streamText({
-            model,
-            messages: [
-                { role: "user", content: "What is 2+2?" },
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "reasoning", text: "The user is asking basic arithmetic; the answer is four." },
-                        { type: "text", text: "4" },
-                    ],
-                },
-                { role: "user", content: "Now what is 2+3?" },
-            ],
-        });
-        await drain(result.fullStream);
-        expect(capture.current).not.toBeNull();
-        const body = capture.current.body;
-        const assistantMsg = body.messages.find((m) => m.role === "assistant");
-        expect(assistantMsg, "assistant message must be present in wire body").toBeDefined();
-        expect(assistantMsg.reasoning_content).toBe("The user is asking basic arithmetic; the answer is four.");
-        expect(assistantMsg.content).toBe("4");
-    });
-    it("deepseek: serializes assistant reasoning part as reasoning_content in request body", async () => {
-        const capture = { current: null };
-        const provider = makeStubProvider("deepseek", capture);
-        const model = provider("deepseek-v4-flash");
-        const result = streamText({
-            model,
-            messages: [
-                { role: "user", content: "Read foo.txt" },
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "reasoning", text: "I need to call the read_file tool." },
-                        { type: "tool-call", toolCallId: "c1", toolName: "read_file", input: { path: "foo.txt" } },
-                    ],
-                },
-                {
-                    role: "tool",
-                    content: [
-                        {
-                            type: "tool-result",
-                            toolCallId: "c1",
-                            toolName: "read_file",
-                            output: { type: "text", value: "contents" },
-                        },
-                    ],
-                },
-                { role: "user", content: "summarize" },
-            ],
-        });
-        await drain(result.fullStream);
-        expect(capture.current).not.toBeNull();
-        const body = capture.current.body;
-        const assistantMsg = body.messages.find((m) => m.role === "assistant");
-        expect(assistantMsg, "assistant message with tool-call must round-trip").toBeDefined();
-        expect(assistantMsg.reasoning_content).toBe("I need to call the read_file tool.");
-        expect(Array.isArray(assistantMsg.tool_calls)).toBe(true);
-        expect(assistantMsg.tool_calls[0]?.id).toBe("c1");
-    });
-    // NOTE: the bare provider correctly omits reasoning_content when a turn has
-    // no reasoning part — but that is exactly the shape SiliconFlow's
-    // thinking-mode validator rejects (code 20015) in a mixed history. The
-    // strategy's transformRequestBody backfills it; see the dedicated describe
-    // block below ("transformThinkingModeBody — backfill / disable").
-    it("emits no reasoning_content key when there are no reasoning parts (no false positives)", async () => {
-        const capture = { current: null };
-        const provider = makeStubProvider("siliconflow", capture);
-        const model = provider("deepseek-ai/DeepSeek-V4-Flash");
-        const result = streamText({
-            model,
-            messages: [
-                { role: "user", content: "Hi" },
-                { role: "assistant", content: [{ type: "text", text: "Hello!" }] },
-                { role: "user", content: "Again" },
-            ],
-        });
-        await drain(result.fullStream);
-        expect(capture.current).not.toBeNull();
-        const body = capture.current.body;
-        const assistantMsg = body.messages.find((m) => m.role === "assistant");
-        expect(assistantMsg.reasoning_content).toBeUndefined();
-    });
-});
-describe("transformThinkingModeBody — backfill / disable (code 20015 fix)", () => {
-    const ENV = "MUONROI_DEEPSEEK_DISABLE_THINKING";
-    let saved;
-    beforeEach(() => {
-        saved = process.env[ENV];
-        delete process.env[ENV];
-    });
-    afterEach(() => {
-        if (saved === undefined)
-            delete process.env[ENV];
-        else
-            process.env[ENV] = saved;
-    });
-    it("A (default): backfills reasoning_content on a tool-call turn that lacks it", () => {
-        const body = {
-            messages: [
-                { role: "user", content: "go" },
-                // tool-call turn with NO reasoning (the real bug shape)
-                { role: "assistant", content: null, tool_calls: [{ id: "t1", type: "function" }] },
-            ],
-        };
-        const out = transformThinkingModeBody(body);
-        const asst = out.messages.find((m) => m.role === "assistant");
-        expect(asst.reasoning_content).toBe("");
-        expect(Array.isArray(asst.tool_calls)).toBe(true); // tool_calls preserved
-        expect("thinking" in out).toBe(false); // thinking still ON
-    });
-    it("A (default): leaves a real reasoning_content untouched and patches only the gap", () => {
-        const body = {
-            messages: [
-                { role: "user", content: "go" },
-                { role: "assistant", content: null, reasoning_content: "real thought", tool_calls: [{ id: "a" }] },
-                { role: "tool", content: "result" },
-                { role: "assistant", content: null, tool_calls: [{ id: "b" }] }, // gap
-            ],
-        };
-        const out = transformThinkingModeBody(body);
-        const asst = out.messages.filter((m) => m.role === "assistant");
-        expect(asst[0].reasoning_content).toBe("real thought"); // untouched
-        expect(asst[1].reasoning_content).toBe(""); // backfilled
-    });
-    it("A (default): backfills content: '' on a reasoning-only turn that lacks content and tool_calls", () => {
-        const body = {
-            messages: [
-                { role: "user", content: "go" },
-                { role: "assistant", content: null, reasoning_content: "only thought" },
-            ],
-        };
-        const out = transformThinkingModeBody(body);
-        const asst = out.messages.find((m) => m.role === "assistant");
-        expect(asst.reasoning_content).toBe("only thought");
-        expect(asst.content).toBe("");
-    });
-    it("A (default): does not touch non-assistant messages", () => {
-        const body = {
-            messages: [
-                { role: "user", content: "hi" },
-                { role: "tool", content: "r" },
-            ],
-        };
-        const out = transformThinkingModeBody(body);
-        expect("reasoning_content" in out.messages[0]).toBe(false);
-        expect("reasoning_content" in out.messages[1]).toBe(false);
-    });
-    it("B (env=1): disables thinking and does NOT backfill reasoning_content", () => {
-        process.env[ENV] = "1";
-        const body = {
-            messages: [{ role: "assistant", content: null, tool_calls: [{ id: "t1" }] }],
-        };
-        const out = transformThinkingModeBody(body);
-        expect(out.thinking).toEqual({ type: "disabled" });
-        const asst = out.messages.find((m) => m.role === "assistant");
-        expect("reasoning_content" in asst).toBe(false);
-    });
-});
-//# sourceMappingURL=reasoning-roundtrip.test.js.map

package/dist/src/providers/__tests__/runtime-integration.test.d.ts

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

package/dist/src/providers/__tests__/runtime-integration.test.js

@@ -1,93 +0,0 @@
-import { beforeAll, describe, expect, test } from "vitest";
-import { loadCatalog } from "../../models/registry.js";
-import { createProviderFactory, detectProviderForModel, resolveModelRuntime } from "../runtime.js";
-// Fake fixture value — kept outside the inline objects so the repo-wide
-// secret scanner doesn't trip on `apiKey: "..."` string literals.
-const MOCK_KEY = "x".repeat(32);
-beforeAll(async () => {
-    await loadCatalog();
-});
-// Detection cases use catalog hits for active providers (deepseek/siliconflow)
-// and prefix-fallback for legacy ids (anthropic/openai/xai stay in code per
-// src/models/catalog.README.md but are not in the local catalog).
-describe("model → provider detection", () => {
-    const cases = [
-        ["claude-sonnet-4-6", "anthropic"],
-        ["claude-opus-4-7", "anthropic"],
-        ["gpt-4o", "openai"],
-        ["gpt-4o-mini", "openai"],
-        ["o3", "openai"],
-        ["deepseek-v4-flash", "deepseek"],
-        ["deepseek-v4-pro", "deepseek"],
-        ["deepseek-ai/DeepSeek-V4-Flash", "siliconflow"],
-        ["deepseek-ai/DeepSeek-V4-Pro", "siliconflow"],
-        ["alibaba/Qwen3-8B", "siliconflow"],
-        ["grok-3", "xai"],
-        ["grok-3-mini", "xai"],
-    ];
-    for (const [modelId, expectedProvider] of cases) {
-        test(`${modelId} → ${expectedProvider}`, () => {
-            expect(detectProviderForModel(modelId)).toBe(expectedProvider);
-        });
-    }
-    test("unknown-custom-model throws instead of defaulting", () => {
-        expect(() => detectProviderForModel("unknown-custom-model")).toThrow("not in catalog and no prefix match");
-    });
-});
-describe("end-to-end: create factory + resolve runtime", () => {
-    test("deepseek model resolves with catalog modelInfo populated", () => {
-        const pf = createProviderFactory("deepseek", {
-            apiKey: MOCK_KEY,
-        });
-        const runtime = resolveModelRuntime(pf.factory, "deepseek-v4-flash");
-        expect(runtime.modelId).toBe("deepseek-v4-flash");
-        expect(runtime.model).toBeDefined();
-        expect(runtime.modelInfo?.provider).toBe("deepseek");
-        // DeepSeek capability does not inject anthropic-style thinking opts.
-        expect(runtime.providerOptions?.anthropic).toBeUndefined();
-    });
-    test("siliconflow model resolves with catalog modelInfo populated", () => {
-        const pf = createProviderFactory("siliconflow", {
-            apiKey: MOCK_KEY,
-        });
-        const runtime = resolveModelRuntime(pf.factory, "Qwen/Qwen3-8B");
-        expect(runtime.modelInfo?.provider).toBe("siliconflow");
-        expect(runtime.modelId).toBe("Qwen/Qwen3-8B");
-    });
-    test("legacy alibaba/* id resolves to Qwen/* canonical via alias (catalog fix 2026-05-26)", () => {
-        // SiliconFlow's /v1/models endpoint returned Qwen/Qwen3-* but the catalog
-        // shipped alibaba/Qwen3-* in version 2.1; session 500325a9f0a9 failed with
-        // HTTP 400 code 20012 "Model does not exist." Aliases keep the legacy id
-        // routable so user-settings.json and persisted sessions don't break.
-        const pf = createProviderFactory("siliconflow", { apiKey: MOCK_KEY });
-        const runtime = resolveModelRuntime(pf.factory, "alibaba/Qwen3-30B-A3B-Instruct-2507");
-        expect(runtime.modelInfo?.provider).toBe("siliconflow");
-        expect(runtime.modelId).toBe("Qwen/Qwen3-30B-A3B-Instruct-2507");
-    });
-    test("openai model not in catalog throws", () => {
-        const pf = createProviderFactory("openai", {
-            apiKey: MOCK_KEY,
-        });
-        expect(() => resolveModelRuntime(pf.factory, "gpt-4o")).toThrow("not found in catalog");
-    });
-    // Anthropic-thinking and xai reasoning-effort behavior is covered by
-    // capabilities-provider-options.test.ts using synthetic ModelInfo fixtures —
-    // those tests do not depend on catalog presence.
-    test("ollama model not in catalog throws", () => {
-        const pf = createProviderFactory("ollama", {});
-        expect(() => resolveModelRuntime(pf.factory, "llama3")).toThrow("not found in catalog");
-    });
-    test("anthropic factory has responses method", () => {
-        const pf = createProviderFactory("anthropic", {
-            apiKey: "sk-ant-test-key-long-enough-for-validation",
-        });
-        expect(typeof pf.factory.responses).toBe("function");
-    });
-    test("openai factory exposes a responses method (needed for ChatGPT OAuth backend)", () => {
-        const pf = createProviderFactory("openai", {
-            apiKey: MOCK_KEY,
-        });
-        expect(typeof pf.factory.responses).toBe("function");
-    });
-});
-//# sourceMappingURL=runtime-integration.test.js.map

package/dist/src/providers/__tests__/runtime.test.d.ts

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

package/dist/src/providers/__tests__/runtime.test.js

@@ -1,80 +0,0 @@
-import { beforeAll, describe, expect, test } from "vitest";
-import { loadCatalog } from "../../models/registry.js";
-import { createProviderFactory, detectProviderForModel, resolveModelRuntime } from "../runtime.js";
-// Fake fixture value — kept outside the inline objects so the repo-wide
-// secret scanner doesn't trip on `apiKey: "..."` string literals.
-const MOCK_KEY = "x".repeat(32);
-beforeAll(async () => {
-    await loadCatalog();
-});
-describe("createProviderFactory", () => {
-    test("creates anthropic factory", () => {
-        const result = createProviderFactory("anthropic", {
-            apiKey: "sk-ant-test-key-long-enough-for-validation",
-        });
-        expect(result.id).toBe("anthropic");
-        expect(typeof result.factory).toBe("function");
-    });
-    test("creates openai factory", () => {
-        const result = createProviderFactory("openai", {
-            apiKey: "sk-openai-test-key-long-enough-for-validation",
-        });
-        expect(result.id).toBe("openai");
-        expect(typeof result.factory).toBe("function");
-    });
-    test("creates google factory", () => {
-        const result = createProviderFactory("google", {
-            apiKey: "google-test-api-key-long-enough-for-validation",
-        });
-        expect(result.id).toBe("google");
-        expect(typeof result.factory).toBe("function");
-    });
-    test("creates deepseek factory via openai-compatible", () => {
-        const result = createProviderFactory("deepseek", {
-            apiKey: MOCK_KEY,
-        });
-        expect(result.id).toBe("deepseek");
-        expect(typeof result.factory).toBe("function");
-    });
-    test("creates xai factory via openai-compatible", () => {
-        const result = createProviderFactory("xai", {
-            apiKey: "xai-test-key-long-enough-for-validation",
-        });
-        expect(result.id).toBe("xai");
-        expect(typeof result.factory).toBe("function");
-    });
-    test("creates ollama factory without key", () => {
-        const result = createProviderFactory("ollama", {});
-        expect(result.id).toBe("ollama");
-        expect(typeof result.factory).toBe("function");
-    });
-});
-describe("resolveModelRuntime", () => {
-    test("resolves known deepseek model", () => {
-        const pf = createProviderFactory("deepseek", {
-            apiKey: MOCK_KEY,
-        });
-        const runtime = resolveModelRuntime(pf.factory, "deepseek-v4-flash");
-        expect(runtime.modelId).toBe("deepseek-v4-flash");
-        expect(runtime.model).toBeDefined();
-        expect(runtime.modelInfo?.provider).toBe("deepseek");
-    });
-    test("throws for unknown model not in catalog", () => {
-        const pf = createProviderFactory("openai", {
-            apiKey: "sk-openai-test-key-long-enough-for-validation",
-        });
-        expect(() => resolveModelRuntime(pf.factory, "custom-model-xyz")).toThrow("not found in catalog");
-    });
-});
-// Prefix-based fallback in detectProviderForModel still maps the legacy ids
-// even though they are no longer in catalog (see src/models/catalog.README.md).
-describe("detectProviderForModel", () => {
-    test("detects anthropic via prefix fallback", () => expect(detectProviderForModel("claude-sonnet-4-6")).toBe("anthropic"));
-    test("detects openai via prefix fallback", () => expect(detectProviderForModel("gpt-4o")).toBe("openai"));
-    test("detects deepseek via catalog", () => expect(detectProviderForModel("deepseek-v4-flash")).toBe("deepseek"));
-    test("prefix fallback for unknown deepseek id", () => expect(detectProviderForModel("deepseek-future-x")).toBe("deepseek"));
-    test("detects siliconflow via catalog", () => expect(detectProviderForModel("deepseek-ai/DeepSeek-V4-Pro")).toBe("siliconflow"));
-    test("detects xai via prefix fallback", () => expect(detectProviderForModel("grok-3")).toBe("xai"));
-    test("throws for unknown model with no prefix match", () => expect(() => detectProviderForModel("unknown-model")).toThrow("not in catalog and no prefix match"));
-});
-//# sourceMappingURL=runtime.test.js.map

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

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