@procedures/mcp-server 0.8.0 → 0.9.0

package/src/procedures/mcp/serve.ts

@@ -9,6 +9,9 @@
  * (default: `@procedures/bundle-mcp`, resolved from the current folder). Without a list,
  * nothing is exposed. The nested calls follow the call policy (`strictCalls`), and each tool call
  * has a time limit.
+ *
+ * The server comes from `createMcpHost()` (CLI-10), so its options come from `hostPolicy()` of the
+ * core, as for the dev-tools server. Before, `mcp.serve` built them by hand.
  */
 
 import { z } from "zod";
@@ -17,14 +20,13 @@ import {
   ProcedureServer,
   PROCEDURE_REGISTRY,
   ProcedureRegistry,
-  timeoutInterceptor,
   type AnyProcedure,
   type ProcedureContext,
   type ProcedurePath,
+  type ToolSurface,
 } from "@procedures/client";
-import { McpServerTransport } from "../../transport/mcp-transport.js";
-import type { McpServerTransportOptions } from "../../types.js";
 import { exposeRule, importBundles, mergeSurfaces } from "../../surface.js";
+import { createMcpHost, type McpHost, type McpHostFaces } from "../../host.js";
 import { ms } from "@procedures/client";
 
 /** The default bundle of the tool surface. */
@@ -54,6 +56,10 @@ const McpServeInputSchema = z.object({
   strictCalls: z.boolean().default(true).describe("True (the default): a procedure of code without metadata.calls can call only tools."),
   /** The time limit of each tool call, in milliseconds (default: 600000). 0: no limit. */
   toolTimeoutMs: z.number().int().min(0).default(600_000).describe("The time limit of each tool call, in milliseconds (default: 600000). 0: no limit."),
+  /** True: the tools are only the procedures that change nothing, and each call has that capability. */
+  readOnly: z.boolean().default(false).describe("True: the tools are only the procedures that change nothing, and each call has that capability."),
+  /** The instructions of the server: the MCP client gives them to the model. */
+  instructions: z.string().optional().describe("The instructions of the server: the MCP client gives them to the model."),
 });
 
 type McpServeInput = z.infer<typeof McpServeInputSchema>;
@@ -83,12 +89,26 @@ export interface ServeOptions {
   bundles?: readonly string[] | undefined;
   strictCalls?: boolean | undefined;
   toolTimeoutMs?: number | undefined;
+  /** True: the tools are only the procedures that change nothing. */
+  readOnly?: boolean | undefined;
+  /** The name of the server for the MCP client. */
+  name?: string | undefined;
+  /** The version of the server for the MCP client. */
+  version?: string | undefined;
+  /** The instructions of the server. */
+  instructions?: string | undefined;
+  /** True: debug lines go to stderr. */
+  debug?: boolean | undefined;
+  /** The faces of the host. The default is stdio. */
+  faces?: McpHostFaces | undefined;
 }
 
 /** The server of `mcp.serve`, before its transport starts. */
 export interface ServeSetup {
   server: ProcedureServer;
   expose: (path: ProcedurePath) => boolean;
+  /** The MCP host of the server: `host.start()` starts its faces. */
+  host: McpHost;
   /** Why the server has no tools, when it has none. */
   warning?: string;
 }
