muonroi-cli 1.8.1 → 1.8.4

package/dist/src/mcp/__tests__/runtime-output-cap.test.js

@@ -1,42 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { MAX_TOOL_OUTPUT_CHARS } from "../../tools/registry.js";
-vi.mock("@modelcontextprotocol/sdk/client/stdio.js", () => ({
-    StdioClientTransport: vi.fn(function (opts) {
-        Object.assign(this, opts);
-    }),
-    getDefaultEnvironment: () => ({}),
-}));
-// MCP client returns a single tool whose execute emits an over-cap payload.
-const huge = "X".repeat(MAX_TOOL_OUTPUT_CHARS + 50_000);
-vi.mock("@ai-sdk/mcp", () => ({
-    createMCPClient: vi.fn(async () => ({
-        tools: async () => ({
-            big_query: {
-                description: "returns a huge blob",
-                inputSchema: { type: "object", properties: {} },
-                execute: async () => ({ type: "content", value: [{ type: "text", text: huge }] }),
-            },
-        }),
-        close: async () => { },
-    })),
-}));
-vi.mock("../validate.js", () => ({
-    validateMcpServerConfig: () => ({ ok: true }),
-}));
-import { buildMcpToolSet } from "../runtime.js";
-describe("buildMcpToolSet — MCP output is capped", () => {
-    beforeEach(() => vi.clearAllMocks());
-    it("truncates an over-cap MCP tool result through the wrapped execute", async () => {
-        const bundle = await buildMcpToolSet([
-            { id: "demo", label: "Demo", enabled: true, transport: "stdio", command: "x", args: [] },
-        ]);
-        const tool = bundle.tools.mcp_demo__big_query;
-        expect(tool).toBeDefined();
-        const out = await tool.execute({}, {});
-        const text = out.value[0].text;
-        expect(text.length).toBeLessThan(huge.length);
-        expect(text).toContain("truncated");
-        await bundle.close();
-    });
-});
-//# sourceMappingURL=runtime-output-cap.test.js.map

package/dist/src/mcp/__tests__/runtime-sanitize.test.d.ts

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

package/dist/src/mcp/__tests__/runtime-sanitize.test.js

