muonroi-cli 1.8.0 → 1.8.3

package/dist/src/providers/mcp-vision-bridge.test.js

@@ -1,381 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { analyzeImageFromSource, askVisionProxy, bridgeMcpToolResult, getVisionGuidanceForTextOnly, isImageFile, listCachedImages, scrubImagePayloadsInMessages, } from "./mcp-vision-bridge.js";
-vi.mock("../models/registry.js", () => ({
-    getModelInfo: (id) => {
-        if (id.startsWith("deepseek"))
-            return { supportsVision: false };
-        if (id === "claude-sonnet-4-6")
-            return { supportsVision: true };
-        return {};
-    },
-}));
-vi.mock("./keychain.js", () => ({
-    loadKeyForProvider: vi.fn().mockResolvedValue("sk-test-key-12345678901234567890"),
-}));
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-describe("bridgeMcpToolResult", () => {
-    beforeEach(() => vi.clearAllMocks());
-    afterEach(() => vi.restoreAllMocks());
-    it("passes through for vision-capable models", async () => {
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", "some output", "claude-sonnet-4-6");
-        expect(result.proxied).toBe(false);
-        expect(result.output).toBe("some output");
-    });
-    it("passes through snapshot (text) results without proxying", async () => {
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_snapshot", "accessibility tree content...", "deepseek-v4-flash");
-        expect(result.proxied).toBe(false);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it("proxies screenshot results for text-only models", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "A login page with username and password fields" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
-        expect(result.proxied).toBe(true);
-        expect(result.description).toContain("login page");
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-    it("intercepts ANY MCP tool with image data, not just Playwright", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Figma design with buttons" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("mcp_figma__export_frame", { imageData: fakeBase64 }, "deepseek-v4-flash");
-        expect(result.proxied).toBe(true);
-        expect(result.description).toContain("Figma design");
-    });
-    it("intercepts non-MCP tools with image data", async () => {
-        const fakeBase64 = `/9j/${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "JPEG content" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("computer_screenshot", { screenshot: fakeBase64 }, "deepseek-v4-flash");
-        expect(result.proxied).toBe(true);
-    });
-    it("detects data URI images in generic results", async () => {
-        const fakeBase64 = "A".repeat(200);
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Chart showing revenue data" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("mcp_some_tool__capture", `data:image/png;base64,${fakeBase64}`, "deepseek-v4-flash");
-        expect(result.proxied).toBe(true);
-    });
-    it("passes through non-image tool results", async () => {
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_click", { success: true, message: "Clicked element" }, "deepseek-v4-flash");
-        expect(result.proxied).toBe(false);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it("falls back gracefully when vision API fails — but still strips base64", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValue({ ok: false, status: 500 });
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
-        // proxied=true means the orchestrator will swap in our cleaned output;
-        // critical to prevent the raw base64 from polluting conversation history.
-        expect(result.proxied).toBe(true);
-        const serialized = JSON.stringify(result.output);
-        expect(serialized).toContain("could not be analyzed");
-        expect(serialized).not.toContain(fakeBase64);
-    });
-    it("strips base64 data from output when proxied", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Dashboard page" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { screenshot: fakeBase64, format: "png" }, "deepseek-v4-flash");
-        expect(result.proxied).toBe(true);
-        const output = result.output;
-        expect(output.screenshot).toContain("removed");
-    });
-    it("caches images for follow-up queries", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Test page" } }],
-            }),
-        });
-        const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
-        expect(result.cachedImageIds).toBeDefined();
-        expect(result.cachedImageIds.length).toBeGreaterThan(0);
-        const cached = listCachedImages();
-        expect(cached.length).toBeGreaterThan(0);
-        expect(cached[cached.length - 1].hasDescription).toBe(true);
-    });
-});
-describe("design context structured output", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("requests json_object response_format for figma/design tools", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: '{"viewport":{"width":1440,"height":900}}' } }],
-            }),
-        });
-        await bridgeMcpToolResult("mcp_figma__export_frame", { imageData: fakeBase64 }, "deepseek-v4-flash");
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.response_format).toEqual({ type: "json_object" });
-    });
-    it("does NOT set response_format for non-design contexts", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ choices: [{ message: { content: "ok" } }] }),
-        });
-        await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.response_format).toBeUndefined();
-    });
-});
-describe("SVG fast-path", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("bypasses vision API when input is image/svg+xml", async () => {
-        const svgText = '<svg width="100" height="50"><rect x="10" y="10" width="80" height="30" fill="#007bff"/></svg>';
-        const svgBase64 = Buffer.from(svgText, "utf8").toString("base64");
-        const dataUri = `data:image/svg+xml;base64,${svgBase64}`;
-        const result = await bridgeMcpToolResult("mcp_figma__export_frame", dataUri, "deepseek-v4-flash");
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(result.proxied).toBe(true);
-        const out = JSON.stringify(result.output);
-        expect(out).toContain("fast-path");
-        expect(out).toContain("rect");
-    });
-});
-describe("askVisionProxy", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("returns guidance when no images cached and no path given", async () => {
-        const result = await askVisionProxy("What?", "img_nonexistent");
-        expect(result).toContain("No matching image");
-        expect(result).toContain("file_path");
-    });
-    it("answers follow-up questions about cached images", async () => {
-        // Cache an image first
-        const fakeBase64 = `/9j/${"B".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "A form page" } }],
-            }),
-        });
-        const bridgeResult = await bridgeMcpToolResult("mcp_playwright__take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
-        const imageId = bridgeResult.cachedImageIds?.[0];
-        expect(imageId).toBeDefined();
-        // Ask follow-up
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "The submit button is blue" } }],
-            }),
-        });
-        const answer = await askVisionProxy("What color is the submit button?", imageId);
-        expect(answer).toContain("submit button is blue");
-        expect(answer).toContain("Vision Proxy Answer");
-    });
-    it("uses most recent image when no ID specified", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Green banner at top" } }],
-            }),
-        });
-        // Should use most recent cached image from previous tests
-        const answer = await askVisionProxy("What color is the banner?");
-        expect(answer).toContain("Vision Proxy Answer");
-    });
-});
-describe("analyzeImageFromSource", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("analyzes inline base64 images", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"C".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "A diagram showing system architecture" } }],
-            }),
-        });
-        const result = await analyzeImageFromSource(fakeBase64);
-        expect(result).toContain("diagram");
-        expect(result).toContain("Cached as");
-    });
-    it("analyzes data URIs", async () => {
-        const fakeBase64 = "A".repeat(200);
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Logo image" } }],
-            }),
-        });
-        const result = await analyzeImageFromSource(`data:image/png;base64,${fakeBase64}`);
-        expect(result).toContain("Logo");
-    });
-    it("rejects invalid source", async () => {
-        const result = await analyzeImageFromSource("not-a-file-and-not-base64");
-        expect(result).toContain("Cannot resolve image source");
-    });
-    it("focuses analysis with a question", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"D".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "The text reads: Hello World" } }],
-            }),
-        });
-        const result = await analyzeImageFromSource(fakeBase64, "What text is visible?");
-        expect(result).toContain("Hello World");
-    });
-});
-describe("getVisionGuidanceForTextOnly", () => {
-    it("returns comprehensive guidance for text-only models", () => {
-        const guidance = getVisionGuidanceForTextOnly("deepseek-v4-flash");
-        expect(guidance).toContain("analyze_image");
-        expect(guidance).toContain("ask_vision_proxy");
-        expect(guidance).toContain("list_vision_cache");
-        expect(guidance).toContain("PROACTIVE");
-        expect(guidance.length).toBeGreaterThan(200);
-    });
-    it("returns empty for vision-capable models", () => {
-        expect(getVisionGuidanceForTextOnly("claude-sonnet-4-6")).toBe("");
-    });
-});
-describe("isImageFile", () => {
-    it("detects common image extensions", () => {
-        expect(isImageFile("photo.png")).toBe(true);
-        expect(isImageFile("photo.jpg")).toBe(true);
-        expect(isImageFile("photo.jpeg")).toBe(true);
-        expect(isImageFile("icon.svg")).toBe(true);
-        expect(isImageFile("anim.gif")).toBe(true);
-        expect(isImageFile("photo.webp")).toBe(true);
-    });
-    it("rejects non-image files", () => {
-        expect(isImageFile("code.ts")).toBe(false);
-        expect(isImageFile("doc.pdf")).toBe(false);
-        expect(isImageFile("data.json")).toBe(false);
-    });
-});
-describe("scrubImagePayloadsInMessages — vision description injection", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("injects bridged vision description into AI-SDK tool-result content", async () => {
-        const fakeBase64 = `iVBORw0KGgo${"Z".repeat(600)}`;
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                choices: [{ message: { content: "Login form with email and password" } }],
-            }),
-        });
-        const toolCallId = "call_test_inject_123";
-        await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash", undefined, toolCallId);
-        // Mimic AI SDK v5 response.messages shape after scrubbing base64.
-        const aiSdkMessage = {
-            role: "tool",
-            content: [
-                {
-                    type: "tool-result",
-                    toolCallId,
-                    toolName: "mcp_playwright__browser_take_screenshot",
-                    output: {
-                        type: "content",
-                        value: [
-                            { type: "text", text: "### Result\n- [Screenshot]" },
-                            { type: "image-data", data: fakeBase64, mediaType: "image/png" },
-                        ],
-                    },
-                },
-            ],
-        };
-        const [scrubbed] = scrubImagePayloadsInMessages([aiSdkMessage]);
-        const value = scrubbed.content[0].output.value;
-        // Original image bytes gone.
-        const imgPart = value.find((p) => p.type === "image-data");
-        expect(imgPart?.data).not.toContain(fakeBase64);
-        // Vision description injected as a text part so the next turn can read it.
-        const injected = value.find((p) => p.type === "text" && p.text?.includes("Login form"));
-        expect(injected).toBeDefined();
-    });
-});
-describe("scrubImagePayloadsInMessages — non-image size cap", () => {
-    it("truncates oversized AI-SDK tool-result text content", () => {
-        // Newlines + spaces ensure the chunk doesn't match the base64-image regex,
-        // so we exercise the size cap rather than the image scrubber.
-        const huge = "  some directory entry line\n".repeat(20_000); // ~580KB
-        const msg = {
-            role: "tool",
-            content: [
-                {
-                    type: "tool-result",
-                    toolCallId: "call_huge_1",
-                    toolName: "mcp_filesystem__directory_tree",
-                    output: { type: "content", value: [{ type: "text", text: huge }] },
-                },
-            ],
-        };
-        const [scrubbed] = scrubImagePayloadsInMessages([msg]);
-        const text = scrubbed.content[0].output.value[0].text;
-        expect(text.length).toBeLessThan(huge.length);
-        expect(text).toContain("truncated by muonroi-cli");
-        expect(text).toContain("directory_tree");
-    });
-    it("truncates oversized bash string output", () => {
-        const huge = "line\n".repeat(80_000); // ~400KB
-        const msg = {
-            role: "tool",
-            content: [
-                {
-                    type: "tool-result",
-                    toolCallId: "call_huge_2",
-                    toolName: "bash",
-                    output: huge,
-                },
-            ],
-        };
-        const [scrubbed] = scrubImagePayloadsInMessages([msg]);
-        const out = scrubbed.content[0].output;
-        expect(out.length).toBeLessThan(huge.length);
-        expect(out).toContain("truncated");
-    });
-    it("leaves small tool outputs untouched", () => {
-        const small = "hello world";
-        const msg = {
-            role: "tool",
-            content: [
-                {
-                    type: "tool-result",
-                    toolCallId: "call_small",
-                    toolName: "bash",
-                    output: small,
-                },
-            ],
-        };
-        const [scrubbed] = scrubImagePayloadsInMessages([msg]);
-        expect(scrubbed.content[0].output).toBe(small);
-    });
-});
-describe("listCachedImages", () => {
-    it("returns structured list with required fields", () => {
-        const cached = listCachedImages();
-        for (const entry of cached) {
-            expect(entry).toHaveProperty("id");
-            expect(entry).toHaveProperty("source");
-            expect(entry).toHaveProperty("label");
-            expect(entry).toHaveProperty("age");
-            expect(entry).toHaveProperty("hasDescription");
-        }
-    });
-});
-//# sourceMappingURL=mcp-vision-bridge.test.js.map

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

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

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

