toolnexus 0.26.0 → 0.28.0

package/src/index.ts

@@ -8,6 +8,7 @@ export * from "./native.js"
 export * from "./http.js"
 export * from "./a2a.js"
 export * from "./acp.js"
+export * from "./transcript_search.js"
 export * from "./serve.js"
 export * from "./mcpserve.js"
 export * from "./mcphandler.js"

package/src/mcp.ts

@@ -6,18 +6,24 @@
 import { readFileSync } from "node:fs"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
+import { AjvJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/ajv"
+import type { jsonSchemaValidator } from "@modelcontextprotocol/sdk/validation"
+import { AdoptedStdioTransport } from "./mcp2026/stdio.js"
 import type { Tool as McpToolDef, ElicitRequest, ElicitResult } from "@modelcontextprotocol/sdk/types.js"
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js"
 import { type JSONSchema, type Tool, type ToolContext, type ToolHints, type ToolResult, type McpStatus, type Request, type Answer, sanitize } from "./types.js"
 import { type ContentPart, summarizePart } from "./content.js"
 import type { SkillDef } from "./skill.js"
-import { probe, newOAuth, defaultTokenStore, type AuthConfig, type ModernServer, type Load2026Options } from "./mcp2026/source.js"
+import { type AuthConfig, type ModernServer, type Load2026Options } from "./mcp2026/source.js"
 import { PendingError, type OAuth, type TokenStore } from "./mcp2026/auth.js"
 export { Token, MemoryTokenStore, type TokenStore } from "./mcp2026/auth.js"
 export type { AuthConfig } from "./mcp2026/source.js"
 
+// Loaded on first use, not at import: the 2026 client is only needed once a config is loaded,
+// and the SDK's remote transports (streamable-HTTP, SSE) only when a remote server falls back.
+let mcp2026: Promise<typeof import("./mcp2026/source.js")> | undefined
+const loadMcp2026 = () => (mcp2026 ??= import("./mcp2026/source.js"))
+
 // ---------------------------------------------------------------------------
 // MCP elicitation bridge (§10). A server can ask US for input mid-`tools/call`
 // (a reverse-request). We map it onto the one `waitFor`: form mode → kind:"input",
@@ -460,8 +466,23 @@ function resourceTools(servers: Map<string, ServerConn>): Tool[] {
  *  exists. Separated from connect so the caller ALWAYS holds a closeable reference — even if the
  *  connect is later abandoned by a timeout/abort, `client.close()` still terminates any spawned
  *  stdio child (no orphaned processes on cancellation). */
+/**
+ * The SDK's default validator, built on first use instead of per Client. Building an Ajv instance
+ * (meta-schemas + formats) costs ~2-3 ms on every connect, yet it is only consulted when a tool
+ * declares an `outputSchema`. Same validator, same results — just not paid for up front.
+ */
+class LazyAjvValidator implements jsonSchemaValidator {
+  private inner?: AjvJsonSchemaValidator
+  getValidator<T>(schema: Parameters<jsonSchemaValidator["getValidator"]>[0]) {
+    return (this.inner ??= new AjvJsonSchemaValidator()).getValidator<T>(schema)
+  }
+}
+
 function newMcpClient(waitFor?: (request: Request) => Promise<Answer>): Client {
-  const client = new Client({ name: "toolnexus", version: "0.1.0" }, { capabilities: waitFor ? { elicitation: {} } : {} })
+  const client = new Client(
+    { name: "toolnexus", version: "0.1.0" },
+    { capabilities: waitFor ? { elicitation: {} } : {}, jsonSchemaValidator: new LazyAjvValidator() },
+  )
   if (waitFor) {
     client.setRequestHandler(ElicitRequestSchema, async (request) =>
       answerToElicitResult(await waitFor(elicitationToRequest(request.params))),
@@ -477,6 +498,10 @@ async function connectTransport(client: Client, cfg: ServerConfig, auth?: Fallba
     const expanded = expandEnvHeaders(cfg.headers)
     const requestInit = expanded ? { headers: expanded } : undefined
     const fetch = auth ? bearerFetch(cfg.url, auth) : undefined
+    const [{ StreamableHTTPClientTransport }, { SSEClientTransport }] = await Promise.all([
+      import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
+      import("@modelcontextprotocol/sdk/client/sse.js"),
+    ])
     try {
       await client.connect(new StreamableHTTPClientTransport(url, { requestInit, ...(fetch ? { fetch } : {}) }))
     } catch {
@@ -552,6 +577,7 @@ type Connected =
  * path, with the OAuth bearer attached for remote servers. Throws ⇒ the server failed.
  */
 async function connectServer(name: string, cfg: ServerConfig, timeout: number, opts: McpLoadOptions, store: TokenStore, sdkClient: () => Client, onSdk: (c: Client) => void): Promise<Connected> {
+  const { newOAuth, probe } = await loadMcp2026()
   const o: Load2026Options = { waitFor: opts.waitFor, tokenStore: store, openUrl: opts.openUrl, signal: opts.signal, disableTools: opts.disableTools }
   const remote = isRemote(cfg)
   const oauth = remote ? newOAuth(cfg.auth, o, store) : undefined
@@ -570,7 +596,10 @@ async function connectServer(name: string, cfg: ServerConfig, timeout: number, o
   if (p.kind === "modern") return p
   const client = sdkClient()
   onSdk(client)
-  await raceTimeout(connectTransport(client, cfg, oauth ? { oauth, waitFor: opts.waitFor } : undefined), timeout, opts.signal)
+  const connecting = p.reuse
+    ? client.connect(new AdoptedStdioTransport(p.reuse.child, p.reuse.leftover)) // §2.2a: same child, no respawn
+    : connectTransport(client, cfg, oauth ? { oauth, waitFor: opts.waitFor } : undefined)
+  await raceTimeout(connecting, timeout, opts.signal)
   const defs = await raceTimeout(paginateTools(client, timeout), timeout, opts.signal)
   return { kind: "sdk", client, defs }
 }
@@ -596,7 +625,7 @@ export async function loadMcp(
   const clients: { close(): Promise<void> }[] = []
   const servers = new Map<string, ServerConn>()
   const skills: SkillDef[] = []
-  const store = defaultTokenStore({ tokenStore: opts?.tokenStore })
+  const store = (await loadMcp2026()).defaultTokenStore({ tokenStore: opts?.tokenStore })
   const waitFor = opts?.waitFor
   const signal = opts?.signal
   const onServer = opts?.onServer
@@ -701,7 +730,7 @@ export async function listMcpTools(input: string | object, opts?: McpLoadOptions
   const toolsByServer: Record<string, ToolInfo[]> = {}
   const status: Record<string, McpStatus> = {}
   const signal = opts?.signal
-  const store = defaultTokenStore({ tokenStore: opts?.tokenStore })
+  const store = (await loadMcp2026()).defaultTokenStore({ tokenStore: opts?.tokenStore })
 
   await Promise.all(
     Object.entries(config).map(async ([name, cfg]) => {

package/src/mcp2026/source.ts

@@ -8,7 +8,8 @@ import { randomBytes } from "node:crypto"
 import { Mcp2026Client } from "./client.js"
 import { HttpStatusError, NotJsonRpcError, PROTOCOL_VERSION, RpcError, SKILLS_EXT, type Obj } from "./protocol.js"
 import { LoopbackAuthorizer, MemoryTokenStore, OAuth, PauseAuthorizer, PendingError, type TokenStore } from "./auth.js"
-import { spawnStdio, StdioClosedError } from "./stdio.js"
+import { spawnStdio, StdioClosedError, type StdioTransport } from "./stdio.js"
+import type { ChildProcess } from "node:child_process"
 import { rank } from "./toolsearch.js"
 import type { Answer, JSONSchema, Request, Tool, ToolContext, ToolResult } from "../types.js"
 import { sanitize } from "../types.js"
@@ -88,7 +89,9 @@ async function authed(oauth: OAuth | undefined, waitFor: WaitFor | undefined, f:
 }
 
 /** What the probe decided. `fallback` ⇒ take the frozen SDK path; anything thrown ⇒ status failed. */
-export type Probe = { kind: "modern"; server: ModernServer } | { kind: "fallback" }
+export type Probe =
+  | { kind: "modern"; server: ModernServer }
+  | { kind: "fallback"; reuse?: { child: ChildProcess; leftover: Buffer } }
 
 /** §2.2a: which discover failures mean "old server". */
 function isFallbackError(e: unknown): boolean {
@@ -115,11 +118,14 @@ export interface ProbeTarget {
 /** Discover first (§2.2). Resolves `modern` (tools listed) or `fallback`; throws on a load failure. */
 export async function probe(t: ProbeTarget, o: Load2026Options): Promise<Probe> {
   let client: Mcp2026Client
+  let stdio: StdioTransport | undefined
   if (t.remote) {
     client = new Mcp2026Client(t.remote.url, { headers: t.remote.headers, auth: t.remote.oauth, timeoutMs: t.timeout })
   } else {
-    const tr = await spawnStdio(t.local!.argv, t.local!.env, t.local!.cwd)
-    client = new Mcp2026Client("", { transport: tr, timeoutMs: t.timeout })
+    stdio = await spawnStdio(t.local!.argv, t.local!.env, t.local!.cwd)
+    // Stop parsing right after the discover reply so an old server's child can be handed over.
+    stdio.holdAfterNextResponse()
+    client = new Mcp2026Client("", { transport: stdio, timeoutMs: t.timeout })
   }
   const oauth = t.remote?.oauth
   let disc: Obj
@@ -129,6 +135,8 @@ export async function probe(t: ProbeTarget, o: Load2026Options): Promise<Probe>
     disc = await authed(oauth, o.waitFor, () => client.call("server/discover", {}, { timeoutMs, signal: o.signal }))
   } catch (e) {
     const stdioTimeout = !!t.local && e instanceof Error && e.message === "stdio request timed out"
+    // §2.2a: a fast JSON-RPC error over stdio ⇒ the SAME child continues into initialize.
+    if (stdio && e instanceof RpcError && !o.signal?.aborted) return { kind: "fallback", reuse: stdio.detach() }
     await client.close().catch(() => {})
     if (o.signal?.aborted) throw e
     if (e instanceof StdioClosedError) throw e
@@ -136,9 +144,11 @@ export async function probe(t: ProbeTarget, o: Load2026Options): Promise<Probe>
     throw e
   }
   if (!supports2026(disc)) {
+    if (stdio) return { kind: "fallback", reuse: stdio.detach() }
     await client.close().catch(() => {})
     return { kind: "fallback" }
   }
+  stdio?.release()
   try {
     const server = new ModernServer(t, client, disc, o)
     await server.load()

package/src/mcp2026/stdio.ts

@@ -4,10 +4,12 @@
  * pending call instead of hanging. No headers, no auth.
  */
 import { spawn, type ChildProcess } from "node:child_process"
-import { createInterface } from "node:readline"
 import type { Readable } from "node:stream"
 import type { Transport } from "./client.js"
 import type { Obj } from "./protocol.js"
+import type { Transport as SdkTransport } from "@modelcontextprotocol/sdk/shared/transport.js"
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js"
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js"
 
 /** The child exited / closed stdout before answering. */
 export class StdioClosedError extends Error {}
@@ -18,33 +20,89 @@ export class StdioTransport implements Transport {
   private done: Promise<void>
   private child: ChildProcess
 
+  private buf: Buffer = Buffer.alloc(0)
+  private onData: (chunk: Buffer) => void
+  private onEnd: () => void
+  private detached = false
+  private hold = false
+  private held = false
+
   constructor(child: ChildProcess) {
     this.child = child
-    const rl = createInterface({ input: child.stdout as Readable, crlfDelay: Infinity })
-    rl.on("line", (line) => {
-      let m: any
-      try {
-        m = JSON.parse(line)
-      } catch {
-        return // noise
-      }
-      if (!m || typeof m !== "object" || m.method !== undefined || m.id === undefined || m.id === null) return // not a response
-      const key = JSON.stringify(m.id)
-      const f = this.pending.get(key)
-      this.pending.delete(key)
-      f?.(m)
-    })
-    this.done = new Promise((r) =>
-      rl.once("close", () => {
-        this.err ??= new StdioClosedError("stdio server closed its stdout")
-        for (const f of this.pending.values()) f({ __closed: true })
-        this.pending.clear()
-        r()
-      }),
-    )
+    // Line-exact own reader (no readline): detach() can stop it and hand over unread bytes.
+    let closed!: () => void
+    this.done = new Promise<void>((r) => (closed = r))
+    this.onData = (chunk: Buffer) => {
+      this.buf = this.buf.length ? Buffer.concat([this.buf, chunk]) : chunk
+      this.drain()
+    }
+    this.onEnd = () => {
+      this.err ??= new StdioClosedError("stdio server closed its stdout")
+      for (const f of this.pending.values()) f({ __closed: true })
+      this.pending.clear()
+      closed()
+    }
+    const out = child.stdout as Readable
+    out.on("data", this.onData)
+    out.once("end", this.onEnd)
+    out.once("close", this.onEnd)
     child.stdin?.on("error", () => {}) // EPIPE after the server died surfaces as a closed stdout
   }
 
+  private drain(): void {
+    let nl: number
+    while (!this.detached && !this.held && (nl = this.buf.indexOf(10)) >= 0) {
+      const line = this.buf.subarray(0, nl).toString("utf8").replace(/\r$/, "")
+      this.buf = this.buf.subarray(nl + 1)
+      this.onLine(line)
+    }
+  }
+
+  /** Probe mode: after the next delivered response, stop parsing (bytes stay buffered for detach). */
+  holdAfterNextResponse(): void {
+    this.hold = true
+  }
+
+  /** Leave probe mode and parse whatever was held. */
+  release(): void {
+    this.hold = false
+    this.held = false
+    this.drain()
+  }
+
+  private onLine(line: string): void {
+    let m: any
+    try {
+      m = JSON.parse(line)
+    } catch {
+      return // noise
+    }
+    if (!m || typeof m !== "object" || m.method !== undefined || m.id === undefined || m.id === null) return // not a response
+    const key = JSON.stringify(m.id)
+    const f = this.pending.get(key)
+    this.pending.delete(key)
+    if (f && this.hold) this.held = true
+    f?.(m)
+  }
+
+  /**
+   * §2.2a handoff: stop reading stdout (listeners removed, stream paused — no read left pending)
+   * and give the live child plus any bytes already read past the last delivered line to the
+   * frozen path. The transport is unusable afterwards; the child is NOT killed.
+   */
+  detach(): { child: ChildProcess; leftover: Buffer } {
+    this.detached = true
+    const out = this.child.stdout as Readable
+    out.off("data", this.onData)
+    out.off("end", this.onEnd)
+    out.off("close", this.onEnd)
+    out.pause()
+    this.err ??= new StdioClosedError("stdio transport detached")
+    const leftover = this.buf
+    this.buf = Buffer.alloc(0)
+    return { child: this.child, leftover }
+  }
+
   /** Writes one line and waits for the response with the same id. Never retried. */
   roundTrip(id: number, body: string, timeoutMs: number, signal?: AbortSignal): Promise<Obj> {
     if (this.err) return Promise.reject(this.err)
@@ -100,3 +158,70 @@ export function spawnStdio(argv: string[], env: NodeJS.ProcessEnv, cwd?: string)
     child.once("spawn", () => resolve(new StdioTransport(child)))
   })
 }
+
+/**
+ * §2.2a: the frozen SDK path over a child the probe already started (StdioClientTransport always
+ * spawns). Takes the detached probe's stdin/stdout plus any bytes it had read but not parsed.
+ */
+export class AdoptedStdioTransport implements SdkTransport {
+  onclose?: () => void
+  onerror?: (error: Error) => void
+  onmessage?: (message: JSONRPCMessage) => void
+  private rb = new ReadBuffer()
+  private closed = false
+
+  constructor(private child: ChildProcess, private leftover: Buffer) {}
+
+  async start(): Promise<void> {
+    const out = this.child.stdout as Readable
+    out.on("data", (chunk: Buffer) => this.feed(chunk))
+    out.on("error", (e) => this.onerror?.(e))
+    this.child.stdin?.on("error", (e) => this.onerror?.(e))
+    this.child.once("close", () => this.finish())
+    if (this.leftover.length) this.feed(this.leftover)
+    this.leftover = Buffer.alloc(0)
+    out.resume()
+  }
+
+  private feed(chunk: Buffer): void {
+    this.rb.append(chunk)
+    for (;;) {
+      let m: JSONRPCMessage | null
+      try {
+        m = this.rb.readMessage()
+      } catch (e) {
+        this.onerror?.(e as Error)
+        continue
+      }
+      if (m === null) break
+      this.onmessage?.(m)
+    }
+  }
+
+  send(message: JSONRPCMessage): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.child.stdin?.write(serializeMessage(message))) this.child.stdin?.once("drain", resolve)
+      else resolve()
+    })
+  }
+
+  private finish(): void {
+    if (this.closed) return
+    this.closed = true
+    this.rb.clear()
+    this.onclose?.()
+  }
+
+  /** Close stdin, then SIGKILL after 2 s if the child is still alive. */
+  async close(): Promise<void> {
+    if (this.child.exitCode === null && this.child.signalCode === null) {
+      const exited = new Promise<void>((r) => this.child.once("exit", () => r()))
+      this.child.stdin?.end()
+      const t = setTimeout(() => this.child.kill("SIGKILL"), 2000)
+      await exited
+      clearTimeout(t)
+    }
+    this.child.stdout?.destroy()
+    this.finish()
+  }
+}

package/src/mcphandler.ts

@@ -348,7 +348,7 @@ export function createMcpHandler(toolkitTools: () => Tool[], cfg: McpHandlerConf
   /** Validates protocol header + session (stateful). Writes the HTTP error itself on failure. */
   async function checkSession(ctx: McpContext, req: IncomingMessage, res: ServerResponse): Promise<boolean> {
     const v = header(req, "MCP-Protocol-Version")
-    if (v !== "" && !legacy.includes(v)) {
+    if (v !== "" && !versions.includes(v)) {
       httpError(res, 400, "Bad Request: unsupported MCP-Protocol-Version")
       return false
     }
@@ -775,8 +775,7 @@ export function createMcpHandler(toolkitTools: () => Tool[], cfg: McpHandlerConf
     if (only2026) return true
     if (method === "initialize") return false
     const hv = header(req, "MCP-Protocol-Version")
-    if (hv === MCP_PROTOCOL_2026) return true
-    if (hv !== "" && versions.includes(hv)) return false
+    if (hv !== "" && legacy.includes(hv)) return false
     return method === "server/discover" || header(req, "Mcp-Method") !== "" || (meta !== undefined && META_VERSION in meta)
   }
 

package/src/mcpserve.ts

@@ -16,7 +16,6 @@ import http from "node:http"
 import type { AddressInfo } from "node:net"
 import { randomBytes, timingSafeEqual } from "node:crypto"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js"
 import { ListToolsRequestSchema, CallToolRequestSchema, McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
 import type { Tool, ToolSource, ToolResult } from "./types.js"
 import type { ContentPart } from "./content.js"
@@ -166,6 +165,8 @@ export interface LocalMcpServer {
  */
 export async function serveLocalMcp(tools: Tool[], cfg?: MCPServeConfig): Promise<LocalMcpServer> {
   const exposed = exposedMcpTools(tools, cfg)
+  // Loaded on first serve, not at import: the transport pulls in @hono/node-server.
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js")
   const token = randomBytes(32).toString("hex")
   const want = Buffer.from("Bearer " + token)
   const server = http.createServer((req, res) => {

package/src/nodefetch.ts

@@ -0,0 +1,143 @@
+/**
+ * Default LLM transport: a `fetch`-shaped function over `node:http`/`node:https` with a shared
+ * keep-alive agent.
+ *
+ * Why: Node's built-in `fetch` (undici + web streams) costs ~1.5 ms per local round-trip, against
+ * ~0.3 ms for `node:http` on the same keep-alive socket. With two LLM calls per tool-calling turn
+ * that was most of the client's per-request overhead (benchmarks/run_toolnexus_js.mjs).
+ *
+ * Behavior is kept identical to `fetch` for what the client uses (status, headers incl.
+ * Retry-After, json/text, a streamed `body` for SSE, abort via `signal` rejecting with its reason).
+ * Anything this path does not cover is handed to `globalThis.fetch` unchanged: a proxy env
+ * (`HTTP(S)_PROXY`, `NODE_USE_ENV_PROXY`), a replaced global `fetch`, a non-http(s) URL, a body
+ * that is not a string/bytes, and redirects.
+ */
+import http from "node:http"
+import https from "node:https"
+import { Readable } from "node:stream"
+import zlib from "node:zlib"
+
+const nativeFetch = globalThis.fetch
+const httpAgent = new http.Agent({ keepAlive: true })
+const httpsAgent = new https.Agent({ keepAlive: true })
+
+function proxyEnv(): boolean {
+  const e = process.env
+  return !!(e.HTTP_PROXY || e.HTTPS_PROXY || e.http_proxy || e.https_proxy || e.NODE_USE_ENV_PROXY)
+}
+
+function toHeaderRecord(h: RequestInit["headers"]): Record<string, string> {
+  const out: Record<string, string> = {}
+  if (!h) return out
+  if (h instanceof Headers || Array.isArray(h)) {
+    for (const [k, v] of h as Iterable<[string, string]>) out[k] = v
+    return out
+  }
+  return { ...(h as Record<string, string>) }
+}
+
+// undici's global dispatcher slot. Node fills it lazily with a default Agent on the first fetch;
+// anything else there (a ProxyAgent, a mock, a tuned Agent) means the host routed fetch on purpose.
+const DISPATCHER = Symbol.for("undici.globalDispatcher.1")
+let knownDefaultDispatcher: unknown
+
+function customDispatcher(): boolean {
+  const d = (globalThis as Record<symbol, unknown>)[DISPATCHER]
+  return d !== undefined && d !== knownDefaultDispatcher
+}
+
+/** Calls the platform fetch; if that call is what created Node's default dispatcher, remember it
+ * so later calls still take the fast path. */
+function platformFetch(input: Parameters<typeof fetch>[0], init?: RequestInit): Promise<Response> {
+  const before = (globalThis as Record<symbol, unknown>)[DISPATCHER]
+  const p = globalThis.fetch(input, init)
+  if (before === undefined) {
+    const after = (globalThis as Record<symbol, unknown>)[DISPATCHER]
+    if (after !== undefined) knownDefaultDispatcher = after
+  }
+  return p
+}
+
+const REDIRECTS = new Set([301, 302, 303, 307, 308])
+
+export const nodeFetch: typeof fetch = (input, init) => {
+  const fallback = () => platformFetch(input, init)
+  if (globalThis.fetch !== nativeFetch || proxyEnv() || customDispatcher()) return fallback()
+  if (init?.redirect && init.redirect !== "follow") return fallback()
+  const url = typeof input === "string" ? input : input instanceof URL ? input.href : undefined
+  const body = init?.body
+  if (url === undefined || (body != null && typeof body !== "string" && !(body instanceof Uint8Array))) return fallback()
+  const isHttps = url.startsWith("https:")
+  if (!isHttps && !url.startsWith("http:")) return fallback()
+  const signal = init?.signal ?? undefined
+  if (signal?.aborted) return Promise.reject(signal.reason)
+
+  return new Promise<Response>((resolve, reject) => {
+    const headers = toHeaderRecord(init?.headers)
+    if (body != null && !Object.keys(headers).some((k) => k.toLowerCase() === "content-length")) {
+      headers["content-length"] = String(typeof body === "string" ? Buffer.byteLength(body) : body.byteLength)
+    }
+    const mod = isHttps ? https : http
+    let settled = false
+    const onAbort = () => {
+      req.destroy(signal!.reason)
+      if (!settled) { settled = true; reject(signal!.reason) }
+    }
+    const req = mod.request(url, { method: init?.method ?? "GET", headers, agent: isHttps ? httpsAgent : httpAgent }, (res) => {
+      const status = res.statusCode ?? 0
+      if (REDIRECTS.has(status) && res.headers.location) {
+        // Follow it the way fetch does, from the redirect target: re-sending to the original URL
+        // would reach the server twice. 303, and 301/302 after a POST, become a bodiless GET;
+        // 307/308 repeat the method and body. Further hops are fetch's to follow.
+        res.resume()
+        signal?.removeEventListener("abort", onAbort)
+        settled = true
+        const target = new URL(res.headers.location, url).href
+        const method = (init?.method ?? "GET").toUpperCase()
+        const toGet = status === 303 ? method !== "HEAD" : (status === 301 || status === 302) && method === "POST"
+        let next: RequestInit | undefined = init
+        if (toGet) {
+          const h = toHeaderRecord(init?.headers)
+          for (const k of Object.keys(h)) {
+            if (/^content-(type|length|encoding|language|location)$/i.test(k)) delete h[k]
+          }
+          next = { ...init, method: "GET", body: undefined, headers: h }
+        }
+        platformFetch(target, next).then(resolve, reject)
+        return
+      }
+      const h = new Headers()
+      for (let i = 0; i < res.rawHeaders.length; i += 2) h.append(res.rawHeaders[i], res.rawHeaders[i + 1])
+      let stream: Readable = res
+      const enc = (res.headers["content-encoding"] ?? "").toLowerCase()
+      if (enc === "gzip" || enc === "x-gzip" || enc === "deflate") stream = res.pipe(zlib.createUnzip())
+      else if (enc === "br") stream = res.pipe(zlib.createBrotliDecompress())
+      const nullBody = status === 204 || status === 304 || init?.method === "HEAD"
+      const ctype = (res.headers["content-type"] ?? "").toLowerCase()
+      const done = (b: ConstructorParameters<typeof Response>[0]) => {
+        if (settled) return
+        settled = true
+        resolve(new Response(nullBody ? null : b, { status, statusText: res.statusMessage, headers: h }))
+      }
+      if (ctype.includes("text/event-stream")) {
+        // Streamed: the body is consumed incrementally (SSE). Abort still destroys the socket.
+        stream.once("end", () => signal?.removeEventListener("abort", onAbort))
+        done(Readable.toWeb(stream) as unknown as ReadableStream)
+        return
+      }
+      const chunks: Buffer[] = []
+      stream.on("data", (c: Buffer) => chunks.push(c))
+      stream.once("error", (e) => { if (!settled) { settled = true; reject(e) } })
+      stream.once("end", () => {
+        signal?.removeEventListener("abort", onAbort)
+        done(Buffer.concat(chunks))
+      })
+    })
+    req.once("error", (e) => {
+      signal?.removeEventListener("abort", onAbort)
+      if (!settled) { settled = true; reject(signal?.aborted ? signal.reason : new TypeError("fetch failed", { cause: e })) }
+    })
+    signal?.addEventListener("abort", onAbort, { once: true })
+    req.end(body ?? undefined)
+  })
+}

package/src/serve.ts

@@ -18,7 +18,8 @@ import http from "node:http"
 import fs from "node:fs"
 import path from "node:path"
 import { randomUUID } from "node:crypto"
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js"
+// The SDK server transport (and the @hono/node-server it pulls in) is loaded only when an MCP
+// profile is actually served, so importing toolnexus does not pay for it.
 import { sanitize, type Tool } from "./types.js"
 import type { SkillInfo } from "./skill.js"
 import type { RunResult } from "./client.js"
@@ -213,6 +214,9 @@ export async function startA2AServer(opts: StartServerOptions): Promise<ServeHan
   const [host, portStr] = splitAddr(opts.addr)
   const store = a2a ? resolveStore(a2a.store) : undefined
   const exposedTools = mcp ? exposedMcpTools(mcpTools ?? [], mcp) : []
+  const StreamableHTTPServerTransport = mcp
+    ? (await import("@modelcontextprotocol/sdk/server/streamableHttp.js")).StreamableHTTPServerTransport
+    : undefined
 
   const server = http.createServer((req, res) => {
     const rpcRes = (id: unknown, payload: object) => {
@@ -244,7 +248,7 @@ export async function startA2AServer(opts: StartServerOptions): Promise<ServeHan
         const body = req.method === "POST" ? await readBody(req) : ""
         const parsed = body ? safeJson(body) : undefined
         const mcpServer = buildMcpServer(exposedTools, mcp, onCall)
-        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined })
+        const transport = new StreamableHTTPServerTransport!({ sessionIdGenerator: undefined })
         res.on("close", () => {
           void transport.close()
           void mcpServer.close()