@@ -1,40 +0,0 @@
-/**
- * Verifies the LLM-facing MCP tool name is sanitized against the OpenAI /
- * DeepSeek function-name regex `^[a-zA-Z0-9_-]+$`. Tool names emitted by some
- * MCP servers (e.g. muonroi-docs `docs.search`, bb.template.describe) contain
- * dots that the providers reject with HTTP 400.
- *
- * We can't easily spin up a real MCP server inside a unit test, so we assert
- * the regex itself matches the same characters runtime.ts rewrites. Smoke /
- * integration coverage of the spawn path lives in smoke.test.ts.
- */
-import { describe, expect, it } from "vitest";
-const FN_NAME_RE = /^[a-zA-Z0-9_-]+$/;
-function sanitize(name) {
-    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-describe("MCP tool name sanitization", () => {
-    it.each([
-        "docs.search",
-        "docs.read",
-        "bb.template.describe",
-        "bb.package.describe",
-        "bb.recipe.list",
-        "ns/with/slash",
-        "weird name with spaces",
-        "v1:colon:tool",
-    ])("rewrites %s to a function-name-safe string", (raw) => {
-        const safe = sanitize(raw);
-        expect(safe).toMatch(FN_NAME_RE);
-    });
-    it("leaves already-safe names unchanged", () => {
-        for (const safe of ["echo", "browser_take_screenshot", "search-files", "read_text_file"]) {
-            expect(sanitize(safe)).toBe(safe);
-        }
-    });
-    it("produces the expected prefixed form for muonroi-docs docs.search", () => {
-        const prefix = `mcp_${"muonroi-docs".replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-        expect(`${prefix}__${sanitize("docs.search")}`).toBe("mcp_muonroi-docs__docs_search");
-    });
-});
-//# sourceMappingURL=runtime-sanitize.test.js.map

package/dist/src/mcp/__tests__/self-verify-jobs.test.d.ts

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

package/dist/src/mcp/__tests__/self-verify-jobs.test.js

@@ -1,92 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { JobManager } from "../self-verify-jobs.js";
-// A controllable stub runner: tier1 resolves/rejects on demand.
-function deferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
-function makeRunner(opts) {
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        tier1: (_o, log) => {
-            log("tier1 started");
-            return (opts.tier1?.() ?? Promise.resolve({ summary: { passed: 1 } }));
-        },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        agentic: (_o, log) => {
-            log("agentic started");
-            return (opts.agentic?.() ?? Promise.resolve({ verdict: "pass" }));
-        },
-    };
-}
-describe("JobManager", () => {
-    it("start returns a runId and job is initially running", () => {
-        const jm = new JobManager(makeRunner({ tier1: () => deferred().promise }));
-        const runId = jm.start({ kind: "tier1" });
-        expect(typeof runId).toBe("string");
-        expect(jm.status(runId)?.status).toBe("running");
-    });
-    it("transitions to done and stores the report", async () => {
-        const d = deferred();
-        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
-        const runId = jm.start({ kind: "tier1" });
-        d.resolve({ summary: { passed: 2 } });
-        await d.promise;
-        await Promise.resolve(); // let the .then microtask run
-        const job = jm.status(runId);
-        expect(job.status).toBe("done");
-        expect(job.report).toEqual({ summary: { passed: 2 } });
-        expect(job.finishedAt).toBeGreaterThan(0);
-    });
-    it("transitions to error on rejection", async () => {
-        const d = deferred();
-        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
-        const runId = jm.start({ kind: "tier1" });
-        d.reject(new Error("boom"));
-        await d.promise.catch(() => { });
-        await Promise.resolve();
-        const job = jm.status(runId);
-        expect(job.status).toBe("error");
-        expect(job.error).toBe("boom");
-    });
-    it("cancel marks a running job cancelled and discards a late result", async () => {
-        const d = deferred();
-        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
-        const runId = jm.start({ kind: "tier1" });
-        expect(jm.cancel(runId)).toBe(true);
-        expect(jm.status(runId)?.status).toBe("cancelled");
-        d.resolve({ summary: { passed: 9 } });
-        await d.promise;
-        await Promise.resolve();
-        expect(jm.status(runId)?.status).toBe("cancelled"); // late resolve ignored
-    });
-    it("captures log lines from the runner", async () => {
-        const jm = new JobManager(makeRunner({}));
-        const runId = jm.start({ kind: "tier1" });
-        await Promise.resolve();
-        expect(jm.status(runId)?.logBuffer).toContain("tier1 started");
-    });
-    it("evicts oldest jobs beyond the cap of 20", () => {
-        const jm = new JobManager(makeRunner({ tier1: () => new Promise(() => { }) }));
-        const ids = [];
-        for (let i = 0; i < 25; i++)
-            ids.push(jm.start({ kind: "tier1" }));
-        expect(jm.list().length).toBe(20);
-        expect(jm.status(ids[0])).toBeUndefined(); // oldest evicted
-        expect(jm.status(ids[24])).toBeDefined();
-    });
-    it("cancel returns false for a non-running job", async () => {
-        const d = deferred();
-        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
-        const runId = jm.start({ kind: "tier1" });
-        expect(jm.cancel(runId)).toBe(true); // first cancel succeeds
-        expect(jm.cancel(runId)).toBe(false); // second cancel: not running
-        expect(jm.cancel("nonexistent")).toBe(false);
-    });
-});
-//# sourceMappingURL=self-verify-jobs.test.js.map

package/dist/src/mcp/__tests__/smart-filter.test.d.ts

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

package/dist/src/mcp/__tests__/smart-filter.test.js

@@ -1,177 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { dropRedundantFsMcpTools, filterMcpServersByMessage } from "../smart-filter.js";
-// Minimal shape — the real McpServerConfig has more fields, but the filter only
-// reads `.id`. Using a structural stub keeps the test independent of config.
-const servers = [
-    { id: "filesystem" },
-    { id: "muonroi-tools" },
-    { id: "muonroi-harness" },
-    { id: "muonroi-docs" },
-    { id: "context7" },
-    { id: "fetch" },
-    { id: "tavily" },
-    { id: "chrome-devtools" },
-    { id: "playwright" },
-    { id: "figma" },
-];
-const ids = (s) => s.map((x) => x.id);
-describe("filterMcpServersByMessage", () => {
-    it("drops browser AND docs/web servers when the message signals neither", () => {
-        // A pure code prompt with no docs/web/browser vocabulary should not pay for
-        // context7/fetch (docs/web lookup) or chrome/playwright/figma (browser).
-        const out = filterMcpServersByMessage(servers, "fix the auth bug in src/auth/login.ts");
-        expect(ids(out)).toEqual(["filesystem", "muonroi-tools", "muonroi-harness"]);
-    });
-    it("keeps browser servers when a browser signal is present", () => {
-        const out = filterMcpServersByMessage(servers, "take a screenshot of the dashboard");
-        expect(ids(out)).toContain("chrome-devtools");
-        expect(ids(out)).toContain("playwright");
-        expect(ids(out)).toContain("figma");
-    });
-    it("keeps docs/web servers when a docs signal is present", () => {
-        const out = filterMcpServersByMessage(servers, "how do I use the zod library API?");
-        expect(ids(out)).toContain("context7");
-        expect(ids(out)).toContain("fetch");
-        // web-search server is also an external-lookup server → kept on a docs signal.
-        expect(ids(out)).toContain("tavily");
-    });
-    it("drops the web-search server on a pure code prompt (no external-info signal)", () => {
-        const out = filterMcpServersByMessage(servers, "fix the auth bug in src/auth/login.ts");
-        expect(ids(out)).not.toContain("tavily");
-    });
-    it("keeps the web-search server on web-search intent (low-collision terms)", () => {
-        for (const msg of [
-            "search the web for the release date",
-            "look up the latest news on this",
-            "what's the weather today",
-            "find this online",
-            "check the internet for outages",
-        ]) {
-            const out = filterMcpServersByMessage(servers, msg);
-            expect(ids(out), msg).toContain("tavily");
-        }
-    });
-    it("keeps both browser and docs servers when the message has a URL", () => {
-        const out = filterMcpServersByMessage(servers, "summarize https://example.com/article");
-        expect(ids(out)).toContain("context7");
-        expect(ids(out)).toContain("fetch");
-        expect(ids(out)).toContain("chrome-devtools");
-    });
-    it("NEVER drops non-optional domain servers (filesystem / tools / harness)", () => {
-        const out = filterMcpServersByMessage(servers, "Reply with exactly one word: PONG");
-        expect(ids(out)).toContain("filesystem");
-        expect(ids(out)).toContain("muonroi-tools");
-        expect(ids(out)).toContain("muonroi-harness");
-    });
-    it("keeps muonroi-docs for an ecosystem question that has no generic docs keyword", () => {
-        // Live miss (session dbe408937a3d turn 1): "bạn hiểu thế nào về hệ sinh thái
-        // muonroi" carries no docs/api keyword and doesn't say "muonroi-docs", so the
-        // authoritative ecosystem source was dropped and the agent guessed from files.
-        for (const msg of [
-            "bạn hiểu thế nào về hệ sinh thái muonroi",
-            "what is the muonroi ecosystem?",
-            "explain the building-block rule engine",
-        ]) {
-            const out = filterMcpServersByMessage(servers, msg);
-            expect(ids(out), msg).toContain("muonroi-docs");
-        }
-    });
-    it("keeping muonroi-docs for an ecosystem question does NOT over-keep other docs/web servers", () => {
-        const out = filterMcpServersByMessage(servers, "bạn hiểu thế nào về hệ sinh thái muonroi");
-        expect(ids(out)).toContain("muonroi-docs");
-        expect(ids(out)).not.toContain("context7");
-        expect(ids(out)).not.toContain("fetch");
-        expect(ids(out)).not.toContain("tavily");
-    });
-    it("returns every server unchanged when disabled (MUONROI_DISABLE_SMART_MCP=1)", () => {
-        const out = filterMcpServersByMessage(servers, "Reply PONG", { disabled: true });
-        expect(ids(out)).toEqual(ids(servers));
-    });
-    it("preserves the existing browser-gate vocabulary exactly", () => {
-        // Regression guard: each token that the original inline regex recognised
-        // must still keep browser servers.
-        for (const word of ["browser", "playwright", "chrome", "figma", "canva", "render", "navigate", "click", "scrape"]) {
-            const out = filterMcpServersByMessage(servers, `please ${word} something`);
-            expect(ids(out)).toContain("chrome-devtools");
-        }
-    });
-    // Regression: session f6f7881a5fae. The user asked "bạn thử call tool
-    // setup_guide ... ( call tool chứ không phải đọc code )". `muonroi-docs` (id
-    // matches /docs/) carried no docs-lookup keyword, so the category skip dropped
-    // it — the model had no `setup_guide` tool and drove the server by hand over
-    // bash JSON-RPC. An explicit tool-invocation intent (or an outright server
-    // mention) must keep the owning server.
-    const docsServers = [{ id: "filesystem" }, { id: "muonroi-docs" }, { id: "context7" }, { id: "tavily" }];
-    it("keeps an optional server when the user explicitly asks to CALL a tool by name", () => {
-        const msg = "bạn thử call tool setup_guide xem có được thông tin gì không nhé ( call tool chứ không phải đọc code nhé )";
-        expect(ids(filterMcpServersByMessage(docsServers, msg))).toContain("muonroi-docs");
-    });
-    it("recognises explicit tool-invocation intent (EN + VI)", () => {
-        for (const msg of [
-            "please call the setup_guide tool and report",
-            "use the docs_search tool",
-            "invoke the mcp tool",
-            "do a tool call to setup_guide",
-            "dùng tool docs_search giúp tôi",
-            "gọi tool setup_guide",
-            "thử mcp tool xem sao",
-        ]) {
-            expect(ids(filterMcpServersByMessage(docsServers, msg)), msg).toContain("muonroi-docs");
-        }
-    });
-    it("keeps a server named outright in the message even without a category signal", () => {
-        // "check the muonroi-docs MCP" — no docs-lookup verb, but the server is named.
-        const out = filterMcpServersByMessage(docsServers, "bạn check xem dùng được mcp muonroi-docs không nhé");
-        expect(ids(out)).toContain("muonroi-docs");
-    });
-    it("still drops optional servers on a pure code prompt (token savings preserved)", () => {
-        // The fix must NOT defeat the filter: no tool-intent, no server mention, no
-        // docs signal → muonroi-docs/context7/tavily still dropped.
-        const out = filterMcpServersByMessage(docsServers, "fix the off-by-one in parseRange()");
-        expect(ids(out)).toEqual(["filesystem"]);
-    });
-});
-describe("dropRedundantFsMcpTools", () => {
-    const fn = () => ({});
-    afterEach(() => {
-        delete process.env.MUONROI_KEEP_REDUNDANT_FS_MCP;
-    });
-    it("drops filesystem-MCP read/write/edit tools when the builtin equivalent is present", () => {
-        // Live waste (grok session f5dfab0ce0ca): files re-read via both read_file
-        // and mcp_filesystem__read_text_file.
-        const mcp = {
-            mcp_filesystem__read_text_file: fn,
-            mcp_filesystem__read_file: fn,
-            mcp_filesystem__read_multiple_files: fn,
-            mcp_filesystem__write_file: fn,
-            mcp_filesystem__edit_file: fn,
-            mcp_filesystem__directory_tree: fn, // NOT a builtin dup — keep
-            mcp_filesystem__search_files: fn, // keep
-            mcp_other__read_text_file: fn, // different server — keep
-        };
-        const builtins = new Set(["read_file", "write_file", "edit_file", "bash", "grep", "glob"]);
-        const { tools, dropped } = dropRedundantFsMcpTools(mcp, builtins);
-        expect(dropped.sort()).toEqual([
-            "mcp_filesystem__edit_file",
-            "mcp_filesystem__read_file",
-            "mcp_filesystem__read_multiple_files",
-            "mcp_filesystem__read_text_file",
-            "mcp_filesystem__write_file",
-        ].sort());
-        expect(Object.keys(tools).sort()).toEqual(["mcp_filesystem__directory_tree", "mcp_filesystem__search_files", "mcp_other__read_text_file"].sort());
-    });
-    it("keeps the MCP tool when the builtin equivalent is NOT present (no silent capability loss)", () => {
-        const mcp = { mcp_filesystem__read_text_file: fn };
-        const { tools, dropped } = dropRedundantFsMcpTools(mcp, new Set(["bash"])); // no builtin read_file
-        expect(dropped).toEqual([]);
-        expect(Object.keys(tools)).toEqual(["mcp_filesystem__read_text_file"]);
-    });
-    it("respects MUONROI_KEEP_REDUNDANT_FS_MCP=1 override", () => {
-        process.env.MUONROI_KEEP_REDUNDANT_FS_MCP = "1";
-        const mcp = { mcp_filesystem__read_text_file: fn };
-        const { tools, dropped } = dropRedundantFsMcpTools(mcp, new Set(["read_file"]));
-        expect(dropped).toEqual([]);
-        expect(Object.keys(tools)).toEqual(["mcp_filesystem__read_text_file"]);
-    });
-});
-//# sourceMappingURL=smart-filter.test.js.map

package/dist/src/mcp/__tests__/tools-server.smoke.test.d.ts

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

package/dist/src/mcp/__tests__/tools-server.smoke.test.js

@@ -1,42 +0,0 @@
-/**
- * tools-server.smoke.test.ts
- *
- * Windows note: unlike src/mcp/smoke.test.ts (which skips its stdio handshake on
- * Windows+Bun citing StdioClientTransport closing stdin immediately), this test runs
- * fully on Windows with the current MCP SDK. Verified stable across 3 consecutive
- * native Windows runs (all passed, ~12-22s each). No platform guard needed here.
- * If this test starts hanging on a future SDK upgrade, add:
- *   describe.skipIf(process.platform === "win32" || !!process.env.CI)(...)
- * matching the precedent in the older smoke.test.ts.
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { describe, expect, it } from "vitest";
-describe("tools-mcp server smoke", () => {
-    it("advertises the selfverify_* tools over stdio", async () => {
-        const transport = new StdioClientTransport({
-            command: "bun",
-            args: ["run", "src/index.ts", "tools-mcp"],
-        });
-        const client = new Client({ name: "smoke-test", version: "0" }, { capabilities: {} });
-        await client.connect(transport);
-        try {
-            const { tools } = await client.listTools();
-            const names = tools.map((t) => t.name);
-            expect(names).toContain("selfverify_start");
-            expect(names).toContain("selfverify_status");
-            expect(names).toContain("selfverify_result");
-            expect(names).toContain("selfverify_list");
-            expect(names).toContain("selfverify_cancel");
-            expect(names).toContain("ee_query");
-            expect(names).toContain("ee_feedback");
-            expect(names).toContain("ee_health");
-            expect(names).toContain("usage_forensics");
-            expect(names).toContain("lsp_query");
-        }
-        finally {
-            await client.close();
-        }
-    }, 60_000);
-});
-//# sourceMappingURL=tools-server.smoke.test.js.map

package/dist/src/mcp/parse-headers.test.d.ts

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

package/dist/src/mcp/parse-headers.test.js

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseEnvLines, parseHeaderLines } from "./parse-headers.js";
-describe("parseHeaderLines", () => {
-    it("parses colon-separated headers and trims whitespace", () => {
-        expect(parseHeaderLines(`
-        Authorization: Bearer token
-        X-Trace-Id:  abc123
-      `)).toEqual({
-            Authorization: "Bearer token",
-            "X-Trace-Id": "abc123",
-        });
-    });
-    it("ignores blank and malformed lines while preserving later colons in values", () => {
-        expect(parseHeaderLines(`
-        invalid
-        : missing-name
-        Host: example.com:443
-      `)).toEqual({
-            Host: "example.com:443",
-        });
-    });
-});
-describe("parseEnvLines", () => {
-    it("parses equals-separated env assignments and trims whitespace", () => {
-        expect(parseEnvLines(`
-        API_KEY = secret
-        MODE= production
-      `)).toEqual({
-            API_KEY: "secret",
-            MODE: "production",
-        });
-    });
-    it("ignores blank and malformed lines while preserving later equals in values", () => {
-        expect(parseEnvLines(`
-        missing
-        = no-name
-        URL=https://example.com?a=b
-      `)).toEqual({
-            URL: "https://example.com?a=b",
-        });
-    });
-});
-//# sourceMappingURL=parse-headers.test.js.map

package/dist/src/mcp/smoke.test.d.ts

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

package/dist/src/mcp/smoke.test.js

@@ -1,159 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { buildMcpToolSet } from "./runtime.js";
-/**
- * MCP smoke tests — unit-level coverage for buildMcpToolSet.
- *
- * Note: Full stdio stub integration was attempted but StdioClientTransport from
- * @modelcontextprotocol/sdk closes stdin immediately on Windows+Bun, preventing
- * real server handshake. Tests cover all code paths reachable without a live
- * transport connection (empty list, disabled servers, validation failures).
- *
- * The stdio handshake test (discovers tools from stdio MCP echo stub) runs on
- * Linux/macOS only — it is skipped on Windows where StdioClientTransport hangs on Bun.
- */
-describe("MCP smoke test — buildMcpToolSet", () => {
-    it("returns empty tools and no errors for empty server list", async () => {
-        const bundle = await buildMcpToolSet([]);
-        expect(bundle.errors).toHaveLength(0);
-        expect(Object.keys(bundle.tools)).toHaveLength(0);
-        await bundle.close();
-    });
-    it("skips disabled servers without errors", async () => {
-        const bundle = await buildMcpToolSet([
-            {
-                id: "disabled-server",
-                label: "disabled-server",
-                enabled: false,
-                transport: "stdio",
-                command: "node",
-                args: ["--version"],
-            },
-        ]);
-        // Disabled server should be skipped — no errors, no tools
-        expect(bundle.errors).toHaveLength(0);
-        expect(Object.keys(bundle.tools)).toHaveLength(0);
-        await bundle.close();
-    });
-    it("reports validation error for stdio server without command", async () => {
-        const bundle = await buildMcpToolSet([
-            {
-                id: "bad-stdio",
-                label: "bad-stdio",
-                enabled: true,
-                transport: "stdio",
-                command: "",
-                args: [],
-            },
-        ]);
-        // Should have a validation error, not throw
-        expect(bundle.errors.length).toBeGreaterThan(0);
-        expect(bundle.errors[0]).toContain("bad-stdio");
-        await bundle.close();
-    });
-    it("reports validation error for http server without url", async () => {
-        const bundle = await buildMcpToolSet([
-            {
-                id: "bad-http",
-                label: "bad-http",
-                enabled: true,
-                transport: "sse",
-                url: "",
-            },
-        ]);
-        expect(bundle.errors.length).toBeGreaterThan(0);
-        expect(bundle.errors[0]).toContain("bad-http");
-        await bundle.close();
-    });
-    it("buildMcpToolSet signature contract — accepts McpServerConfig[] and returns McpToolBundle shape", () => {
-        // Structural type check: buildMcpToolSet must be a function accepting server configs
-        // and returning a promise of { tools, errors, close }.
-        // This verifies the public API without spawning a subprocess.
-        expect(typeof buildMcpToolSet).toBe("function");
-        // The function must return a promise
-        const result = buildMcpToolSet([]);
-        expect(result).toBeInstanceOf(Promise);
-        // Resolve the promise and verify shape
-        return result.then((bundle) => {
-            expect(bundle).toHaveProperty("tools");
-            expect(bundle).toHaveProperty("errors");
-            expect(typeof bundle.close).toBe("function");
-            return bundle.close();
-        });
-    });
-    it.skipIf(process.platform === "win32" || !!process.env.CI)("discovers tools from stdio MCP echo stub", async () => {
-        // Inline MCP echo server script — handles initialize, notifications/initialized,
-        // and tools/list using Content-Length framing per the MCP JSON-RPC spec.
-        const echoServerScript = `
-const { stdin, stdout } = require('process');
-let buf = '';
-stdin.setEncoding('utf8');
-stdin.on('data', (chunk) => {
-  buf += chunk;
-  while (true) {
-    const headerEnd = buf.indexOf('\\r\\n\\r\\n');
-    if (headerEnd === -1) break;
-    const header = buf.slice(0, headerEnd);
-    const match = header.match(/Content-Length:\\s*(\\d+)/i);
-    if (!match) { buf = buf.slice(headerEnd + 4); continue; }
-    const len = parseInt(match[1], 10);
-    const bodyStart = headerEnd + 4;
-    if (buf.length < bodyStart + len) break;
-    const body = buf.slice(bodyStart, bodyStart + len);
-    buf = buf.slice(bodyStart + len);
-    handleMessage(JSON.parse(body));
-  }
-});
-function send(obj) {
-  const s = JSON.stringify(obj);
-  stdout.write('Content-Length: ' + Buffer.byteLength(s) + '\\r\\n\\r\\n' + s);
-}
-function handleMessage(msg) {
-  if (msg.method === 'initialize') {
-    send({ jsonrpc: '2.0', id: msg.id, result: {
-      protocolVersion: '2024-11-05',
-      capabilities: { tools: { listChanged: false } },
-      serverInfo: { name: 'echo-stub', version: '1.0.0' }
-    }});
-  } else if (msg.method === 'notifications/initialized') {
-    // no response needed
-  } else if (msg.method === 'tools/list') {
-    send({ jsonrpc: '2.0', id: msg.id, result: {
-      tools: [{
-        name: 'echo',
-        description: 'Echoes input',
-        inputSchema: { type: 'object', properties: { message: { type: 'string' } }, required: ['message'] }
-      }]
-    }});
-  }
-}
-`;
-        const tmpDir = await mkdtemp(join(tmpdir(), "mcp-echo-stub-"));
-        const scriptPath = join(tmpDir, "echo-server.js");
-        let bundle;
-        try {
-            await writeFile(scriptPath, echoServerScript, "utf8");
-            bundle = await buildMcpToolSet([
-                {
-                    id: "test_echo",
-                    label: "test_echo",
-                    enabled: true,
-                    transport: "stdio",
-                    command: "node",
-                    args: [scriptPath],
-                },
-            ]);
-            expect(bundle.errors).toHaveLength(0);
-            expect(Object.keys(bundle.tools).length).toBeGreaterThanOrEqual(1);
-            expect(Object.keys(bundle.tools)).toContain("mcp_test_echo__echo");
-        }
-        finally {
-            if (bundle)
-                await bundle.close();
-            await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        }
-    }, 15000);
-});
-//# sourceMappingURL=smoke.test.js.map

package/dist/src/models/__tests__/registry.test.d.ts

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