@@ -1,37 +0,0 @@
-/**
- * Tests for src/providers/ollama.ts
- * Uses recorded JSONL fixture replayed via mocked streamText.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createMockFullStream, loadFixtureChunks } from "./__test-utils__/load-fixture.js";
-vi.mock("ai", () => ({
-    streamText: vi.fn(),
-}));
-vi.mock("ollama-ai-provider-v2", () => ({
-    createOllama: vi.fn(() => vi.fn((model) => ({ modelId: model }))),
-}));
-import { streamText } from "ai";
-import { createOllamaAdapter } from "./ollama.js";
-const mockStreamText = vi.mocked(streamText);
-describe("createOllamaAdapter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('has id "ollama"', () => {
-        const adapter = createOllamaAdapter({ model: "qwen2.5-coder:1.5b" });
-        expect(adapter.id).toBe("ollama");
-    });
-    it("streams text-delta from ollama fixture", async () => {
-        const chunks = loadFixtureChunks("ollama", "streaming");
-        mockStreamText.mockReturnValue({ fullStream: createMockFullStream(chunks) });
-        const adapter = createOllamaAdapter({ model: "qwen2.5-coder:1.5b", baseURL: "http://localhost:11434/api" });
-        const collected = [];
-        for await (const chunk of adapter.stream({ messages: [{ role: "user", content: "hi" }] })) {
-            collected.push(chunk);
-        }
-        const textChunks = collected.filter((c) => c.kind === "text-delta");
-        expect(textChunks.length).toBeGreaterThanOrEqual(3);
-        expect(collected.some((c) => c.kind === "finish")).toBe(true);
-    });
-});
-//# sourceMappingURL=ollama.test.js.map

package/dist/src/providers/openai-compatible.test.d.ts

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

package/dist/src/providers/openai-compatible.test.js

@@ -1,53 +0,0 @@
-/**
- * Tests for src/providers/openai-compatible.ts
- * Verifies DeepSeek + SiliconFlow share the OpenAI-compatible adapter.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createMockFullStream, loadFixtureChunks } from "./__test-utils__/load-fixture.js";
-vi.mock("ai", () => ({
-    streamText: vi.fn(),
-}));
-vi.mock("@ai-sdk/openai-compatible", () => ({
-    createOpenAICompatible: vi.fn(() => vi.fn((model) => ({ modelId: model }))),
-}));
-import { streamText } from "ai";
-import { createOpenAICompatibleAdapter } from "./openai-compatible.js";
-const mockStreamText = vi.mocked(streamText);
-describe("createOpenAICompatibleAdapter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('sets id to "deepseek" when configured as deepseek', () => {
-        const adapter = createOpenAICompatibleAdapter({
-            id: "deepseek",
-            model: "deepseek-v4-flash",
-            apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx",
-            baseURL: "https://api.deepseek.com/v1",
-        });
-        expect(adapter.id).toBe("deepseek");
-    });
-    it('sets id to "siliconflow" when configured as siliconflow', () => {
-        const adapter = createOpenAICompatibleAdapter({
-            id: "siliconflow",
-            model: "Qwen/Qwen2.5-Coder-32B-Instruct",
-            apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx",
-        });
-        expect(adapter.id).toBe("siliconflow");
-    });
-    it("streams text-delta events from deepseek fixture", async () => {
-        const chunks = loadFixtureChunks("deepseek", "streaming");
-        mockStreamText.mockReturnValue({ fullStream: createMockFullStream(chunks) });
-        const adapter = createOpenAICompatibleAdapter({
-            id: "deepseek",
-            model: "deepseek-v4-flash",
-            apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx",
-        });
-        const collected = [];
-        for await (const chunk of adapter.stream({ messages: [{ role: "user", content: "hi" }] })) {
-            collected.push(chunk);
-        }
-        const textChunks = collected.filter((c) => c.kind === "text-delta");
-        expect(textChunks.length).toBeGreaterThanOrEqual(3);
-    });
-});
-//# sourceMappingURL=openai-compatible.test.js.map

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

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

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

@@ -1,53 +0,0 @@
-/**
- * Tests for src/providers/openai.ts
- * Uses recorded JSONL fixtures replayed via mocked streamText.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createMockFullStream, loadFixtureChunks } from "./__test-utils__/load-fixture.js";
-// Mock ai module's streamText
-vi.mock("ai", () => ({
-    streamText: vi.fn(),
-}));
-// Mock @ai-sdk/openai
-vi.mock("@ai-sdk/openai", () => ({
-    createOpenAI: vi.fn(() => vi.fn((model) => ({ modelId: model }))),
-}));
-import { streamText } from "ai";
-import { createOpenAIAdapter } from "./openai.js";
-const mockStreamText = vi.mocked(streamText);
-describe("createOpenAIAdapter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('has id "openai"', () => {
-        const adapter = createOpenAIAdapter({ model: "gpt-4o", apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx" });
-        expect(adapter.id).toBe("openai");
-    });
-    it("streams text-delta events from streaming fixture", async () => {
-        const chunks = loadFixtureChunks("openai", "streaming");
-        mockStreamText.mockReturnValue({ fullStream: createMockFullStream(chunks) });
-        const adapter = createOpenAIAdapter({ model: "gpt-4o", apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx" });
-        const collected = [];
-        for await (const chunk of adapter.stream({ messages: [{ role: "user", content: "hi" }] })) {
-            collected.push(chunk);
-        }
-        const textChunks = collected.filter((c) => c.kind === "text-delta");
-        expect(textChunks.length).toBeGreaterThanOrEqual(3);
-        expect(collected.some((c) => c.kind === "finish")).toBe(true);
-    });
-    it("yields parallel tool-call events with distinct toolCallIds", async () => {
-        const chunks = loadFixtureChunks("openai", "parallel-tools");
-        mockStreamText.mockReturnValue({ fullStream: createMockFullStream(chunks) });
-        const adapter = createOpenAIAdapter({ model: "gpt-4o", apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx" });
-        const collected = [];
-        for await (const chunk of adapter.stream({ messages: [{ role: "user", content: "read files" }] })) {
-            collected.push(chunk);
-        }
-        const toolCalls = collected.filter((c) => c.kind === "tool-call");
-        expect(toolCalls.length).toBeGreaterThanOrEqual(2);
-        // Distinct toolCallIds
-        const ids = new Set(toolCalls.map((c) => c.toolCallId));
-        expect(ids.size).toBe(toolCalls.length);
-    });
-});
-//# sourceMappingURL=openai.test.js.map

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

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

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

@@ -1,81 +0,0 @@
-/**
- * Tests for src/providers/pricing.ts
- * Verifies lookupPricing returns correct USD/M for known (provider, model) pairs
- * and undefined for unknown models (except ollama wildcard).
- */
-import { beforeAll, describe, expect, it } from "vitest";
-import { loadCatalog } from "../models/registry.js";
-import { lookupPricing, STATIC_PRICING_FALLBACK } from "./pricing.js";
-describe("lookupPricing", () => {
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    // --- Catalog-first path ---
-    it("catalog path: deepseek-v4-flash returns pricing from catalog", () => {
-        const p = lookupPricing("deepseek", "deepseek-v4-flash");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0.27);
-        expect(p.output_per_million_usd).toBe(1.1);
-        expect(p.cached_input_per_million_usd).toBe(0.027);
-    });
-    it("catalog path: deepseek-v4-pro returns pricing from catalog with cached_input", () => {
-        const p = lookupPricing("deepseek", "deepseek-v4-pro");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0.55);
-        expect(p.output_per_million_usd).toBe(2.19);
-        expect(p.cached_input_per_million_usd).toBe(0.055);
-    });
-    it("catalog path: siliconflow model returns pricing from catalog", () => {
-        const p = lookupPricing("siliconflow", "deepseek-ai/DeepSeek-V4-Flash");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0.14);
-        expect(p.output_per_million_usd).toBe(0.28);
-    });
-    // --- Static fallback path (providers not in catalog) ---
-    it("static fallback: anthropic claude-3-5-sonnet-latest returns pricing", () => {
-        const p = lookupPricing("anthropic", "claude-3-5-sonnet-latest");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(3.0);
-        expect(p.output_per_million_usd).toBe(15.0);
-    });
-    it("static fallback: openai gpt-4o returns pricing", () => {
-        const p = lookupPricing("openai", "gpt-4o");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(2.5);
-        expect(p.output_per_million_usd).toBe(10.0);
-    });
-    it("static fallback: google gemini-2.5-flash returns pricing", () => {
-        const p = lookupPricing("google", "gemini-2.5-flash");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0.3);
-    });
-    it("static fallback: deepseek deepseek-v4-flash with cached_input rate", () => {
-        const p = lookupPricing("deepseek", "deepseek-v4-flash");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0.27);
-        expect(p.output_per_million_usd).toBe(1.1);
-        expect(p.cached_input_per_million_usd).toBe(0.027);
-    });
-    it("anthropic models surface cache_write surcharge via static fallback", () => {
-        const p = lookupPricing("anthropic", "claude-3-5-sonnet-latest");
-        expect(p?.cached_input_per_million_usd).toBeDefined();
-        expect(p?.cache_write_per_million_usd).toBeDefined();
-        expect(p.cache_write_per_million_usd).toBeGreaterThan(p.input_per_million_usd);
-    });
-    it("returns undefined for unknown provider", () => {
-        expect(lookupPricing("nonexistent", "model")).toBeUndefined();
-    });
-    it("returns undefined for unknown model on a known provider (not ollama)", () => {
-        expect(lookupPricing("anthropic", "nonexistent-model")).toBeUndefined();
-    });
-    it("returns zero pricing for any ollama model via wildcard", () => {
-        const p = lookupPricing("ollama", "any-model-here");
-        expect(p).toBeDefined();
-        expect(p.input_per_million_usd).toBe(0);
-        expect(p.output_per_million_usd).toBe(0);
-    });
-    it("STATIC_PRICING_FALLBACK map has entries for all 6 providers", () => {
-        expect(Object.keys(STATIC_PRICING_FALLBACK)).toEqual(expect.arrayContaining(["anthropic", "openai", "google", "deepseek", "siliconflow", "ollama"]));
-    });
-});
-//# sourceMappingURL=pricing.test.js.map

