muonroi-cli 1.4.0 → 1.4.1

package/src/mcp/runtime.ts

@@ -1,182 +0,0 @@
-import { createMCPClient, type MCPClient } from "@ai-sdk/mcp";
-import { jsonSchema } from "@ai-sdk/provider-utils";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { ToolSet } from "ai";
-import type { McpServerConfig } from "../utils/settings.js";
-import { capMcpToolResult } from "./cap-tool-result.js";
-import { getMcpKey, type McpKeyId } from "./mcp-keychain.js";
-import { createOAuthProviderWithCallback } from "./oauth-provider.js";
-import { validateMcpServerConfig } from "./validate.js";
-
-// Map MCP server id → keychain id + env var name for env hydration at spawn.
-// When a server's env value is empty/missing, we look up the key from the
-// OS keychain (or its env-var fallback) and inject it into the spawned process.
-const MCP_ENV_HYDRATION: Record<string, { keyId: McpKeyId; envVar: string }> = {
-  tavily: { keyId: "tavily", envVar: "TAVILY_API_KEY" },
-};
-
-async function hydrateServerEnv(server: McpServerConfig): Promise<McpServerConfig> {
-  const hydration = MCP_ENV_HYDRATION[server.id];
-  if (!hydration) return server;
-  const existing = server.env?.[hydration.envVar];
-  if (existing && existing.length > 0) return server;
-  const key = await getMcpKey(hydration.keyId);
-  if (!key) return server;
-  return { ...server, env: { ...(server.env ?? {}), [hydration.envVar]: key } };
-}
-
-function mcpToolPrefix(server: McpServerConfig): string {
-  return `mcp_${server.id.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-}
-
-// Phase M1 — lazy schema loading.
-//
-// The AI SDK's MCP client returns tools whose `inputSchema` carries the full
-// JSON Schema advertised by the MCP server. That schema is serialized into the
-// provider tool definition for EVERY `streamText` call, regardless of which
-// MCP tools the model actually invokes. With 5+ servers × 20+ tools × 1-5 KB
-// per schema, this trivially adds 100-500 KB of overhead to every model call.
-//
-// The fix: ship a minimal placeholder schema (`{ type: "object",
-// additionalProperties: true }`) to the model, and let the real MCP server
-// validate args downstream when the tool is actually called. The model
-// continues to know the tool's name + description so it can decide when to
-// call; the real schema only matters at execution time, which the MCP server
-// already enforces.
-//
-// Args validation: the AI SDK's `dynamicTool` factory only runs `validate()`
-// when present on the schema, and the MCP client never sets it (see
-// `jsonSchema(...)` in @ai-sdk/provider-utils — no `validate` arg). So this
-// change preserves the existing validation surface exactly (none on our side;
-// all enforced by the MCP server).
-// OpenAI Responses API rejects object schemas without a `properties` field
-// (HTTP 400 invalid_function_parameters). Anthropic/DeepSeek don't enforce
-// this. Always emit `properties: {}` alongside `additionalProperties: true`
-// so the schema is portable across providers.
-const LAZY_MCP_INPUT_SCHEMA = {
-  type: "object" as const,
-  properties: {} as Record<string, unknown>,
-  additionalProperties: true,
-};
-
-function stripMcpInputSchema<T extends { inputSchema?: unknown; description?: string }>(tool: T): T {
-  // Replace the full schema with a permissive placeholder. We keep `description`
-  // and `execute` (and any other fields) intact. Many MCP tools also have an
-  // `outputSchema`; we leave that alone since the AI SDK uses it only to parse
-  // structured tool results — it doesn't ship to the model.
-  return {
-    ...tool,
-    inputSchema: jsonSchema(LAZY_MCP_INPUT_SCHEMA),
-  };
-}
-
-function toTransport(server: McpServerConfig, authProvider?: OAuthClientProvider) {
-  if (server.transport === "stdio") {
-    return new StdioClientTransport({
-      command: server.command ?? "",
-      args: server.args,
-      env: server.env ? { ...getDefaultEnvironment(), ...server.env } : undefined,
-      cwd: server.cwd,
-      stderr: "pipe",
-    });
-  }
-
-  return {
-    type: server.transport,
-    url: server.url ?? "",
-    headers: server.headers,
-    ...(authProvider ? { authProvider: authProvider as any } : {}),
-  } as const;
-}
-
-export interface McpToolBundle {
-  tools: ToolSet;
-  errors: string[];
-  close(): Promise<void>;
-}
-
-export interface McpBuildOptions {
-  onOAuthRequired?: (serverId: string, url: URL) => void;
-}
-
-export async function buildMcpToolSet(servers: McpServerConfig[], opts?: McpBuildOptions): Promise<McpToolBundle> {
-  const tools: ToolSet = {};
-  const errors: string[] = [];
-  const clients: MCPClient[] = [];
-  const cleanups: (() => void)[] = [];
-
-  for (const rawServer of servers) {
-    if (!rawServer.enabled) continue;
-
-    const validation = validateMcpServerConfig(rawServer);
-    if (!validation.ok) {
-      errors.push(`${rawServer.label}: ${validation.error}`);
-      continue;
-    }
-
-    try {
-      // Hydrate env vars from the OS keychain before spawning — e.g. inject
-      // TAVILY_API_KEY for the tavily MCP if the user stored it via the
-      // research-onboarding wizard.
-      const server = await hydrateServerEnv(rawServer);
-
-      let authProvider: OAuthClientProvider | undefined;
-
-      if (server.transport !== "stdio" && opts?.onOAuthRequired) {
-        const oauthResult = await createOAuthProviderWithCallback({
-          serverId: server.id,
-          onAuthorizationUrl: (url: URL) => opts.onOAuthRequired!(server.id, url),
-        });
-        authProvider = oauthResult.provider;
-        cleanups.push(oauthResult.close);
-      }
-
-      const client = await createMCPClient({
-        transport: toTransport(server, authProvider),
-        name: `muonroi-cli-${server.id}`,
-        version: "1.0.0",
-      });
-      clients.push(client);
-
-      const mcpTools = await client.tools();
-      const prefix = mcpToolPrefix(server);
-
-      for (const [name, tool] of Object.entries(mcpTools)) {
-        // OpenAI/DeepSeek function-name regex: ^[a-zA-Z0-9_-]+$. MCP spec
-        // does not restrict server-side tool names, so we sanitize here.
-        // The tool's execute() closure still calls the MCP server with the
-        // original name — we only rename what the LLM sees.
-        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const prefixedName = `${prefix}__${safeName}`;
-        const stripped = stripMcpInputSchema(tool as { inputSchema?: unknown; description?: string });
-        // Cap MCP tool output the same way built-in tools are capped
-        // (`truncateOutput` / MAX_TOOL_OUTPUT_CHARS). Without this wrap the raw
-        // server payload streams into the model context uncapped — a cost leak
-        // that hits cheap models hardest. See cap-tool-result.ts.
-        const baseExecute = (stripped as { execute?: (args: unknown, options: unknown) => Promise<unknown> }).execute;
-        tools[prefixedName] = {
-          ...(stripped as object),
-          description: `[MCP ${server.label}] ${tool.description ?? name}`,
-          ...(typeof baseExecute === "function"
-            ? {
-                execute: async (args: unknown, options: unknown) => capMcpToolResult(await baseExecute(args, options)),
-              }
-            : {}),
-        } as ToolSet[string];
-      }
-    } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push(`${rawServer.label}: ${message}`);
-    }
-  }
-
-  return {
-    tools,
-    errors,
-    async close() {
-      for (const fn of cleanups) fn();
-      await Promise.all(clients.map((client) => client.close().catch(() => {})));
-    },
-  };
-}

package/src/mcp/self-verify-jobs.ts

@@ -1,137 +0,0 @@
-/**
- * src/mcp/self-verify-jobs.ts
- *
- * In-process job tracker for self-verify runs exposed over MCP.
- * Pure module: the actual self-verify execution is injected via the Runner
- * interface so unit tests never spawn a real TUI.
- */
-
-import { randomUUID } from "node:crypto";
-import type { AgenticReport } from "../self-qa/agentic-loop.js";
-import type { SelfVerifyReport } from "../self-qa/index.js";
-
-export type JobKind = "tier1" | "agentic";
-export type JobStatus = "running" | "done" | "error" | "cancelled";
-
-export interface StartTier1Opts {
-  kind: "tier1";
-  since?: string;
-  max?: number;
-  emit?: boolean;
-  out?: string;
-}
-
-export interface StartAgenticOpts {
-  kind: "agentic";
-  goal: string;
-  llm: string;
-  turns?: number;
-}
-
-export type StartOpts = StartTier1Opts | StartAgenticOpts;
-
-export interface Job {
-  runId: string;
-  kind: JobKind;
-  status: JobStatus;
-  startedAt: number;
-  finishedAt?: number;
-  logBuffer: string[];
-  report?: SelfVerifyReport | AgenticReport;
-  error?: string;
-}
-
-/**
- * Execution backend. The default implementation (in tools-server.ts) calls
- * runSelfVerify / runAgenticLoop. `signal` is best-effort — the underlying
- * self-verify functions may ignore it; cancellation discards any late result.
- */
-export interface Runner {
-  tier1(opts: StartTier1Opts, log: (m: string) => void, signal: AbortSignal): Promise<SelfVerifyReport>;
-  agentic(opts: StartAgenticOpts, log: (m: string) => void, signal: AbortSignal): Promise<AgenticReport>;
-}
-
-const LOG_CAP = 2000;
-const JOB_CAP = 20;
-
-export class JobManager {
-  private jobs = new Map<string, Job>();
-  private controllers = new Map<string, AbortController>();
-
-  constructor(private readonly runner: Runner) {}
-
-  start(opts: StartOpts): string {
-    const runId = randomUUID();
-    const ctrl = new AbortController();
-    const job: Job = {
-      runId,
-      kind: opts.kind,
-      status: "running",
-      startedAt: Date.now(),
-      logBuffer: [],
-    };
-    this.jobs.set(runId, job);
-    this.controllers.set(runId, ctrl);
-    this.evict();
-
-    const log = (m: string) => {
-      job.logBuffer.push(m);
-      if (job.logBuffer.length > LOG_CAP) {
-        job.logBuffer.splice(0, job.logBuffer.length - LOG_CAP);
-      }
-    };
-
-    const run =
-      opts.kind === "tier1"
-        ? this.runner.tier1(opts, log, ctrl.signal)
-        : this.runner.agentic(opts, log, ctrl.signal);
-
-    run.then(
-      (report) => {
-        this.controllers.delete(runId); // I2: keep maps symmetric after natural completion
-        if (job.status === "cancelled") return;
-        job.report = report;
-        job.status = "done";
-        job.finishedAt = Date.now();
-      },
-      (err) => {
-        this.controllers.delete(runId); // I2: keep maps symmetric after natural completion
-        if (job.status === "cancelled") return;
-        job.error = err instanceof Error ? err.message : String(err);
-        job.status = "error";
-        job.finishedAt = Date.now();
-      },
-    );
-
-    return runId;
-  }
-
-  status(runId: string): Job | undefined {
-    return this.jobs.get(runId);
-  }
-
-  list(): Job[] {
-    return [...this.jobs.values()];
-  }
-
-  cancel(runId: string): boolean {
-    const job = this.jobs.get(runId);
-    if (!job || job.status !== "running") return false;
-    this.controllers.get(runId)?.abort();
-    job.status = "cancelled";
-    job.finishedAt = Date.now();
-    return true;
-  }
-
-  private evict(): void {
-    if (this.jobs.size <= JOB_CAP) return;
-    const sorted = [...this.jobs.values()].sort((a, b) => a.startedAt - b.startedAt);
-    while (this.jobs.size > JOB_CAP) {
-      const oldest = sorted.shift();
-      if (!oldest) break;
-      this.controllers.get(oldest.runId)?.abort(); // I1: abort still-running evicted jobs
-      this.jobs.delete(oldest.runId);
-      this.controllers.delete(oldest.runId);
-    }
-  }
-}

package/src/mcp/smart-filter.ts

@@ -1,138 +0,0 @@
-/**
- * Smart MCP server filtering.
- *
- * MCP tool schemas are the single largest variable contributor to per-turn
- * input tokens — a live probe ("Reply with one word: PONG", session
- * 8a87aa060c6a) carried 53 tool schemas (~21K input tokens) for a turn that
- * used zero tools. ~36 of those came from MCP servers that the turn could not
- * possibly need.
- *
- * The original inline filter (message-processor.ts) only skipped browser/vision
- * servers when the message had no browser signal. This generalises that same
- * proven pattern to a small category→signal table: an OPTIONAL category is
- * dropped only when its signal is absent from the user's current message.
- *
- * Safety: builtin tools are never touched here, and only servers whose id
- * matches a known optional category are ever dropped — domain servers
- * (filesystem, muonroi-tools, harness, …) always pass through. A false
- * positive (signal matched when not strictly needed) merely keeps a server,
- * costing tokens but never breaking capability; the regexes are deliberately
- * broad so the failure mode is "kept", not "wrongly dropped".
- *
- * Disable entirely with MUONROI_DISABLE_SMART_MCP=1 (handled by the caller,
- * passed in as `disabled`).
- */
-
-/** Browser/vision automation servers — only needed when the turn touches a page. */
-const SKIP_WHEN_NO_BROWSER = /playwright|chrome|browser|devtools|vision|figma|canva/i;
-
-/**
- * External-lookup servers (docs / URL fetch / web search) — only needed when
- * the turn reaches for information outside the codebase. Web-search servers
- * (tavily/exa/brave/serper/perplexity/…) belong to the same category: a pure
- * code-edit turn never needs them, and each carries 2-3 tool schemas.
- */
-const SKIP_WHEN_NO_DOCS =
-  /context7|(^|[-_])fetch([-_]|$)|docs|tavily|exa|brave|serper|perplexity|web[-_]?search|websearch/i;
-
-/** Matches a browser/page-automation intent (kept identical to the legacy inline regex, plus a URL). */
-function hasBrowserSignal(message: string): boolean {
-  return (
-    /https?:\/\/\S+/i.test(message) ||
-    /\b(screenshot|browser|playwright|chrome|figma|canva|render|webpage|website|url|hyperlink|navigate|click|scrape)\b/i.test(
-      message,
-    )
-  );
-}
-
-/**
- * Matches an external-information intent (docs lookup / URL fetch / web search).
- * Broad on purpose — bias is keep-not-drop. Web-search intent adds a few
- * low-collision terms (news/weather/online/internet/"look up") that rarely
- * appear in a pure code-edit prompt; bare "search" is intentionally excluded
- * because it collides with "search the codebase" / "add a search feature".
- */
-function hasDocsSignal(message: string): boolean {
-  return (
-    /https?:\/\/\S+/i.test(message) ||
-    /\b(docs?|documentation|api|sdk|library|libraries|framework|package|npm|pip|cargo|crate|gem|maven|nuget|install|migrat\w*|changelog|release\s*notes?|reference|usage|fetch|download|http|web|google|search\s+(the\s+)?web|news|weather|headlines|look\s*up|online|internet)\b/i.test(
-      message,
-    )
-  );
-}
-
-/**
- * Filesystem-MCP tool names that 1:1 duplicate a first-class BUILTIN file tool.
- * The builtin `read_file`/`write_file`/`edit_file` are strictly better (read-
- * before-write tracking, LSP sync, CRLF-tolerant matching, per-turn dedup +
- * read-budget wrappers), so exposing the MCP twins on top is pure redundancy.
- *
- * Live waste (storyflow_ui explore-flow A/B, grok session f5dfab0ce0ca): the
- * model re-read the SAME three files via BOTH `read_file` and
- * `mcp_filesystem__read_text_file` — a 772-line component was read 6× — because
- * two interchangeable read tools were on offer. Each re-read re-injects the
- * whole file into context (large input-token leak) on top of ~150 tok/schema.
- *
- * Mapping: bare MCP tool name → the builtin that already covers it. We only drop
- * the MCP tool when that builtin is actually present in the turn's tool set.
- */
-const FS_MCP_BUILTIN_EQUIVALENT: Record<string, string> = {
-  read_file: "read_file",
-  read_text_file: "read_file",
-  read_media_file: "read_file",
-  read_multiple_files: "read_file",
-  write_file: "write_file",
-  edit_file: "edit_file",
-};
-
-/**
- * Drop filesystem-MCP read/write/edit tools that duplicate a present builtin.
- * Scoped to the `mcp_filesystem__` prefix so non-filesystem MCP tools (and the
- * filesystem server's NON-duplicate tools — directory_tree, search_files,
- * get_file_info, …) are never touched. Returns the filtered set plus the list
- * of dropped names so the caller can log it (no silent capability removal).
- * Override with MUONROI_KEEP_REDUNDANT_FS_MCP=1.
- */
-export function dropRedundantFsMcpTools<T extends Record<string, unknown>>(
-  mcpTools: T,
-  builtinToolNames: ReadonlySet<string>,
-): { tools: T; dropped: string[] } {
-  if (process.env.MUONROI_KEEP_REDUNDANT_FS_MCP === "1") return { tools: mcpTools, dropped: [] };
-  const out: Record<string, unknown> = {};
-  const dropped: string[] = [];
-  for (const [name, tool] of Object.entries(mcpTools)) {
-    const m = name.match(/^mcp_filesystem__(.+)$/);
-    const equivalent = m ? FS_MCP_BUILTIN_EQUIVALENT[m[1]!] : undefined;
-    if (equivalent && builtinToolNames.has(equivalent)) {
-      dropped.push(name);
-      continue;
-    }
-    out[name] = tool;
-  }
-  return { tools: out as T, dropped };
-}
-
-export interface SmartFilterOptions {
-  /** When true, smart filtering is bypassed and every server passes through. */
-  disabled?: boolean;
-}
-
-/**
- * Filter a list of MCP servers down to those plausibly relevant to the user's
- * current message. Only `.id` is read; the generic keeps the caller's concrete
- * server type intact.
- */
-export function filterMcpServersByMessage<T extends { id: string }>(
-  servers: T[],
-  userMessage: string,
-  opts: SmartFilterOptions = {},
-): T[] {
-  if (opts.disabled) return servers;
-  const browser = hasBrowserSignal(userMessage);
-  const docs = hasDocsSignal(userMessage);
-  return servers.filter((s) => {
-    if (!browser && SKIP_WHEN_NO_BROWSER.test(s.id)) return false;
-    if (!docs && SKIP_WHEN_NO_DOCS.test(s.id)) return false;
-    return true;
-  });
-}

package/src/mcp/smoke.test.ts

@@ -1,170 +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: Awaited<ReturnType<typeof buildMcpToolSet>> | undefined;
-
-      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,
-  );
-});