@@ -105,16 +125,17 @@ export async function prepareServe(
   from: string = process.cwd(),
   registry: ProcedureRegistry = PROCEDURE_REGISTRY
 ): Promise<ServeSetup> {
-  let expose: (path: ProcedurePath) => boolean = () => false;
+  // Without a surface, nothing is a tool
+  let surface: ToolSurface | ((path: ProcedurePath) => boolean) = () => false;
   let warning: string | undefined;
   if (input.namespaces) {
-    expose = exposeRule({ namespaces: input.namespaces, exclude: input.exclude });
+    surface = { namespaces: input.namespaces, exclude: input.exclude };
   } else {
     const bundles = input.bundles ?? [DEFAULT_SERVE_BUNDLE];
     try {
-      const surface = mergeSurfaces(await importBundles(bundles, from));
-      if (surface) {
-        expose = exposeRule({ namespaces: surface.namespaces, exclude: [...(surface.exclude ?? []), ...(input.exclude ?? [])] });
+      const merged = mergeSurfaces(await importBundles(bundles, from));
+      if (merged) {
+        surface = { namespaces: merged.namespaces, exclude: [...(merged.exclude ?? []), ...(input.exclude ?? [])] };
       } else {
         warning = `The bundles ${bundles.join(", ")} give no mcpNamespaces, so no procedure is a tool. Give namespaces.`;
       }
@@ -125,14 +146,23 @@ export async function prepareServe(
     }
   }
 
-  const server = new ProcedureServer({
-    autoRegister: input.autoRegister ?? true,
+  const host = createMcpHost({
     registry,
-    expose,
-    strictCalls: input.strictCalls ?? true,
-    interceptors: [timeoutInterceptor({ limit: ms(input.toolTimeoutMs ?? 600_000) })],
+    surface,
+    readOnly: input.readOnly === true,
+    policy: { strictCalls: input.strictCalls ?? true, timeout: ms(input.toolTimeoutMs ?? 600_000) },
+    serverOptions: { autoRegister: input.autoRegister ?? true },
+    ...(input.name !== undefined ? { name: input.name } : {}),
+    ...(input.version !== undefined ? { version: input.version } : {}),
+    ...(input.instructions !== undefined ? { instructions: input.instructions } : {}),
+    ...(input.debug !== undefined ? { debug: input.debug } : {}),
+    faces: input.faces ?? { stdio: true },
   });
-  return warning === undefined ? { server, expose } : { server, expose, warning };
+  // A surface always gives a rule, so the host has one
+  const expose = host.expose ?? (typeof surface === "function" ? surface : exposeRule(surface));
+  const setup: ServeSetup = { server: host.server, expose, host };
+  if (warning !== undefined) setup.warning = warning;
+  return setup;
 }
 
 export const mcpServeProcedure: AnyProcedure = defineProcedure({
@@ -150,33 +180,21 @@ export const mcpServeProcedure: AnyProcedure = defineProcedure({
     const serverVersion = input.version ?? "1.0.0";
     // The registry of the caller: a host with its own registry serves its own procedures
     const registry = ctx?.registry instanceof ProcedureRegistry ? ctx.registry : PROCEDURE_REGISTRY;
-    const { server, expose, warning } = await prepareServe(input, process.cwd(), registry);
-
-    // Build transport options
-    const options: McpServerTransportOptions = {
-      transport: input.transport,
-      serverInfo: {
-        name: serverName,
-        version: serverVersion,
-      },
-      debug: input.debug,
-      toolFilter: { include: expose },
-    };
-
-    // Create MCP transport
-    const mcpTransport = new McpServerTransport(server, options);
-
-    // Add transport and start
-    server.addTransport(mcpTransport);
-    await server.start();
-
-    const state = mcpTransport.getState();
+    const { host, warning } = await prepareServe(
+      { ...input, name: serverName, version: serverVersion, faces: { stdio: true } },
+      process.cwd(),
+      registry,
+    );
+    // The face of stdio: it stops the host when the client closes the input
+    await host.start();
+
+    const toolCount = host.state().faces[0]?.toolCount ?? host.tools().length;
     if (warning) console.error(`[mcp.serve] ${warning}`);
 
     return {
       success: true,
       transport: input.transport,
-      toolCount: state.toolCount,
+      toolCount,
       serverName,
       ...(warning ? { warning } : {}),
     };

package/src/transport/http.ts

@@ -8,13 +8,17 @@
  * a local server apply: the server listens on loopback by default, it refuses a web page of
  * another host or origin (DNS rebinding, cross-site requests), and with a token it refuses a
  * request without the token.
+ *
+ * Each tool call carries the credentials of its HTTP request (CLI-10), so the request hook of the
+ * server (`principalOf`) and its token check apply. A server that reads cookies trusts a request
+ * with a cookie only from a named origin (CSRF).
  */
 
 import { randomUUID } from "node:crypto";
 import { createServer, type IncomingMessage, type Server as HttpServer, type ServerResponse } from "node:http";
 import type { AddressInfo } from "node:net";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { bearerOf, checkBrowserRequest, tokenMatches } from "@procedures/client";
+import { bearerOf, checkBrowserRequest, hasAmbientCredentials, tokenMatches } from "@procedures/client";
 import type { HttpTransportOptions } from "../types.js";
 
 /** The HTTP endpoint of an MCP server, with a session for each client. */
@@ -71,8 +75,10 @@ export function createHttpTransport(
       if (owned) refuse(res, 404, "NOT_FOUND", `No MCP endpoint at ${url.pathname}`);
       return;
     }
-    // A web page must not reach the tools: the host and the origin of the request
-    const guard = checkBrowserRequest(req, { ...(options.allowedOrigins ? { allowedOrigins: options.allowedOrigins } : {}) });
+    // A web page must not reach the tools: the host and the origin of the request. A server that
+    // reads cookies trusts a request with ambient credentials only from a named origin (CSRF)
+    const ambient = options.ambientCredentials === "always" || hasAmbientCredentials(req.headers);
+    const guard = checkBrowserRequest(req, { ...(options.allowedOrigins ? { allowedOrigins: options.allowedOrigins } : {}) }, false, ambient);
     if (!guard.ok) {
       refuse(res, guard.status, guard.code, guard.message);
       return;

package/src/transport/mcp-transport.ts

@@ -12,19 +12,63 @@ import {
   type ServerNotification,
 } from "@modelcontextprotocol/sdk/types.js";
 import type { Transport as SdkTransport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { ServerTransport, Server, ProcedureRegistry } from "@procedures/client";
-import { PROCEDURE_REGISTRY, pathToMethod } from "@procedures/client";
+import type {
+  ServerTransport,
+  Server,
+  ProcedureRegistry,
+  RequestHandler,
+  Credentials,
+  Elicit,
+  ElicitMode,
+  ElicitRequest,
+  ElicitResult,
+  ElicitOptions,
+  ReportProgress,
+} from "@procedures/client";
+import { PROCEDURE_REGISTRY, pathToMethod, createElicit, elicitWithPolicy, requestCredentials, untrustedTextsOf } from "@procedures/client";
 import {
   proceduresToMcpTools,
   toToolDefinition,
-  decodePath,
   type McpTool,
 } from "@procedures/mcp";
-import type { McpServerTransportOptions, McpServerTransportState } from "../types.js";
+import type { McpServerTransportOptions, McpServerTransportState, McpTextBlock, McpToolContent } from "../types.js";
 import { createStdioTransport } from "./stdio.js";
 import { createSseTransport } from "./sse.js";
 import { createHttpTransport, type McpHttpTransport } from "./http.js";
 import { optionalMs } from "@procedures/client";
+import { createUntrustedEnvelopes } from "../untrusted.js";
+
+/**
+ * The tools with the names of a `toolName` function. Without the function, the tools keep the
+ * default names.
+ */
+export function namedTools(tools: readonly McpTool[], toolName?: ((path: readonly string[]) => string) | undefined): McpTool[] {
+  return toolName ? tools.map((tool) => ({ ...tool, name: toolName(tool.procedurePath) })) : [...tools];
+}
+
+/** The time that the face waits for the answer of the person, when the question gives no time. */
+export const DEFAULT_ELICIT_TIMEOUT_MS = 300_000;
+
+/** The parts of the request handler context of the SDK that a tool call uses. */
+interface CallExtra {
+  signal: AbortSignal;
+  requestId: string | number;
+  _meta?: { progressToken?: string | number | undefined } | undefined;
+  sendNotification: (notification: ServerNotification) => Promise<void>;
+  /** The HTTP request of the message: present only for a network transport (Streamable HTTP) */
+  requestInfo?: { headers: Record<string, string | string[] | undefined>; url?: URL | undefined } | undefined;
+}
+
+/**
+ * The credentials of a tool call that came over the network (CLI-10): the bearer token, the
+ * cookies, the headers and the query of its HTTP request. A call over stdio or an in-memory
+ * transport has none: it comes from this process.
+ */
+function callCredentials(extra: CallExtra): Credentials | undefined {
+  const info = extra.requestInfo;
+  if (!info) return undefined;
+  return requestCredentials({ headers: info.headers, url: info.url ? `${info.url.pathname}${info.url.search}` : undefined });
+}
 
 /**
  * Generate a unique request ID.
@@ -32,8 +76,10 @@ import { optionalMs } from "@procedures/client";
 /** The most text blocks of a stream result: the last items of a long stream. */
 const MAX_STREAM_BLOCKS = 100;
 
-function toText(value: unknown): string {
-  return typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? String(value));
+/** The text of a value: a string as it is, another value as JSON (pretty, or compact on one line). */
+function toText(value: unknown, json: "pretty" | "compact" = "pretty"): string {
+  if (typeof value === "string") return value;
+  return (json === "compact" ? JSON.stringify(value) : JSON.stringify(value, null, 2)) ?? String(value);
 }
 
 /**
@@ -95,6 +141,8 @@ export class McpServerTransport implements ServerTransport {
   private listChangedTimer: ReturnType<typeof setTimeout> | undefined;
   /** The limits of a stream that can run without an end, the time in milliseconds (R15) */
   private readonly streamLimits: { items: number; timeMs: number };
+  /** This function removes the listener of the end of the stdio input */
+  private stdinEnd: (() => void) | undefined;
 
   constructor(server: Server, options: McpServerTransportOptions = {}) {
     this.server = server;
@@ -134,6 +182,8 @@ export class McpServerTransport implements ServerTransport {
       capabilities: {
         tools: { listChanged: true },
       },
+      // The instructions of the server: the client gives them to the model (CLI-10)
+      ...(this.options.instructions !== undefined ? { instructions: this.options.instructions } : {}),
     });
     this.setupHandlers(server);
     return server;
@@ -170,11 +220,13 @@ export class McpServerTransport implements ServerTransport {
         };
       }
 
-      // Decode path from tool name. The method is the core mapping of every host (deep dive
-      // architecture review 3.3)
-      const path = decodePath(name);
+      // The path of the procedure of the tool. The method is the core mapping of every host
+      // (deep dive architecture review 3.3). A tool name of the toolName option does not decode,
+      // and a sanitized segment does not decode to the segment of the procedure.
+      const path = tool.procedurePath;
 
       // Build ServerRequest
+      const credentials = callCredentials(extra as CallExtra);
       const serverRequest = {
         id: generateRequestId(),
         method: pathToMethod(path),
@@ -185,26 +237,41 @@ export class McpServerTransport implements ServerTransport {
         },
         // A cancelled tool call (notifications/cancelled) aborts the procedure
         signal: extra.signal,
+        // The credentials of a call over the network: the request hook (principalOf) and the
+        // token check of the server apply to it (CLI-10)
+        ...(credentials ? { credentials } : {}),
+      };
+      // What this face offers the procedure (CLI-12): the questions to the person, and the
+      // progress for a caller that sent a progress token
+      const elicit = elicitWithPolicy(this.faceElicit(server, extra), this.options.elicitation);
+      const progress = this.callProgress(extra);
+      const callRequest = {
+        ...serverRequest,
+        ...(elicit ? { elicit } : {}),
+        ...(progress ? { progress: progress.report } : {}),
       };
 
       try {
         // Process through universal server
-        const response = await this.server.handle(serverRequest);
+        const response = await this.server.handle(callRequest);
 
         this.log(`Tool ${name} completed: ${response.status.type}`);
 
         // Convert to MCP result
         if (response.status.type === "success" && response.stream) {
           const unbounded = response.metadata?.["stream"] === "unbounded";
-          return await this.streamResult(response.stream, extra, unbounded);
+          // The items are the progress of a stream, unless the procedure reports its own
+          return await this.streamResult(response.stream, extra, unbounded, tool, () => progress?.used() === true);
         }
         if (response.status.type === "success") {
-          const structured = tool.outputSchema ? structuredContentOf(response.payload) : undefined;
+          const rendered = this.render(response.payload, tool);
+          const hooked = this.options.content?.({ ...rendered, tool, value: response.payload });
+          const result = hooked ?? rendered;
           return {
-            content: [{ type: "text" as const, text: toText(response.payload) }],
+            content: result.content,
             // MCP structured output: the result as an object, for a tool with an output schema.
             // The text block stays, for clients that do not read structured content.
-            ...(structured ? { structuredContent: structured } : {}),
+            ...(result.structuredContent ? { structuredContent: result.structuredContent } : {}),
           };
         } else {
           // The code and the reason of the error travel on each face (roadmap R25)
@@ -247,7 +314,9 @@ export class McpServerTransport implements ServerTransport {
       _meta?: { progressToken?: string | number | undefined } | undefined;
       sendNotification: (notification: ServerNotification) => Promise<void>;
     },
-    unbounded = false
+    unbounded = false,
+    tool?: McpTool,
+    ownProgress: () => boolean = () => false
   ): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
     const progressToken = extra._meta?.progressToken;
     const blocks: Array<{ type: "text"; text: string }> = [];
@@ -265,14 +334,17 @@ export class McpServerTransport implements ServerTransport {
           count--;
           break;
         }
-        const text = toText(item);
+        // An item with untrusted fields gives its data, then its envelopes (CLI-10)
+        const rendered = tool?.untrusted ? this.render(item, tool).content : undefined;
+        const text = rendered ? rendered.map((block) => block.text).join("\n") : toText(item, this.options.json);
         blocks.push({ type: "text", text });
         if (blocks.length > MAX_STREAM_BLOCKS) blocks.shift();
-        if (progressToken !== undefined) {
+        if (progressToken !== undefined && !ownProgress()) {
+          const message = rendered ? rendered[0]!.text : text;
           await extra
             .sendNotification({
               method: "notifications/progress",
-              params: { progressToken, progress: count, message: text.slice(0, 1000) },
+              params: { progressToken, progress: count, message: message.slice(0, 1000) },
             })
             .catch(() => undefined);
         }
@@ -291,6 +363,96 @@ export class McpServerTransport implements ServerTransport {
     return { content: blocks };
   }
 
+  /**
+   * The content of a successful value. A tool with untrusted fields (`metadata.untrusted`) gives
+   * the data as JSON in the first block. The second block has the texts of those fields in
+   * envelopes. In the structured content, each untrusted field is the text of its envelopes.
+   */
+  private render(value: unknown, tool: McpTool): McpToolContent {
+    const fields = tool.untrusted ?? [];
+    if (fields.length === 0 || value === null || typeof value !== "object" || Array.isArray(value)) {
+      const structured = tool.outputSchema ? structuredContentOf(value) : undefined;
+      return { content: [{ type: "text", text: toText(value, this.options.json) }], ...(structured ? { structuredContent: structured } : {}) };
+    }
+    const data: Record<string, unknown> = { ...(value as Record<string, unknown>) };
+    const envelopes = createUntrustedEnvelopes(this.options.untrusted ?? {});
+    const wrap = this.options.untrusted?.wrap;
+    const texts: Record<string, string> = {};
+    const blocks: string[] = [];
+    for (const field of fields) {
+      if (!(field in data)) continue;
+      const items = untrustedTextsOf(data[field]);
+      delete data[field];
+      const text = wrap ? wrap(items, { tool: tool.name, field }) : envelopes.text(items);
+      texts[field] = text;
+      if (text !== "") blocks.push(text);
+    }
+    const content: McpTextBlock[] = [{ type: "text", text: toText(data, this.options.json) }];
+    if (blocks.length > 0) content.push({ type: "text", text: blocks.join("\n") });
+    const structured = tool.outputSchema ? structuredContentOf(data) : undefined;
+    return { content, ...(structured ? { structuredContent: { ...structured, ...texts } } : {}) };
+  }
+
+  /**
+   * The function of this face that asks the person, or undefined when the client cannot ask
+   * (it declares no elicitation). Each question goes with the tool call (`relatedRequestId`), so
+   * the Streamable HTTP transport sends it on the stream of the call.
+   */
+  private faceElicit(server: McpServer, extra: CallExtra): Elicit | undefined {
+    const capability = server.getClientCapabilities()?.elicitation as { form?: unknown; url?: unknown } | undefined;
+    if (!capability) return undefined;
+    const modes: ElicitMode[] = [];
+    if (capability.form) modes.push("form");
+    if (capability.url) modes.push("url");
+    if (modes.length === 0) return undefined;
+    return createElicit(modes, async (request: ElicitRequest, options: ElicitOptions): Promise<ElicitResult> => {
+      const timeout = optionalMs(options.timeout, "timeout") ?? DEFAULT_ELICIT_TIMEOUT_MS;
+      const signal = options.signal && options.signal !== extra.signal ? AbortSignal.any([extra.signal, options.signal]) : extra.signal;
+      const params =
+        request.mode === "url"
+          ? { mode: "url" as const, message: request.message, url: request.url, elicitationId: request.id ?? globalThis.crypto.randomUUID() }
+          : {
+              mode: "form" as const,
+              message: request.message,
+              requestedSchema: {
+                type: "object" as const,
+                properties: request.fields,
+                ...(request.required ? { required: [...request.required] } : {}),
+              },
+            };
+      // The SDK types do not agree with exactOptionalPropertyTypes and readonly arrays
+      const reply = await server.elicitInput(params as never, { relatedRequestId: extra.requestId, signal, timeout });
+      return { action: reply.action, ...(reply.content ? { content: reply.content } : {}), by: "person" };
+    });
+  }
+
+  /**
+   * The progress function of a call, when the caller sent a progress token. `used()` tells if
+   * the procedure reported its own progress.
+   */
+  private callProgress(extra: CallExtra): { report: ReportProgress; used: () => boolean } | undefined {
+    const progressToken = extra._meta?.progressToken;
+    if (progressToken === undefined) return undefined;
+    let used = false;
+    return {
+      used: () => used,
+      report: async (update) => {
+        used = true;
+        await extra
+          .sendNotification({
+            method: "notifications/progress",
+            params: {
+              progressToken,
+              progress: update.progress,
+              ...(update.total !== undefined ? { total: update.total } : {}),
+              ...(update.message !== undefined ? { message: update.message.slice(0, 1000) } : {}),
+            },
+          })
+          .catch(() => undefined);
+      },
+    };
+  }
+
   private setupRegistryListeners(): void {
     // Create listener functions that we can later remove
     this.registerListener = () => {
@@ -331,7 +493,11 @@ export class McpServerTransport implements ServerTransport {
     const before = this.toolSignature();
 
     this.tools.clear();
-    for (const tool of mcpTools) {
+    for (const tool of namedTools(mcpTools, this.options.toolName)) {
+      if (this.tools.has(tool.name)) {
+        // MUST be stderr: stdout carries the protocol of stdio
+        console.error(`[mcp] Two procedures have the tool name "${tool.name}": the transport keeps ${tool.procedurePath.join(".")}`);
+      }
       this.tools.set(tool.name, tool);
     }
 
@@ -390,11 +556,26 @@ export class McpServerTransport implements ServerTransport {
         transport = this.options.sdkTransport;
         this.log("Using the given transport");
       } else if (this.options.transport === "stdio") {
-        transport = createStdioTransport();
+        const stdio = this.options.stdio;
+        const stdin = stdio?.stdin ?? process.stdin;
+        transport = createStdioTransport(stdin, stdio?.stdout);
+        // The client closed the input: the host stops (CLI-10). The SDK does not watch the end.
+        if (stdio?.onEnd) {
+          const onEnd = stdio.onEnd;
+          const listener = (): void => {
+            this.log("The input of stdio ended");
+            onEnd();
+          };
+          stdin.once("end", listener);
+          this.stdinEnd = () => stdin.off("end", listener);
+        }
         this.log("Using stdio transport");
       } else if (this.options.transport === "http") {
         // Streamable HTTP (roadmap R26): an MCP server of its own for each session
-        this.http = createHttpTransport(this.options.httpOptions ?? {}, async (sessionTransport) => {
+        // The face trusts cookies only as the server reads them (CSRF)
+        const ambientCredentials = (this.server as Partial<RequestHandler>).ambientCredentials;
+        const httpOptions = { ...this.options.httpOptions, ...(ambientCredentials ? { ambientCredentials } : {}) };
+        this.http = createHttpTransport(httpOptions, async (sessionTransport) => {
           const sessionServer = this.createSdkServer();
           this.sessionServers.add(sessionServer);
           sessionServer.onclose = () => this.sessionServers.delete(sessionServer);
@@ -416,6 +597,8 @@ export class McpServerTransport implements ServerTransport {
       }
     } catch (error) {
       this.removeRegistryListeners();
+      this.stdinEnd?.();
+      this.stdinEnd = undefined;
       await this.http?.close().catch(() => undefined);
       this.http = undefined;
       throw error;
@@ -435,6 +618,8 @@ export class McpServerTransport implements ServerTransport {
 
     // Cleanup registry listeners
     this.removeRegistryListeners();
+    this.stdinEnd?.();
+    this.stdinEnd = undefined;
     if (this.listChangedTimer) {
       clearTimeout(this.listChangedTimer);
       this.listChangedTimer = undefined;

package/src/transport/stdio.ts

@@ -4,16 +4,18 @@
  * Creates an MCP stdio transport for CLI usage.
  */
 
+import type { Readable, Writable } from "node:stream";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 /**
  * Create a stdio transport for MCP server.
  *
  * Stdio transport uses standard input/output for communication,
- * suitable for CLI tools and desktop app integrations.
+ * suitable for CLI tools and desktop app integrations. A test or an embedding gives other
+ * streams: the defaults are `process.stdin` and `process.stdout`.
  *
  * @returns MCP stdio transport instance
  */
-export function createStdioTransport(): StdioServerTransport {
-  return new StdioServerTransport();
+export function createStdioTransport(stdin?: Readable, stdout?: Writable): StdioServerTransport {
+  return new StdioServerTransport(stdin, stdout);
 }