package/dist/src/providers/prompt-cache-key.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for computePromptCacheKey — the F1 fix for OpenAI prompt
- * cache key stability across rounds in a session.
- */
-export {};

package/dist/src/providers/prompt-cache-key.spec.js

@@ -1,24 +0,0 @@
-/**
- * Unit tests for computePromptCacheKey — the F1 fix for OpenAI prompt
- * cache key stability across rounds in a session.
- */
-import { describe, expect, it } from "vitest";
-import { computePromptCacheKey } from "./runtime.js";
-describe("computePromptCacheKey", () => {
-    it("returns a stable 32-char hex hash for a given session id", () => {
-        const a = computePromptCacheKey("sess-abc-123");
-        const b = computePromptCacheKey("sess-abc-123");
-        expect(a).toBe(b);
-        expect(a).toMatch(/^[a-f0-9]{32}$/);
-    });
-    it("produces different keys for different session ids", () => {
-        const a = computePromptCacheKey("sess-aaa");
-        const b = computePromptCacheKey("sess-bbb");
-        expect(a).not.toBe(b);
-    });
-    it("returns undefined when no session id is provided", () => {
-        expect(computePromptCacheKey(undefined)).toBeUndefined();
-        expect(computePromptCacheKey("")).toBeUndefined();
-    });
-});
-//# sourceMappingURL=prompt-cache-key.spec.js.map

package/dist/src/providers/runtime-mock.spec.d.ts

@@ -1,8 +0,0 @@
-/**
- * Verifies the H1 mock-model hook in resolveModelRuntime: when
- * `globalThis.__muonroiMockModel` is set, the resolved runtime returns the
- * mock model and the test-supplied unsupportedParams/defaultProviderOptions
- * overrides flow through to ResolvedModelRuntime exactly as the real factory
- * path would surface them.
- */
-export {};