zidane 4.0.2 → 4.1.3

package/dist/mcp-8wClKY-3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-8wClKY-3.js","names":[],"sources":["../src/mcp/sse-to-json-fetch.ts","../src/mcp/tolerant-client.ts","../src/mcp/index.ts"],"sourcesContent":["/**\n * `fetch` shim that converts streamable-http POST responses with\n * `Content-Type: text/event-stream` into synthetic `application/json`\n * responses, preserving every original header (notably `mcp-session-id`).\n *\n * Why this exists\n * ----------------\n * The MCP SDK's streamable-http transport handles POST responses two ways\n * depending on `content-type`:\n *\n *   - `application/json` → `await response.json()` (works on every runtime).\n *   - `text/event-stream` → `body.pipeThrough(TextDecoderStream)\n *                              .pipeThrough(EventSourceParserStream)`\n *                          and forward each parsed event to `onmessage`.\n *\n * On Bun + MCP SDK 1.29.x the second pipeline silently drops the parsed\n * event: the full `event: message\\ndata: {...}\\n\\n` arrives intact, the\n * stream closes, but `onmessage` is never called. Bootstrap then waits the\n * full `bootstrapTimeout` (10s default) and the agent loses every tool the\n * server would have exposed.\n *\n * The MCP spec lets clients accept either content type\n * (`Accept: application/json, text/event-stream`), so flipping the stream\n * to JSON at the boundary is a transparent, server-agnostic workaround.\n *\n * Scope of the shim\n * -----------------\n *   - POST + `text/event-stream` → drain, parse SSE message events, return\n *     a synthetic `application/json` response. Single event becomes a JSON\n *     object (matching the shape the SDK expects from non-streaming\n *     servers); multiple events become a JSON array (the SDK already\n *     iterates `Array.isArray(data)` from a JSON response).\n *   - GET (long-lived `_startOrAuthSse` listener) → untouched. Per-event\n *     latency matters there and the SSE pipeline isn't always broken on\n *     GET in the same way (different code path inside Bun's stream impl).\n *   - 202 / non-SSE / malformed SSE / no body → passthrough.\n *\n * Runtime gating\n * --------------\n * `sseToJsonFetchIfNeeded()` only returns a wrapper on Bun. Node + browser\n * runtimes get `undefined` and the SDK uses global `fetch` directly — no\n * extra buffer-and-redrain on the happy path, and no risk of collapsing a\n * future progress-streaming response into a single batched array. If you\n * need to apply the shim unconditionally (testing, custom hosts), call\n * `sseToJsonFetch()` directly.\n *\n * Cleanup\n * -------\n * Remove this file and its `fetch:` injection in `createTransport` once\n * either Bun fixes the `pipeThrough` chain or the SDK switches off the\n * streaming pipeline by default.\n */\n\n/**\n * Detect whether we're running on Bun. The `Bun` global is set by the\n * runtime itself and isn't faked by Bun's Node-compat layer.\n */\nfunction isBunRuntime(): boolean {\n  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'\n}\n\n/**\n * Returns the `sseToJsonFetch` wrapper only on runtimes that need it\n * (currently Bun). Returns `undefined` everywhere else, which makes the\n * SDK fall back to the global `fetch` and keeps the streaming pipeline\n * intact on Node where it works correctly.\n *\n * Designed as the value to pass directly to `StreamableHTTPClientTransport`'s\n * `fetch` option:\n *\n *     new StreamableHTTPClientTransport(url, {\n *       fetch: sseToJsonFetchIfNeeded(),\n *     })\n */\nexport function sseToJsonFetchIfNeeded(): typeof fetch | undefined {\n  return isBunRuntime() ? sseToJsonFetch() : undefined\n}\n\n/**\n * Wrap a `fetch` implementation so streamable-http POST responses that come\n * back as `text/event-stream` are converted to JSON. Pass the result as\n * `opts.fetch` to `StreamableHTTPClientTransport`.\n *\n * Always-on (i.e. unconditional) — for the runtime-gated entry point,\n * use {@link sseToJsonFetchIfNeeded} instead.\n */\nexport function sseToJsonFetch(baseFetch: typeof fetch = fetch): typeof fetch {\n  return async function sseToJsonWrappedFetch(input, init) {\n    const response = await baseFetch(input, init)\n\n    // Only intercept POSTs. The SDK's GET path opens a long-lived SSE\n    // listener (`_startOrAuthSse`) that we must not buffer-drain.\n    const method = (init?.method ?? 'GET').toString().toUpperCase()\n    if (method !== 'POST')\n      return response\n\n    const contentType = response.headers.get('content-type')\n    if (!contentType || !contentType.includes('text/event-stream'))\n      return response\n\n    if (!response.body)\n      return response\n\n    let raw: string\n    try {\n      raw = await response.text()\n    }\n    catch {\n      // Bun edge case: if even .text() fails, surrender — the original\n      // response is already drained, so we can't recover. Return it; the\n      // SDK will surface the underlying read error.\n      return response\n    }\n\n    const events = parseSseDataEvents(raw)\n    // Single event → bare object; multi-event or zero → array. The SDK's\n    // JSON branch handles both shapes (`Array.isArray(data) ? data.map(…) : …`).\n    const payload = events.length === 1 ? events[0] : events\n    return synthesizeJsonResponse(response, payload)\n  } as typeof fetch\n}\n\n/**\n * Parse a buffered SSE body into the JSON payloads of its `message` events.\n *\n * Skips:\n * - SSE comments (lines starting with `:`).\n * - Non-default event types (`event: foo` ≠ `message`). The MCP server\n *   only ever emits `message` events for JSON-RPC; anything else is out of\n *   band and the SDK wouldn't have surfaced it to `onmessage` either.\n * - Malformed `data:` payloads (anything that fails `JSON.parse`).\n */\nfunction parseSseDataEvents(raw: string): unknown[] {\n  const events: unknown[] = []\n  for (const block of raw.split(/\\r?\\n\\r?\\n/)) {\n    if (!block.trim())\n      continue\n\n    const dataLines: string[] = []\n    let isMessageEvent = true\n    for (const line of block.split(/\\r?\\n/)) {\n      if (line.startsWith(':'))\n        continue\n      if (line.startsWith('event:')) {\n        const eventType = line.slice('event:'.length).trim()\n        if (eventType && eventType !== 'message')\n          isMessageEvent = false\n      }\n      else if (line.startsWith('data:')) {\n        // Per SSE spec: a single leading space after `data:` is part of the\n        // separator, not the payload. Anything beyond it is.\n        const value = line.slice('data:'.length)\n        dataLines.push(value.startsWith(' ') ? value.slice(1) : value)\n      }\n    }\n\n    if (!isMessageEvent || dataLines.length === 0)\n      continue\n\n    try {\n      events.push(JSON.parse(dataLines.join('\\n')))\n    }\n    catch {\n      // Drop malformed events. The SDK's broken pipe would have dropped\n      // them too — staying silent here matches that baseline.\n    }\n  }\n  return events\n}\n\n/**\n * Build a `Response` mirroring the original's status / statusText / headers\n * but with a JSON body and `content-type: application/json`. Header\n * preservation is the whole point — `mcp-session-id` is set by the server\n * on the initialize POST and must round-trip into the SDK's\n * `_sessionId` capture (`response.headers.get('mcp-session-id')`).\n */\nfunction synthesizeJsonResponse(original: Response, payload: unknown): Response {\n  const headers = new Headers(original.headers)\n  headers.set('content-type', 'application/json')\n  return new Response(JSON.stringify(payload), {\n    status: original.status,\n    statusText: original.statusText,\n    headers,\n  })\n}\n","/**\n * Drop-in `Client` subclass whose `connect()` mirrors the upstream MCP SDK\n * sequence but treats `notifications/initialized` as best-effort.\n *\n * The MCP spec marks that notification fire-and-forget, but the SDK awaits\n * the underlying transport `send()` and rethrows on any HTTP 4xx. Several\n * real-world streamable-http servers (e.g. browser-codemode, custom MCPs\n * that gate non-initialize routes on a session id that didn't yet exist when\n * the notification posted) reject the notification with a 4xx and still\n * accept every subsequent request. The base `Client.connect()` then closes\n * the transport, the bootstrap fails, and the agent silently loses every\n * tool the server would have exposed.\n *\n * This subclass changes only that single step — log + continue if the\n * notification throws. Initialize, capability/version capture,\n * `setProtocolVersion`, listChanged handler wiring, and the close-on-failure\n * path for everything else are preserved verbatim from the SDK.\n *\n * Should be removed when the SDK lands an opt-in tolerance flag upstream.\n */\nimport { Client } from '@modelcontextprotocol/sdk/client/index.js'\nimport { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js'\nimport {\n  InitializeResultSchema,\n  LATEST_PROTOCOL_VERSION,\n  SUPPORTED_PROTOCOL_VERSIONS,\n} from '@modelcontextprotocol/sdk/types.js'\n\n// Private fields the override needs to read/write to mirror upstream behavior.\n// Cast surface is isolated to this one type so the rest of the file stays clean.\ninterface ClientPrivates {\n  _capabilities: unknown\n  _clientInfo: unknown\n  _serverCapabilities: unknown\n  _serverVersion: unknown\n  _instructions: unknown\n  _pendingListChangedConfig?: unknown\n  _setupListChangedHandlers: (config: unknown) => void\n}\n\ninterface MaybeSessionedTransport {\n  sessionId?: unknown\n  setProtocolVersion?: (v: string) => void\n}\n\nexport class TolerantMcpClient extends Client {\n  async connect(\n    transport: Parameters<Client['connect']>[0],\n    options?: Parameters<Client['connect']>[1],\n  ): Promise<void> {\n    // Wire the transport (Protocol.connect — onmessage/onclose/onerror hooks\n    // and transport.start) without sending any messages. We MUST NOT call\n    // `super.connect()` here — that's `Client.connect`, which would\n    // re-execute the very initialize+notification dance we're overriding.\n    await Protocol.prototype.connect.call(this as never, transport)\n\n    // Reconnect path: the upstream client short-circuits on a transport that\n    // already carries a session id, so do we.\n    if ((transport as MaybeSessionedTransport).sessionId !== undefined)\n      return\n\n    const self = this as unknown as ClientPrivates\n\n    try {\n      const result = await this.request(\n        {\n          method: 'initialize',\n          params: {\n            protocolVersion: LATEST_PROTOCOL_VERSION,\n            capabilities: self._capabilities,\n            clientInfo: self._clientInfo,\n          },\n        },\n        InitializeResultSchema,\n        options,\n      )\n\n      if (result === undefined)\n        throw new Error(`Server sent invalid initialize result: ${result}`)\n      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion))\n        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`)\n\n      self._serverCapabilities = result.capabilities\n      self._serverVersion = result.serverInfo\n\n      const setProtocolVersion = (transport as MaybeSessionedTransport).setProtocolVersion\n      if (setProtocolVersion)\n        setProtocolVersion.call(transport, result.protocolVersion)\n\n      self._instructions = result.instructions\n\n      // Best-effort. The session id (if any) is already captured by the\n      // transport from the `initialize` response headers, so subsequent\n      // requests like `tools/list` still authenticate. Don't bring down the\n      // whole connection on a 4xx for a fire-and-forget notification.\n      try {\n        await this.notification({ method: 'notifications/initialized' })\n      }\n      catch (notifyError) {\n        const msg = notifyError instanceof Error ? notifyError.message : String(notifyError)\n        console.warn(`[zidane:mcp] server rejected notifications/initialized (continuing): ${msg}`)\n      }\n\n      if (self._pendingListChangedConfig) {\n        self._setupListChangedHandlers(self._pendingListChangedConfig)\n        self._pendingListChangedConfig = undefined\n      }\n    }\n    catch (error) {\n      // Same failure path as upstream Client — anything *other* than the\n      // tolerated notification failure tears the transport down so the\n      // bootstrap surfaces a clear error.\n      void this.close()\n      throw error\n    }\n  }\n}\n","/**\n * MCP (Model Context Protocol) server support.\n *\n * Connects to one or more MCP servers, discovers their tools,\n * and wraps them as zidane ToolDefs for use in agent loops.\n */\n\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js'\nimport type { Hookable } from 'hookable'\nimport type { AgentHooks } from '../agent'\nimport type { ToolContext, ToolDef } from '../tools/types'\nimport type { McpServerConfig, ToolResultContent } from '../types'\nimport { Buffer } from 'node:buffer'\nimport { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'\nimport { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'\nimport { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'\nimport { toolOutputByteLength } from '../types'\nimport { sseToJsonFetchIfNeeded } from './sse-to-json-fetch'\nimport { TolerantMcpClient } from './tolerant-client'\n\nexport type { McpServerConfig } from '../types'\n\nexport interface McpConnection {\n  tools: Record<string, ToolDef>\n  close: () => Promise<void>\n}\n\n// ---------------------------------------------------------------------------\n// Shape normalization\n// ---------------------------------------------------------------------------\n\ninterface RawServerShape {\n  name?: string\n  transport?: string\n  type?: string\n  command?: string\n  args?: string[]\n  env?: Record<string, string>\n  strictEnv?: boolean\n  url?: string\n  httpUrl?: string\n  sseUrl?: string\n  headers?: Record<string, string>\n  bootstrapTimeout?: number\n  toolTimeout?: number\n  enabledTools?: string[]\n  disabledTools?: string[]\n  toolFilter?: McpServerConfig['toolFilter']\n  [key: string]: unknown\n}\n\nconst DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS = 10_000\n\nfunction inferTransport(raw: RawServerShape): McpServerConfig['transport'] {\n  if (raw.transport === 'stdio' || raw.transport === 'sse' || raw.transport === 'streamable-http')\n    return raw.transport\n  if (raw.type === 'stdio' || raw.type === 'sse' || raw.type === 'streamable-http' || raw.type === 'http')\n    return raw.type === 'http' ? 'streamable-http' : raw.type\n  if (raw.command)\n    return 'stdio'\n  if (raw.httpUrl)\n    return 'streamable-http'\n  if (raw.sseUrl)\n    return 'sse'\n  if (raw.url)\n    return 'streamable-http'\n  throw new Error(`Cannot infer MCP transport from config: ${JSON.stringify(raw)}`)\n}\n\nfunction normalizeOne(name: string, raw: RawServerShape): McpServerConfig {\n  const transport = inferTransport(raw)\n  const url = raw.url ?? raw.httpUrl ?? raw.sseUrl\n\n  const config: McpServerConfig = { name, transport }\n  if (raw.command)\n    config.command = raw.command\n  if (raw.args)\n    config.args = raw.args\n  if (raw.env)\n    config.env = raw.env\n  if (raw.strictEnv === true)\n    config.strictEnv = true\n  if (url)\n    config.url = url\n  if (raw.headers)\n    config.headers = raw.headers\n  if (typeof raw.bootstrapTimeout === 'number')\n    config.bootstrapTimeout = raw.bootstrapTimeout\n  if (typeof raw.toolTimeout === 'number')\n    config.toolTimeout = raw.toolTimeout\n  if (Array.isArray(raw.enabledTools))\n    config.enabledTools = raw.enabledTools\n  if (Array.isArray(raw.disabledTools))\n    config.disabledTools = raw.disabledTools\n  if (typeof raw.toolFilter === 'function')\n    config.toolFilter = raw.toolFilter\n\n  return config\n}\n\n/**\n * True when the input looks like a single config object (flat fields like `command`,\n * `transport`, `url`) rather than a record whose values are configs.\n */\nfunction looksLikeSingleConfig(obj: Record<string, unknown>): boolean {\n  const singleConfigKeys = ['transport', 'type', 'command', 'url', 'httpUrl', 'sseUrl']\n  return singleConfigKeys.some(key => typeof obj[key] === 'string')\n}\n\n/**\n * Normalize MCP server configs from any common shape to `McpServerConfig[]`.\n *\n * Accepts:\n * - `McpServerConfig[]` — zidane native (pass-through).\n * - `McpServerConfig` — a single config object (wrapped to a 1-element array).\n * - `Record<string, RawShape>` — name-keyed map (common in host-SDK configs), where the key is the server name.\n * - Mixed shapes with `type` vs `transport`, `httpUrl`/`sseUrl` vs `url`.\n *\n * Returns `[]` when `input` is nullish. Throws a descriptive error when the transport\n * cannot be inferred from a given entry, or when the input shape is unsupported.\n */\nexport function normalizeMcpServers(input: unknown): McpServerConfig[] {\n  if (input == null)\n    return []\n\n  if (Array.isArray(input)) {\n    return input.map((raw, idx) => {\n      const obj = raw as RawServerShape\n      const name = obj.name ?? `mcp_${idx}`\n      return normalizeOne(name, obj)\n    })\n  }\n\n  if (typeof input === 'object') {\n    const obj = input as Record<string, unknown>\n    // Single-config heuristic: flat fields like `transport`/`command`/`url` at the top\n    // level indicate a single McpServerConfig, not a record of configs.\n    if (looksLikeSingleConfig(obj)) {\n      const raw = obj as RawServerShape\n      const name = raw.name ?? 'mcp_0'\n      return [normalizeOne(name, raw)]\n    }\n    return Object.entries(obj as Record<string, RawServerShape>).map(\n      ([name, raw]) => normalizeOne(name, raw ?? {}),\n    )\n  }\n\n  throw new Error(`Unsupported MCP server config shape: ${typeof input}`)\n}\n\n/**\n * Lossy flattener — converts MCP `CallToolResult.content` blocks to a single\n * string. Text blocks are extracted; non-text blocks are JSON-stringified.\n *\n * Use this only at UI / log boundaries that require a string. The agent\n * loop itself routes through {@link normalizeMcpBlocks} so image blocks\n * survive into provider-native tool_result content (Anthropic blocks,\n * OpenAI companion-user-message).\n */\nexport function resultToString(content: unknown[]): string {\n  if (!content || !Array.isArray(content))\n    return ''\n  return content\n    .map((block) => {\n      if (block && typeof block === 'object' && (block as { type?: unknown }).type === 'text') {\n        const text = (block as { text?: unknown }).text\n        if (typeof text === 'string')\n          return text\n      }\n      return JSON.stringify(block)\n    })\n    .join('\\n')\n}\n\n/**\n * Normalize MCP `CallToolResult.content` to zidane's {@link ToolResultContent[]} shape.\n *\n * Handles the four MCP content block types:\n * - `text` → preserved as `{type:'text', text}`\n * - `image` → preserved as `{type:'image', mediaType, data}` (MCP uses `mimeType`)\n * - `resource` with embedded text → flattened to a text block\n * - `resource` with embedded blob whose `mimeType` is `image/*` → flattened to an image block\n * - Any unrecognized block → JSON-stringified fallback text block (lossy but safe)\n *\n * Returns `null` when the input is not an array — callers should fall back to an empty\n * result in that case.\n */\nexport function normalizeMcpBlocks(content: unknown): ToolResultContent[] | null {\n  if (!Array.isArray(content))\n    return null\n\n  const out: ToolResultContent[] = []\n  for (const raw of content) {\n    if (!raw || typeof raw !== 'object')\n      continue\n    const block = raw as Record<string, unknown>\n\n    if (block.type === 'text' && typeof block.text === 'string') {\n      out.push({ type: 'text', text: block.text })\n      continue\n    }\n\n    if (block.type === 'image' && typeof block.data === 'string') {\n      const mediaType = typeof block.mimeType === 'string'\n        ? block.mimeType\n        : (typeof block.mediaType === 'string' ? block.mediaType : 'image/png')\n      out.push({ type: 'image', mediaType, data: block.data })\n      continue\n    }\n\n    if (block.type === 'resource' && block.resource && typeof block.resource === 'object') {\n      const res = block.resource as Record<string, unknown>\n      if (typeof res.text === 'string') {\n        out.push({ type: 'text', text: res.text })\n        continue\n      }\n      if (typeof res.blob === 'string' && typeof res.mimeType === 'string' && res.mimeType.startsWith('image/')) {\n        out.push({ type: 'image', mediaType: res.mimeType, data: res.blob })\n        continue\n      }\n    }\n\n    // Audio, resource_link, and unknown block shapes — fall back to a JSON-stringified\n    // text block. Lossy but keeps the information addressable by the model.\n    out.push({ type: 'text', text: JSON.stringify(block) })\n  }\n\n  return out\n}\n\n/**\n * Route the MCP result content through the narrowest appropriate zidane shape:\n *\n * - All blocks are `text` → return a joined string (smaller wire payload,\n *   string-friendly for hook consumers that don't need structured access).\n * - Any block is non-text → return a structured `ToolResultContent[]`.\n * - Empty / non-array input → return `''`.\n */\nfunction packMcpResult(content: unknown): string | ToolResultContent[] {\n  const normalized = normalizeMcpBlocks(content)\n  if (!normalized || normalized.length === 0)\n    return ''\n\n  // Single pass: build the joined string as we go. Bail to the structured array\n  // the moment we hit a non-text block.\n  const parts: string[] = []\n  for (const block of normalized) {\n    if (block.type !== 'text')\n      return normalized\n    parts.push(block.text)\n  }\n  return parts.join('\\n')\n}\n\n/**\n * Create the appropriate MCP transport for a server config.\n *\n * For stdio: when `config.env` is provided, it is merged on top of the MCP SDK's\n * `getDefaultEnvironment()` whitelist (`PATH`, `HOME`, `LANG`, `SHELL`, `USER` on\n * POSIX; `APPDATA`, `PATH`, ... on Win32). Without this defensive merge, older\n * MCP SDK versions strip `PATH` the moment a consumer sets any env, breaking\n * `spawn('node', ...)` with ENOENT. Pass `strictEnv: true` to opt out and send\n * `env` verbatim.\n */\nfunction createTransport(config: McpServerConfig) {\n  switch (config.transport) {\n    case 'stdio': {\n      const mergedEnv = config.env && !config.strictEnv\n        ? { ...getDefaultEnvironment(), ...config.env }\n        : config.env\n      return new StdioClientTransport({\n        command: config.command!,\n        args: config.args,\n        env: mergedEnv,\n      })\n    }\n    case 'sse':\n      return new SSEClientTransport(new URL(config.url!), {\n        requestInit: config.headers ? { headers: config.headers } : undefined,\n      })\n    case 'streamable-http':\n      // `fetch: sseToJsonFetchIfNeeded()` works around a Bun + MCP SDK\n      // 1.29.x bug where `text/event-stream` POST responses are buffered\n      // correctly but never surface to `onmessage`, dead-locking bootstrap.\n      // The helper returns the wrapper only on Bun and `undefined` on Node\n      // (so the SDK's streaming pipeline stays intact where it works).\n      // See ./sse-to-json-fetch.ts.\n      return new StreamableHTTPClientTransport(new URL(config.url!), {\n        requestInit: config.headers ? { headers: config.headers } : undefined,\n        fetch: sseToJsonFetchIfNeeded(),\n      })\n    default:\n      throw new Error(`Unknown MCP transport: ${config.transport}`)\n  }\n}\n\n/**\n * Connect to MCP servers and discover their tools.\n *\n * Each tool is namespaced as `mcp_{serverName}_{toolName}` to avoid\n * collisions with agent tools or tools from other servers.\n *\n * @param configs - Array of MCP server configurations\n * @param _clientFactory - Internal: override client construction for testing\n * @param hooks - Optional agent hooks for firing mcp:connect, mcp:error, mcp:close events\n */\nexport async function connectMcpServers(\n  configs: McpServerConfig[],\n  _clientFactory?: () => Client,\n  hooks?: Hookable<AgentHooks>,\n): Promise<McpConnection> {\n  const connections: { name: string, client: Client }[] = []\n  const tools: Record<string, ToolDef> = {}\n  const errors: { name: string, error: Error }[] = []\n  let closed = false\n\n  // Bootstrap every server in parallel. Previously this was a sequential for-loop,\n  // which meant a single slow server (GitHub MCP, cold streamable-http endpoints,\n  // anything on a flaky network) blocked the whole first `agent.run()` for up to\n  // N × bootstrapTimeout. With `Promise.all` + per-server try/catch, wall-clock\n  // collapses to the slowest server, and the existing partial-failure tolerance\n  // keeps the agent alive when any subset connects.\n  const bootstrapResults = await Promise.all(configs.map(config => bootstrapServer(config, _clientFactory, hooks)))\n\n  for (const result of bootstrapResults) {\n    if (!result.ok) {\n      errors.push({ name: result.name, error: result.error })\n      await hooks?.callHook('mcp:error', { name: result.name, error: result.error })\n      continue\n    }\n\n    connections.push({ name: result.name, client: result.client })\n    const toolNames: string[] = []\n    for (const tool of result.tools) {\n      const namespacedName = `mcp_${result.config.name}_${tool.name}`\n      toolNames.push(namespacedName)\n      tools[namespacedName] = buildMcpToolDef(result.config, result.client, tool, namespacedName, hooks)\n    }\n    await hooks?.callHook('mcp:connect', {\n      name: result.name,\n      transport: result.config.transport,\n      tools: toolNames,\n    })\n  }\n\n  // If all servers failed, throw; partial failures are tolerated\n  if (errors.length > 0 && connections.length === 0) {\n    const messages = errors.map(e => `${e.name}: ${e.error.message}`).join(', ')\n    throw new Error(`All MCP servers failed to connect: ${messages}`)\n  }\n\n  return {\n    tools,\n    close: async () => {\n      // Idempotent — double-close on `agent.destroy()` retry should not\n      // re-fire the hook or call `client.close()` twice (the stdio transport\n      // treats a second close as a no-op but some transports throw).\n      if (closed)\n        return\n      closed = true\n      await Promise.allSettled(\n        connections.map(async ({ name, client }) => {\n          await hooks?.callHook('mcp:close', { name })\n          await client.close()\n        }),\n      )\n    },\n  }\n}\n\n/**\n * Discriminated result returned by `bootstrapServer` so `connectMcpServers` can\n * aggregate successes + failures without letting a rejected promise tear down\n * the whole parallel batch.\n */\ntype BootstrapResult\n  = | { ok: true, name: string, config: McpServerConfig, client: Client, tools: Array<{ name: string, description?: string | null, inputSchema?: unknown }> }\n    | { ok: false, name: string, error: Error }\n\n/**\n * Connect one MCP server and list its tools, wrapped in a single race against\n * `config.bootstrapTimeout` (default 10s). Always emits `mcp:bootstrap:start`\n * before network I/O and `mcp:bootstrap:end` with `durationMs` + outcome, so a\n * host can build a timing view even when every server succeeds.\n *\n * Errors are captured into the `{ ok: false }` result rather than thrown — the\n * parent uses `Promise.all` across every server and we can't let one rejection\n * short-circuit the batch.\n */\nasync function bootstrapServer(\n  config: McpServerConfig,\n  _clientFactory: (() => Client) | undefined,\n  hooks: Hookable<AgentHooks> | undefined,\n): Promise<BootstrapResult> {\n  const start = Date.now()\n  // Validate mutually-exclusive filter fields up-front so the consumer gets a\n  // typed `mcp:bootstrap:end` failure rather than a silent later-stage drop.\n  if (config.enabledTools && config.disabledTools) {\n    const error = new Error(\n      `MCP server \"${config.name}\": enabledTools and disabledTools are mutually exclusive — set one or the other, not both.`,\n    )\n    await hooks?.callHook('mcp:bootstrap:start', { name: config.name, transport: config.transport })\n    await hooks?.callHook('mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs: 0,\n      ok: false,\n      error,\n    })\n    return { ok: false, name: config.name, error }\n  }\n\n  await hooks?.callHook('mcp:bootstrap:start', { name: config.name, transport: config.transport })\n\n  let client: Client | null = null\n  try {\n    // TolerantMcpClient is a drop-in subclass that survives a 4xx on the\n    // `notifications/initialized` post (some real-world servers reject it\n    // without that breaking subsequent `tools/list` etc.). See\n    // ./tolerant-client.ts for the exact semantics.\n    client = _clientFactory\n      ? _clientFactory()\n      : new TolerantMcpClient({ name: 'zidane', version: '1.0.0' })\n    const currentClient = client\n\n    const transport = createTransport(config)\n    const bootstrapTimeout = config.bootstrapTimeout ?? DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS\n    const { tools: mcpTools } = await raceWithTimeout(\n      async () => {\n        await currentClient.connect(transport)\n        return await currentClient.listTools()\n      },\n      bootstrapTimeout,\n      `MCP server \"${config.name}\" bootstrap timed out after ${bootstrapTimeout}ms`,\n    )\n\n    // Per-tool filtering — config-side first (static host policy), then the\n    // `mcp:tools:filter` hook (runtime / dynamic decisions). Both compose AND-\n    // style: a tool needs to pass every stage to land in the agent registry.\n    const filteredTools = await applyMcpToolFilters(config, mcpTools, hooks)\n\n    const durationMs = Date.now() - start\n    await hooks?.callHook('mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs,\n      ok: true,\n      toolCount: filteredTools.length,\n    })\n    return { ok: true, name: config.name, config, client: currentClient, tools: filteredTools }\n  }\n  catch (err) {\n    const error = err instanceof Error ? err : new Error(String(err))\n    await closeClientQuietly(client)\n    const durationMs = Date.now() - start\n    await hooks?.callHook('mcp:bootstrap:end', {\n      name: config.name,\n      transport: config.transport,\n      durationMs,\n      ok: false,\n      error,\n    })\n    return { ok: false, name: config.name, error }\n  }\n}\n\n/**\n * Apply config-side filters (`enabledTools` / `disabledTools` / `toolFilter`)\n * and then the `mcp:tools:filter` hook to the upstream tool list.\n *\n * Composition order — narrowest-to-widest:\n * 1. Allow-list (`enabledTools`) — keep only listed tools.\n * 2. Deny-list (`disabledTools`) — drop listed tools.\n * 3. Predicate (`toolFilter`) — fine-grained metadata filtering.\n * 4. Hook (`mcp:tools:filter`) — runtime / per-host decisions.\n *\n * The mutual exclusion of `enabledTools` and `disabledTools` is checked in\n * `bootstrapServer` so this stays a pure data transform.\n */\nasync function applyMcpToolFilters(\n  config: McpServerConfig,\n  tools: Array<{ name: string, description?: string | null, inputSchema?: unknown }>,\n  hooks: Hookable<AgentHooks> | undefined,\n): Promise<Array<{ name: string, description?: string | null, inputSchema?: unknown }>> {\n  let filtered = tools\n\n  if (config.enabledTools && config.enabledTools.length > 0) {\n    const allow = new Set(config.enabledTools)\n    filtered = filtered.filter(t => allow.has(t.name))\n  }\n\n  if (config.disabledTools && config.disabledTools.length > 0) {\n    const deny = new Set(config.disabledTools)\n    filtered = filtered.filter(t => !deny.has(t.name))\n  }\n\n  if (config.toolFilter) {\n    const predicate = config.toolFilter\n    filtered = filtered.filter(t => predicate(t))\n  }\n\n  if (hooks) {\n    // Pass a fresh array so handlers cannot retroactively mutate the caller's\n    // upstream list; mutations they make to `ctx.tools` are scoped to this turn.\n    const ctx = { server: config.name, transport: config.transport, tools: [...filtered] }\n    await hooks.callHook('mcp:tools:filter', ctx)\n    filtered = ctx.tools\n  }\n\n  return filtered\n}\n\n/**\n * Build the zidane `ToolDef` that wraps a single MCP tool. Extracted so the\n * parallel bootstrap path can assemble tools from a results array without\n * inlining a 70-line closure inside the collector loop.\n *\n * The returned `execute` closes over the bootstrapped `client` — reconnects /\n * swap-outs must go through a fresh `connectMcpServers` call rather than\n * rewiring the tool in place.\n */\nfunction buildMcpToolDef(\n  config: McpServerConfig,\n  client: Client,\n  tool: { name: string, description?: string | null, inputSchema?: unknown },\n  namespacedName: string,\n  hooks: Hookable<AgentHooks> | undefined,\n): ToolDef {\n  return {\n    spec: {\n      name: namespacedName,\n      description: tool.description || '',\n      inputSchema: (tool.inputSchema ?? { type: 'object', properties: {} }) as Record<string, unknown>,\n    },\n    execute: async (input: Record<string, unknown>, ctx: ToolContext) => {\n      const { turnId, callId, signal } = ctx\n      const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName\n\n      // Gate — block MCP tool execution or substitute a synthetic result.\n      const gateCtx: {\n        turnId: string\n        callId: string\n        server: string\n        tool: string\n        displayName: string\n        input: Record<string, unknown>\n        block: boolean\n        reason: string\n        result?: string | ToolResultContent[]\n      } = {\n        turnId,\n        callId,\n        server: config.name,\n        tool: tool.name,\n        displayName,\n        input,\n        block: false,\n        reason: 'MCP tool execution was blocked',\n      }\n      await hooks?.callHook('mcp:tool:gate', gateCtx)\n\n      // Conflict resolution mirrors the loop's `tool:gate`: when both `block`\n      // and `result` are set (e.g. a policy gate refuses on top of a consumer\n      // cache substitute), `block` wins.\n      if (gateCtx.block)\n        return `Blocked: ${gateCtx.reason}`\n\n      const effectiveInput = gateCtx.input\n\n      // MCP gate `result` substitute — skip the upstream callTool, fire the\n      // transform + after hooks so consumers see the substitute consistently\n      // with normally-executed calls.\n      if (gateCtx.result !== undefined) {\n        let substitute: string | ToolResultContent[] = gateCtx.result\n        const transformCtx = {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          result: substitute,\n          outputBytes: toolOutputByteLength(substitute),\n        }\n        await hooks?.callHook('mcp:tool:transform', transformCtx)\n        substitute = transformCtx.result\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          result: substitute,\n          outputBytes: toolOutputByteLength(substitute),\n        })\n        return substitute\n      }\n      await hooks?.callHook('mcp:tool:before', {\n        turnId,\n        callId,\n        server: config.name,\n        tool: tool.name,\n        displayName,\n        input: effectiveInput,\n      })\n      const timeout = config.toolTimeout ?? 30_000\n      try {\n        // Race the call against the configured timeout AND the run-level\n        // abort signal. Aborting the run has to propagate into MCP calls\n        // — otherwise a hung stdio server keeps the tool call alive\n        // until `destroy()` eventually closes the client, which can be\n        // minutes if the agent is waiting on `waitForIdle()`.\n        const result = await raceWithTimeoutAndSignal(\n          () => client.callTool({ name: tool.name, arguments: effectiveInput }),\n          timeout,\n          `MCP tool \"${tool.name}\" on server \"${config.name}\" timed out after ${timeout}ms`,\n          signal,\n        )\n        let output: string | ToolResultContent[] = packMcpResult(result.content)\n\n        // Transform — mutate result before returning. `outputBytes` reflects\n        // the size before any consumer mutation so a truncation hook can size-budget.\n        const transformCtx = {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          result: output,\n          outputBytes: toolOutputByteLength(output),\n        }\n        await hooks?.callHook('mcp:tool:transform', transformCtx)\n        output = transformCtx.result\n\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          result: output,\n          outputBytes: toolOutputByteLength(output),\n        })\n        return output\n      }\n      catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err))\n        await hooks?.callHook('mcp:tool:error', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          error,\n        })\n        await hooks?.callHook('mcp:tool:after', {\n          turnId,\n          callId,\n          server: config.name,\n          tool: tool.name,\n          displayName,\n          input: effectiveInput,\n          result: error.message,\n          outputBytes: Buffer.byteLength(error.message),\n        })\n        throw error\n      }\n    },\n  }\n}\n\nasync function closeClientQuietly(client: Pick<Client, 'close'> | null | undefined): Promise<void> {\n  if (!client)\n    return\n  try {\n    await client.close()\n  }\n  catch {\n    // Best-effort cleanup — original bootstrap error is more actionable.\n  }\n}\n\nasync function raceWithTimeout<T>(\n  task: () => Promise<T>,\n  timeoutMs: number,\n  timeoutMessage: string,\n): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  try {\n    return await new Promise<T>((resolvePromise, rejectPromise) => {\n      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs)\n      task().then(resolvePromise, rejectPromise)\n    })\n  }\n  finally {\n    if (timer)\n      clearTimeout(timer)\n  }\n}\n\n/**\n * Race a promise-returning task against (a) a timeout and (b) an optional\n * abort signal. Cleans up its timer and abort listener on every exit path.\n *\n * The task itself isn't cancellable (the MCP SDK doesn't take a signal), so\n * the rejection unblocks the tool call while the underlying RPC completes in\n * the background. When the agent subsequently calls `connection.close()` the\n * stdio transport kills the subprocess, which clears any stuck in-flight work.\n */\nasync function raceWithTimeoutAndSignal<T>(\n  task: () => Promise<T>,\n  timeoutMs: number,\n  timeoutMessage: string,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  if (signal?.aborted)\n    throw new Error('MCP tool call aborted')\n\n  let timer: ReturnType<typeof setTimeout> | undefined\n  let onAbort: (() => void) | undefined\n  try {\n    return await new Promise<T>((resolvePromise, rejectPromise) => {\n      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs)\n      if (signal) {\n        onAbort = () => rejectPromise(new Error('MCP tool call aborted'))\n        signal.addEventListener('abort', onAbort, { once: true })\n      }\n      task().then(resolvePromise, rejectPromise)\n    })\n  }\n  finally {\n    if (timer)\n      clearTimeout(timer)\n    if (signal && onAbort)\n      signal.removeEventListener('abort', onAbort)\n  }\n}\n"],"mappings":"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"}

package/dist/mcp.d.ts

@@ -1,4 +1,2 @@
-import '@modelcontextprotocol/sdk/client/index.js';
-import 'hookable';
-export { M as McpConnection, r as McpServerConfig, an as connectMcpServers, az as normalizeMcpBlocks, aA as normalizeMcpServers, aE as resultToString } from './agent-BAHrGtqu.js';
-import './types-Bai5rKpa.js';
+import { d as McpConnection, f as connectMcpServers, h as resultToString, m as normalizeMcpServers, mt as McpServerConfig, p as normalizeMcpBlocks } from "./agent-BoV5Twdl.js";
+export { McpConnection, McpServerConfig, connectMcpServers, normalizeMcpBlocks, normalizeMcpServers, resultToString };

package/dist/mcp.js

@@ -1,13 +1,2 @@
-import {
-  connectMcpServers,
-  normalizeMcpBlocks,
-  normalizeMcpServers,
-  resultToString
-} from "./chunk-7GQ7P6DM.js";
-import "./chunk-JH6IAAFA.js";
-export {
-  connectMcpServers,
-  normalizeMcpBlocks,
-  normalizeMcpServers,
-  resultToString
-};
+import { i as resultToString, n as normalizeMcpBlocks, r as normalizeMcpServers, t as connectMcpServers } from "./mcp-8wClKY-3.js";
+export { connectMcpServers, normalizeMcpBlocks, normalizeMcpServers, resultToString };