toolcraft 0.0.5 → 0.0.7

package/node_modules/tiny-mcp-client/src/internal.ts

@@ -0,0 +1,3566 @@
+import { spawn } from "node:child_process";
+import type { ChildProcessWithoutNullStreams, SpawnOptions } from "node:child_process";
+import { PassThrough } from "node:stream";
+import type { Readable, Writable } from "node:stream";
+import type { JSONRPCMessage as SdkJsonRpcMessage } from "@modelcontextprotocol/sdk/types.js";
+import {
+  createOAuthClientProvider,
+  OAuthError,
+  type OAuthClientProvider,
+  type OAuthClientProviderOptions,
+} from "mcp-oauth";
+import type { Server as TinyStdioMcpServer } from "tiny-stdio-mcp-server";
+import {
+  OAuthMetadataDiscovery,
+  parseBearerWwwAuthenticateHeader,
+} from "./oauth-discovery.js";
+import type {
+  OAuthDiscoveryCache,
+} from "./oauth-discovery.js";
+
+export {
+  OAuthMetadataDiscovery,
+  discoverOAuthMetadata,
+  parseBearerWwwAuthenticateHeader,
+  resolveAuthorizationServerMetadataUrl,
+  resolveProtectedResourceMetadataUrl,
+} from "./oauth-discovery.js";
+export {
+  createAuthStoreSessionStore,
+  createDefaultOAuthClientProvider,
+} from "mcp-oauth";
+export type {
+  OAuthDiscoveryCache,
+} from "./oauth-discovery.js";
+export type { OAuthAuthorizationServerMetadata, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthProtectedResourceMetadata, OAuthUnauthorizedChallenge } from "./oauth-discovery.js";
+export type {
+  DefaultOAuthClientProviderOptions,
+  OAuthClientProvider,
+  OAuthClientProviderOptions,
+  OAuthSessionStore,
+  StoredOAuthSession,
+} from "mcp-oauth";
+
+export type RequestId = number | string;
+
+export interface Implementation {
+  name: string;
+  version: string;
+}
+
+export interface ClientCapabilities {
+  roots?: {
+    listChanged?: boolean;
+    [key: string]: unknown;
+  };
+  sampling?: {
+    [key: string]: unknown;
+  };
+  experimental?: Record<string, unknown>;
+}
+
+export interface ServerCapabilities {
+  prompts?: {
+    listChanged?: boolean;
+    [key: string]: unknown;
+  };
+  resources?: {
+    subscribe?: boolean;
+    listChanged?: boolean;
+    [key: string]: unknown;
+  };
+  tools?: {
+    listChanged?: boolean;
+    [key: string]: unknown;
+  };
+  logging?: {
+    [key: string]: unknown;
+  };
+  completions?: {
+    [key: string]: unknown;
+  };
+  experimental?: Record<string, unknown>;
+}
+
+export interface InitializeParams {
+  protocolVersion: string;
+  capabilities: ClientCapabilities;
+  clientInfo: Implementation;
+}
+
+export interface InitializeResult {
+  protocolVersion: string;
+  capabilities: ServerCapabilities;
+  serverInfo: Implementation;
+  instructions?: string;
+}
+
+export interface McpClientOptions {
+  clientInfo: Implementation;
+  capabilities?: ClientCapabilities;
+  onToolsChanged?: () => void | Promise<void>;
+  onResourcesChanged?: () => void | Promise<void>;
+  onResourceUpdated?: (uri: string) => void | Promise<void>;
+  onPromptsChanged?: () => void | Promise<void>;
+  onLog?: (message: LogMessage) => void | Promise<void>;
+  onProgress?: (params: ProgressParams) => void | Promise<void>;
+  onSamplingRequest?: (
+    params: CreateMessageParams
+  ) => CreateMessageResult | Promise<CreateMessageResult>;
+  onRootsList?: () => Root[] | Promise<Root[]>;
+}
+
+const MCP_PROTOCOL_VERSION = "2025-03-26";
+
+export class McpClient {
+  private currentState: "disconnected" | "initializing" | "ready" | "closed" = "disconnected";
+  private currentServerCapabilities: ServerCapabilities | null = null;
+  private currentServerInfo: Implementation | null = null;
+  private currentInstructions: string | undefined;
+  private readonly options: McpClientOptions;
+  private transport: McpTransport | null = null;
+  private messageLayer: JsonRpcMessageLayer | null = null;
+
+  constructor(options: McpClientOptions) {
+    this.options = options;
+  }
+
+  get state(): "disconnected" | "initializing" | "ready" | "closed" {
+    return this.currentState;
+  }
+
+  get serverCapabilities(): ServerCapabilities | null {
+    return this.currentServerCapabilities;
+  }
+
+  get serverInfo(): Implementation | null {
+    return this.currentServerInfo;
+  }
+
+  get instructions(): string | undefined {
+    return this.currentInstructions;
+  }
+
+  private getMessageLayerOrThrow(): JsonRpcMessageLayer {
+    if (this.currentState === "disconnected") {
+      throw new Error("MCP client is disconnected");
+    }
+
+    if (this.currentState === "closed") {
+      throw new Error("MCP client is closed");
+    }
+
+    if (this.messageLayer === null) {
+      throw new Error("MCP client is disconnected");
+    }
+
+    return this.messageLayer;
+  }
+
+  async connect(transport: McpTransport): Promise<InitializeResult> {
+    if (this.currentState !== "disconnected" && this.currentState !== "closed") {
+      throw new Error("MCP client is already connected");
+    }
+
+    const transportClosedReason = transport.closed
+      .then((closedEvent) => closedEvent.reason)
+      .catch((error: unknown) =>
+        error instanceof Error ? error : new Error(String(error))
+      );
+    const messageLayer = new JsonRpcMessageLayer(
+      transport.readable,
+      transport.writable,
+      30_000,
+      transportClosedReason
+    );
+    const {
+      onSamplingRequest,
+      onRootsList,
+      onToolsChanged,
+      onResourcesChanged,
+      onResourceUpdated,
+      onPromptsChanged,
+      onLog,
+      onProgress,
+    } = this.options;
+
+    messageLayer.onRequest("ping", () => ({}));
+
+    if (onSamplingRequest !== undefined) {
+      messageLayer.onRequest("sampling/createMessage", (params) =>
+        onSamplingRequest(params as CreateMessageParams)
+      );
+    }
+
+    if (onRootsList !== undefined) {
+      messageLayer.onRequest("roots/list", async () => ({
+        roots: await onRootsList(),
+      }));
+    }
+
+    messageLayer.onNotification("notifications/tools/list_changed", async () => {
+      if (onToolsChanged === undefined) {
+        return;
+      }
+
+      await onToolsChanged();
+    });
+    messageLayer.onNotification("notifications/resources/list_changed", async () => {
+      if (onResourcesChanged === undefined) {
+        return;
+      }
+
+      await onResourcesChanged();
+    });
+    messageLayer.onNotification("notifications/resources/updated", async (params) => {
+      if (onResourceUpdated === undefined) {
+        return;
+      }
+
+      if (typeof params !== "object" || params === null || Array.isArray(params)) {
+        return;
+      }
+
+      const { uri } = params as { uri?: unknown };
+      if (typeof uri !== "string") {
+        return;
+      }
+
+      await onResourceUpdated(uri);
+    });
+    messageLayer.onNotification("notifications/prompts/list_changed", async () => {
+      if (onPromptsChanged === undefined) {
+        return;
+      }
+
+      await onPromptsChanged();
+    });
+    messageLayer.onNotification("notifications/message", async (params) => {
+      if (onLog === undefined || !isObjectRecord(params) || !isLogLevel(params.level)) {
+        return;
+      }
+
+      if (!hasOwn(params, "data")) {
+        return;
+      }
+
+      const message: LogMessage = {
+        level: params.level,
+        data: params.data,
+      };
+
+      if (params.logger !== undefined) {
+        if (typeof params.logger !== "string") {
+          return;
+        }
+
+        message.logger = params.logger;
+      }
+
+      await onLog(message);
+    });
+    messageLayer.onNotification("notifications/progress", async (params) => {
+      if (onProgress === undefined || !isObjectRecord(params)) {
+        return;
+      }
+
+      const { progressToken, progress } = params;
+      if (!isRequestId(progressToken) || typeof progress !== "number") {
+        return;
+      }
+
+      const progressParams: ProgressParams = {
+        progressToken,
+        progress,
+      };
+
+      if (params.total !== undefined) {
+        if (typeof params.total !== "number") {
+          return;
+        }
+
+        progressParams.total = params.total;
+      }
+
+      if (params.message !== undefined) {
+        if (typeof params.message !== "string") {
+          return;
+        }
+
+        progressParams.message = params.message;
+      }
+
+      await onProgress(progressParams);
+    });
+    messageLayer.onNotification("notifications/cancelled", () => undefined);
+
+    this.transport = transport;
+    this.messageLayer = messageLayer;
+    this.currentState = "initializing";
+    transport.closed
+      .then((closedEvent) => {
+        if (this.transport !== transport) {
+          return;
+        }
+
+        this.messageLayer?.dispose(closedEvent.reason);
+        this.messageLayer = null;
+        this.transport = null;
+        this.currentState = "closed";
+      })
+      .catch((error: unknown) => {
+        if (this.transport !== transport) {
+          return;
+        }
+
+        const reason = error instanceof Error ? error : new Error(String(error));
+        this.messageLayer?.dispose(reason);
+        this.messageLayer = null;
+        this.transport = null;
+        this.currentState = "closed";
+      });
+
+    const capabilities: ClientCapabilities = {
+      ...(this.options.capabilities ?? {}),
+    };
+
+    if (onSamplingRequest !== undefined && capabilities.sampling === undefined) {
+      capabilities.sampling = {};
+    }
+
+    if (onRootsList !== undefined) {
+      capabilities.roots = {
+        ...(capabilities.roots ?? {}),
+      };
+    }
+
+    const initializeResult = (await messageLayer.sendRequest("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      clientInfo: this.options.clientInfo,
+      capabilities,
+    })) as InitializeResult;
+
+    if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+      throw new McpError(
+        ERROR_INVALID_REQUEST,
+        `Unsupported protocol version: ${initializeResult.protocolVersion}`
+      );
+    }
+
+    this.currentServerCapabilities = initializeResult.capabilities;
+    this.currentServerInfo = initializeResult.serverInfo;
+    this.currentInstructions = initializeResult.instructions;
+    messageLayer.sendNotification("notifications/initialized");
+    this.currentState = "ready";
+
+    return initializeResult;
+  }
+
+  private getServerCapabilitiesOrThrow(): ServerCapabilities {
+    if (this.currentServerCapabilities === null) {
+      throw new Error("MCP client has not completed initialization");
+    }
+
+    return this.currentServerCapabilities;
+  }
+
+  async listTools(params: PaginatedParams = {}): Promise<{ tools: Tool[]; nextCursor?: string }> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.tools === undefined) {
+      throw new Error("Server does not support tools");
+    }
+
+    const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
+    return (await messageLayer.sendRequest("tools/list", requestParams)) as {
+      tools: Tool[];
+      nextCursor?: string;
+    };
+  }
+
+  async callTool(params: CallToolParams, options: CallToolOptions = {}): Promise<CallToolResult> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.tools === undefined) {
+      throw new Error("Server does not support tools");
+    }
+
+    const requestParams =
+      options.progressToken === undefined
+        ? params
+        : {
+            ...params,
+            _meta: {
+              progressToken: options.progressToken,
+            },
+          };
+
+    let requestId: RequestId | undefined;
+    const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
+      onRequestId: (nextRequestId) => {
+        requestId = nextRequestId;
+      },
+    }) as Promise<CallToolResult>;
+    if (options.signal === undefined) {
+      return await requestPromise;
+    }
+    const signal = options.signal;
+
+    let abortListener: (() => void) | undefined;
+    const abortPromise = new Promise<CallToolResult>((_, reject) => {
+      const rejectWithAbortReason = () => {
+        if (requestId !== undefined) {
+          messageLayer.sendNotification("notifications/cancelled", { requestId });
+        }
+        reject(signal.reason);
+      };
+
+      abortListener = rejectWithAbortReason;
+      signal.addEventListener("abort", abortListener, { once: true });
+      if (signal.aborted) {
+        signal.removeEventListener("abort", abortListener);
+        rejectWithAbortReason();
+      }
+    });
+
+    try {
+      return (await Promise.race([requestPromise, abortPromise])) as CallToolResult;
+    } finally {
+      if (abortListener !== undefined) {
+        signal.removeEventListener("abort", abortListener);
+      }
+    }
+  }
+
+  async listResources(
+    params: PaginatedParams = {}
+  ): Promise<{ resources: Resource[]; nextCursor?: string }> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.resources === undefined) {
+      throw new Error("Server does not support resources");
+    }
+
+    const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
+    return (await messageLayer.sendRequest("resources/list", requestParams)) as {
+      resources: Resource[];
+      nextCursor?: string;
+    };
+  }
+
+  async listResourceTemplates(
+    params: PaginatedParams = {}
+  ): Promise<{ resourceTemplates: ResourceTemplate[]; nextCursor?: string }> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.resources === undefined) {
+      throw new Error("Server does not support resources");
+    }
+
+    const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
+    return (await messageLayer.sendRequest("resources/templates/list", requestParams)) as {
+      resourceTemplates: ResourceTemplate[];
+      nextCursor?: string;
+    };
+  }
+
+  async readResource(params: ReadResourceParams): Promise<{ contents: ResourceContents[] }> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.resources === undefined) {
+      throw new Error("Server does not support resources");
+    }
+
+    return (await messageLayer.sendRequest("resources/read", params)) as {
+      contents: ResourceContents[];
+    };
+  }
+
+  async subscribe(uri: string): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.resources?.subscribe !== true) {
+      throw new Error("Server does not support resource subscriptions");
+    }
+
+    await messageLayer.sendRequest("resources/subscribe", { uri });
+  }
+
+  async unsubscribe(uri: string): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.resources?.subscribe !== true) {
+      throw new Error("Server does not support resource subscriptions");
+    }
+
+    await messageLayer.sendRequest("resources/unsubscribe", { uri });
+  }
+
+  async listPrompts(params: PaginatedParams = {}): Promise<{ prompts: Prompt[]; nextCursor?: string }> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.prompts === undefined) {
+      throw new Error("Server does not support prompts");
+    }
+
+    const requestParams = params.cursor === undefined ? undefined : { cursor: params.cursor };
+    return (await messageLayer.sendRequest("prompts/list", requestParams)) as {
+      prompts: Prompt[];
+      nextCursor?: string;
+    };
+  }
+
+  async getPrompt(params: GetPromptParams): Promise<GetPromptResult> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.prompts === undefined) {
+      throw new Error("Server does not support prompts");
+    }
+
+    return (await messageLayer.sendRequest("prompts/get", params)) as GetPromptResult;
+  }
+
+  async complete(params: CompleteParams): Promise<CompleteResult> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.completions === undefined) {
+      throw new Error("Server does not support completions");
+    }
+
+    return (await messageLayer.sendRequest("completion/complete", params)) as CompleteResult;
+  }
+
+  async setLogLevel(level: LogLevel): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const serverCapabilities = this.getServerCapabilitiesOrThrow();
+    if (serverCapabilities.logging === undefined) {
+      throw new Error("Server does not support logging");
+    }
+
+    await messageLayer.sendRequest("logging/setLevel", { level });
+  }
+
+  async cancel(requestId: RequestId, reason?: string): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    const params: { requestId: RequestId; reason?: string } = { requestId };
+
+    if (reason !== undefined) {
+      params.reason = reason;
+    }
+
+    messageLayer.sendNotification("notifications/cancelled", params);
+  }
+
+  async sendRootsChanged(): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    messageLayer.sendNotification("notifications/roots/list_changed");
+  }
+
+  async ping(): Promise<void> {
+    const messageLayer = this.getMessageLayerOrThrow();
+    await messageLayer.sendRequest("ping");
+  }
+
+  async close(): Promise<void> {
+    if (this.currentState === "closed") {
+      return;
+    }
+
+    const closeError = new Error("MCP client closed");
+    this.messageLayer?.dispose(closeError);
+    this.transport?.dispose(closeError);
+    this.messageLayer = null;
+    this.transport = null;
+    this.currentState = "closed";
+  }
+}
+
+export interface Tool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+  annotations?: ToolAnnotations;
+}
+
+export interface ToolAnnotations {
+  title?: string;
+  readOnlyHint?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+}
+
+export interface CallToolParams {
+  name: string;
+  arguments?: Record<string, unknown>;
+}
+
+export interface CallToolOptions {
+  signal?: AbortSignal;
+  progressToken?: ProgressToken;
+}
+
+export interface ReadResourceParams {
+  uri: string;
+}
+
+export interface Resource {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+  size?: number;
+}
+
+export interface ResourceTemplate {
+  uriTemplate: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+export interface PaginatedParams {
+  cursor?: string;
+}
+
+export interface PaginatedResult {
+  nextCursor?: string;
+}
+
+export interface TextResourceContents {
+  uri: string;
+  mimeType?: string;
+  text: string;
+}
+
+export interface BlobResourceContents {
+  uri: string;
+  mimeType?: string;
+  blob: string;
+}
+
+export type ResourceContents = TextResourceContents | BlobResourceContents;
+
+export interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export interface ImageContent {
+  type: "image";
+  data: string;
+  mimeType: string;
+}
+
+export interface AudioContent {
+  type: "audio";
+  data: string;
+  mimeType: string;
+}
+
+export interface EmbeddedResource {
+  type: "resource";
+  resource: ResourceContents;
+}
+
+export type ContentItem = TextContent | ImageContent | AudioContent | EmbeddedResource;
+
+export interface Prompt {
+  name: string;
+  description?: string;
+  arguments?: PromptArgument[];
+}
+
+export interface PromptArgument {
+  name: string;
+  description?: string;
+  required?: boolean;
+}
+
+export interface PromptMessage {
+  role: "user" | "assistant";
+  content: ContentItem;
+}
+
+export interface GetPromptResult {
+  description?: string;
+  messages: PromptMessage[];
+}
+
+export interface GetPromptParams {
+  name: string;
+  arguments?: Record<string, string>;
+}
+
+export interface CallToolResult {
+  content: ContentItem[];
+  isError?: boolean;
+}
+
+export interface Root {
+  uri: string;
+  name?: string;
+}
+
+export type LogLevel =
+  | "debug"
+  | "info"
+  | "notice"
+  | "warning"
+  | "error"
+  | "critical"
+  | "alert"
+  | "emergency";
+
+export interface LogMessage {
+  level: LogLevel;
+  logger?: string;
+  data: unknown;
+}
+
+export type ProgressToken = RequestId;
+
+export interface ProgressParams {
+  progressToken: ProgressToken;
+  progress: number;
+  total?: number;
+  message?: string;
+}
+
+export interface ModelHint {
+  name?: string;
+}
+
+export interface ModelPreferences {
+  hints?: ModelHint[];
+  costPriority?: number;
+  speedPriority?: number;
+  intelligencePriority?: number;
+}
+
+export interface SamplingMessage {
+  role: "user" | "assistant";
+  content: ContentItem | ContentItem[];
+}
+
+export type IncludeContext = "none" | "thisServer" | "allServers";
+
+export interface CreateMessageParams {
+  messages: SamplingMessage[];
+  modelPreferences?: ModelPreferences;
+  systemPrompt?: string;
+  includeContext?: IncludeContext;
+  temperature?: number;
+  maxTokens: number;
+  stopSequences?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface CreateMessageResult {
+  model: string;
+  content: ContentItem | ContentItem[];
+  role: "user" | "assistant";
+  stopReason: string;
+}
+
+export interface PromptReference {
+  type: "ref/prompt";
+  name: string;
+}
+
+export interface ResourceReference {
+  type: "ref/resource";
+  uri: string;
+}
+
+export interface CompleteArgument {
+  name: string;
+  value: string;
+}
+
+export interface CompleteParams {
+  ref: PromptReference | ResourceReference;
+  argument: CompleteArgument;
+}
+
+export interface Completion {
+  values: string[];
+  hasMore?: boolean;
+  total?: number;
+}
+
+export interface CompleteResult {
+  completion: Completion;
+}
+
+export const ERROR_PARSE = -32700;
+export const ERROR_INVALID_REQUEST = -32600;
+export const ERROR_METHOD_NOT_FOUND = -32601;
+export const ERROR_INVALID_PARAMS = -32602;
+export const ERROR_INTERNAL = -32603;
+
+export interface McpTransportClosedEvent {
+  reason: Error;
+  code?: number;
+  signal?: NodeJS.Signals;
+}
+
+export interface McpTransport {
+  readable: Readable;
+  writable: Writable;
+  closed: Promise<McpTransportClosedEvent>;
+  dispose(reason?: Error): void;
+}
+
+export interface InMemoryServerTransport {
+  readable: Readable;
+  writable: Writable;
+}
+
+export interface InMemoryTransportPair {
+  clientTransport: McpTransport;
+  serverTransport: InMemoryServerTransport;
+}
+
+export function createInMemoryTransportPair(): InMemoryTransportPair {
+  const clientToServer = new PassThrough();
+  const serverToClient = new PassThrough();
+  let disposed = false;
+  let resolveClosed:
+    | ((closedEvent: McpTransportClosedEvent) => void)
+    | undefined;
+
+  const closed = new Promise<McpTransportClosedEvent>((resolve) => {
+    resolveClosed = resolve;
+  });
+
+  const resolveClosedOnce = (reason: Error): void => {
+    if (resolveClosed === undefined) {
+      return;
+    }
+
+    const currentResolve = resolveClosed;
+    resolveClosed = undefined;
+    currentResolve({ reason });
+  };
+
+  const dispose = (reason = new Error("In-memory transport disposed")): void => {
+    if (disposed) {
+      return;
+    }
+
+    disposed = true;
+
+    if (!clientToServer.destroyed && !clientToServer.writableEnded) {
+      clientToServer.end();
+    }
+
+    if (!serverToClient.destroyed && !serverToClient.writableEnded) {
+      serverToClient.end();
+    }
+
+    resolveClosedOnce(reason);
+  };
+
+  clientToServer.once("error", (error) => {
+    dispose(error instanceof Error ? error : new Error(String(error)));
+  });
+  serverToClient.once("error", (error) => {
+    dispose(error instanceof Error ? error : new Error(String(error)));
+  });
+
+  return {
+    clientTransport: {
+      readable: serverToClient,
+      writable: clientToServer,
+      closed,
+      dispose,
+    },
+    serverTransport: {
+      readable: clientToServer,
+      writable: serverToClient,
+    },
+  };
+}
+
+interface SdkTransportAdapterInput {
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: SdkJsonRpcMessage, extra?: any) => void;
+  start(): Promise<void>;
+  close(): Promise<void>;
+  send(message: SdkJsonRpcMessage): Promise<void>;
+}
+
+export interface McpClientConnection {
+  connect(transport: McpTransport): Promise<void>;
+  close(): Promise<void>;
+}
+
+interface SdkServerConnection {
+  connect(transport: unknown): Promise<void>;
+}
+
+export interface SdkTestPair<TClient extends McpClientConnection> {
+  client: TClient;
+  cleanup: () => Promise<void>;
+}
+
+export class SdkTransportAdapter implements McpTransport {
+  readonly readable: Readable;
+  readonly writable: Writable;
+  readonly closed: Promise<McpTransportClosedEvent>;
+  private readonly sdkTransport: SdkTransportAdapterInput;
+  private readonly readStream = new PassThrough();
+  private readonly writeStream = new PassThrough();
+  private resolveClosed:
+    | ((closedEvent: McpTransportClosedEvent) => void)
+    | undefined;
+  private disposed = false;
+
+  constructor(sdkTransport: SdkTransportAdapterInput) {
+    this.sdkTransport = sdkTransport;
+    this.readable = this.readStream;
+    this.writable = this.writeStream;
+    this.closed = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+
+    this.sdkTransport.onmessage = (message) => {
+      this.readStream.write(serializeJsonRpcMessage(message as JsonRpcMessage));
+    };
+    this.sdkTransport.onclose = () => {
+      this.dispose(new Error("SDK transport closed"));
+    };
+    this.sdkTransport.onerror = (error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    };
+
+    this.readStream.once("error", (error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+    this.writeStream.once("error", (error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+
+    this.consumeWrittenLines().catch((error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+    this.sdkTransport.start().catch((error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+
+  dispose(reason = new Error("SDK transport adapter disposed")): void {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+
+    if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
+      this.writeStream.end();
+    }
+
+    if (!this.readStream.destroyed && !this.readStream.writableEnded) {
+      this.readStream.end();
+    }
+
+    if (this.resolveClosed !== undefined) {
+      const resolveClosed = this.resolveClosed;
+      this.resolveClosed = undefined;
+      resolveClosed({ reason });
+    }
+
+    this.sdkTransport.close().catch(() => undefined);
+  }
+
+  private async consumeWrittenLines(): Promise<void> {
+    for await (const line of readLines(this.writeStream)) {
+      if (this.disposed || line.length === 0) {
+        continue;
+      }
+
+      let parsedMessage: unknown;
+      try {
+        parsedMessage = JSON.parse(line);
+      } catch {
+        throw new Error(`Malformed JSON line: ${line}`);
+      }
+
+      if (typeof parsedMessage !== "object" || parsedMessage === null || Array.isArray(parsedMessage)) {
+        throw new Error(`Malformed JSON line: ${line}`);
+      }
+
+      await this.sdkTransport.send(parsedMessage as SdkJsonRpcMessage);
+    }
+  }
+}
+
+export async function createSdkTestPair<TClient extends McpClientConnection>(
+  server: SdkServerConnection,
+  createClient: () => TClient
+): Promise<SdkTestPair<TClient>> {
+  const { InMemoryTransport } = await import("@modelcontextprotocol/sdk/inMemory.js");
+  const [clientSdkTransport, serverSdkTransport] = InMemoryTransport.createLinkedPair();
+  const clientTransport = new SdkTransportAdapter(clientSdkTransport);
+  const serverPromise = server.connect(serverSdkTransport);
+  const client = createClient();
+
+  try {
+    await client.connect(clientTransport);
+  } catch (error) {
+    clientTransport.dispose(new Error("SDK test pair setup failed"));
+    await clientSdkTransport.close();
+    await serverSdkTransport.close();
+    await serverPromise;
+    throw error;
+  }
+
+  const cleanup = async (): Promise<void> => {
+    await client.close();
+    clientTransport.dispose(new Error("SDK test pair cleanup"));
+    await clientSdkTransport.close();
+    await serverSdkTransport.close();
+    await serverPromise;
+  };
+
+  return { client, cleanup };
+}
+
+export async function createMockEchoToolServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-echo-tool-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const echoTool = {
+    name: "echo",
+    description: "Echoes the provided message.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        message: {
+          type: "string",
+        },
+      },
+      required: ["message"],
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [echoTool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== "echo") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    const message = request.params.arguments?.message;
+    if (typeof message !== "string") {
+      throw new Error("Echo tool requires a string message argument");
+    }
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: message,
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export async function createMockMultiToolServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-multi-tool-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const tools = [
+    {
+      name: "add",
+      description: "Adds two numbers and returns the sum as text.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          a: { type: "number" },
+          b: { type: "number" },
+        },
+        required: ["a", "b"],
+      },
+    },
+    {
+      name: "greet",
+      description: "Greets a user with optional formal tone.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          name: { type: "string" },
+          formal: { type: "boolean" },
+        },
+        required: ["name"],
+      },
+    },
+    {
+      name: "fail",
+      description: "Returns an intentional tool error payload.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+      },
+    },
+  ];
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === "add") {
+      const a = request.params.arguments?.a;
+      const b = request.params.arguments?.b;
+
+      if (typeof a !== "number" || typeof b !== "number") {
+        throw new Error("Add tool requires numeric a and b arguments");
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: String(a + b),
+          },
+        ],
+      };
+    }
+
+    if (request.params.name === "greet") {
+      const name = request.params.arguments?.name;
+      const formal = request.params.arguments?.formal;
+
+      if (typeof name !== "string") {
+        throw new Error("Greet tool requires a string name argument");
+      }
+      if (formal !== undefined && typeof formal !== "boolean") {
+        throw new Error("Greet tool formal argument must be boolean when provided");
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: formal ? `Good day, ${name}.` : `Hello, ${name}!`,
+          },
+        ],
+      };
+    }
+
+    if (request.params.name === "fail") {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text" as const,
+            text: "Intentional tool failure.",
+          },
+        ],
+      };
+    }
+
+    throw new Error(`Unknown tool: ${request.params.name}`);
+  });
+
+  return server;
+}
+
+export async function createMockPaginatedToolsServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { ListToolsRequestSchema }] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/index.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]);
+
+  const server = new Server(
+    { name: "mock-paginated-tools-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const pageSize = 5;
+  const tools = Array.from({ length: 20 }, (_, index) => ({
+    name: `tool-${index + 1}`,
+    description: `Mock paginated tool ${index + 1}.`,
+    inputSchema: {
+      type: "object" as const,
+      properties: {},
+    },
+  }));
+
+  server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    const cursor = request.params?.cursor;
+    const startIndex = cursor === undefined ? 0 : Number(cursor);
+
+    if (
+      !Number.isInteger(startIndex) ||
+      startIndex < 0 ||
+      startIndex > tools.length ||
+      startIndex % pageSize !== 0
+    ) {
+      throw new Error(`Invalid cursor: ${String(cursor)}`);
+    }
+
+    const pageTools = tools.slice(startIndex, startIndex + pageSize);
+    const nextIndex = startIndex + pageSize;
+    if (nextIndex >= tools.length) {
+      return { tools: pageTools };
+    }
+
+    return {
+      tools: pageTools,
+      nextCursor: String(nextIndex),
+    };
+  });
+
+  return server;
+}
+
+export async function createMockResourceServer(): Promise<SdkServerConnection> {
+  const [
+    { Server },
+    {
+      ListResourcesRequestSchema,
+      ListResourceTemplatesRequestSchema,
+      ReadResourceRequestSchema,
+    },
+  ] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/index.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]);
+
+  const server = new Server(
+    { name: "mock-resource-server", version: "1.0.0" },
+    { capabilities: { resources: {} } }
+  );
+  const resources = [
+    {
+      uri: "file:///readme.txt",
+      name: "readme.txt",
+      mimeType: "text/plain",
+    },
+    {
+      uri: "file:///image.png",
+      name: "image.png",
+      mimeType: "image/png",
+    },
+  ];
+  const resourceContentsByUri = new Map<string, ResourceContents>([
+    [
+      "file:///readme.txt",
+      {
+        uri: "file:///readme.txt",
+        mimeType: "text/plain",
+        text: "This is a mock README resource.",
+      },
+    ],
+    [
+      "file:///image.png",
+      {
+        uri: "file:///image.png",
+        mimeType: "image/png",
+        blob: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8Xw8AAoMBgL9qj3QAAAAASUVORK5CYII=",
+      },
+    ],
+  ]);
+  const resourceTemplates = [
+    {
+      uriTemplate: "file:///{path}",
+      name: "file-template",
+    },
+  ];
+
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources,
+  }));
+
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const resourceContent = resourceContentsByUri.get(request.params.uri);
+    if (resourceContent === undefined) {
+      throw new Error(`Unknown resource: ${request.params.uri}`);
+    }
+
+    return {
+      contents: [resourceContent],
+    };
+  });
+
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates,
+  }));
+
+  return server;
+}
+
+export async function createMockSubscribableResourceServer(): Promise<
+  SdkServerConnection & {
+    triggerResourceUpdated: (uri: string, updatedText?: string) => Promise<void>;
+    triggerResourceListChanged: () => Promise<void>;
+  }
+> {
+  const [
+    { Server },
+    {
+      ListResourcesRequestSchema,
+      ReadResourceRequestSchema,
+      SubscribeRequestSchema,
+      UnsubscribeRequestSchema,
+    },
+  ] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-subscribable-resource-server", version: "1.0.0" },
+    { capabilities: { resources: { subscribe: true, listChanged: true } } }
+  );
+  const resources = [
+    {
+      uri: "file:///readme.txt",
+      name: "readme.txt",
+      mimeType: "text/plain",
+    },
+  ];
+  const resourceContentsByUri = new Map<string, ResourceContents>([
+    [
+      "file:///readme.txt",
+      {
+        uri: "file:///readme.txt",
+        mimeType: "text/plain",
+        text: "Initial subscribable resource text.",
+      },
+    ],
+  ]);
+  const subscribedUris = new Set<string>();
+
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources,
+  }));
+
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const resourceContent = resourceContentsByUri.get(request.params.uri);
+    if (resourceContent === undefined) {
+      throw new Error(`Unknown resource: ${request.params.uri}`);
+    }
+
+    return {
+      contents: [resourceContent],
+    };
+  });
+
+  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    subscribedUris.add(request.params.uri);
+    return {};
+  });
+
+  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+    subscribedUris.delete(request.params.uri);
+    return {};
+  });
+
+  return Object.assign(server, {
+    triggerResourceUpdated: async (uri: string, updatedText?: string): Promise<void> => {
+      if (updatedText !== undefined) {
+        const existingContent = resourceContentsByUri.get(uri);
+        if (existingContent === undefined || "blob" in existingContent) {
+          throw new Error(`Unknown text resource: ${uri}`);
+        }
+
+        resourceContentsByUri.set(uri, {
+          uri,
+          mimeType: existingContent.mimeType,
+          text: updatedText,
+        });
+      }
+
+      if (!subscribedUris.has(uri)) {
+        return;
+      }
+
+      await server.sendResourceUpdated({ uri });
+    },
+    triggerResourceListChanged: async (): Promise<void> => {
+      await server.sendResourceListChanged();
+    },
+  });
+}
+
+export async function createMockPromptServer(): Promise<SdkServerConnection> {
+  const [
+    { Server },
+    { ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, McpError: SdkMcpError },
+  ] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-prompt-server", version: "1.0.0" },
+    { capabilities: { prompts: {} } }
+  );
+  const promptTemplates = [
+    {
+      prompt: {
+        name: "code_review",
+        description: "Review code for correctness and maintainability.",
+        arguments: [
+          {
+            name: "code",
+            description: "Code to review.",
+            required: true,
+          },
+        ],
+      },
+      messages: [
+        {
+          role: "user" as const,
+          textTemplate: "Please review the following code:\n{{code}}",
+        },
+        {
+          role: "assistant" as const,
+          textTemplate: "I will review the code for potential issues and improvements.",
+        },
+      ],
+    },
+    {
+      prompt: {
+        name: "summarize",
+        description: "Summarize the provided text.",
+      },
+      messages: [
+        {
+          role: "user" as const,
+          textTemplate: "Please summarize the provided text.",
+        },
+      ],
+    },
+  ];
+  const promptsByName = new Map(promptTemplates.map((template) => [template.prompt.name, template]));
+
+  const renderPromptMessage = (
+    textTemplate: string,
+    argumentsMap: Record<string, unknown> | undefined
+  ): string => {
+    if (argumentsMap === undefined) {
+      return textTemplate;
+    }
+
+    let renderedText = textTemplate;
+    for (const [name, value] of Object.entries(argumentsMap)) {
+      if (typeof value !== "string") {
+        continue;
+      }
+
+      renderedText = renderedText.split(`{{${name}}}`).join(value);
+    }
+
+    return renderedText;
+  };
+
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: promptTemplates.map((template) => template.prompt),
+  }));
+
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const template = promptsByName.get(request.params.name);
+    if (template === undefined) {
+      throw new SdkMcpError(ErrorCode.InvalidParams, `Unknown prompt: ${request.params.name}`);
+    }
+
+    const requestArguments = request.params.arguments;
+    for (const argument of template.prompt.arguments ?? []) {
+      if (!argument.required) {
+        continue;
+      }
+
+      const value = requestArguments?.[argument.name];
+      if (typeof value !== "string") {
+        throw new SdkMcpError(
+          ErrorCode.InvalidParams,
+          `Missing required prompt argument: ${argument.name}`
+        );
+      }
+    }
+
+    return {
+      description: template.prompt.description,
+      messages: template.messages.map((message) => ({
+        role: message.role,
+        content: {
+          type: "text" as const,
+          text: renderPromptMessage(message.textTemplate, requestArguments),
+        },
+      })),
+    };
+  });
+
+  return server;
+}
+
+export async function createMockCompletionServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CompleteRequestSchema }] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/index.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]);
+
+  const server = new Server(
+    { name: "mock-completion-server", version: "1.0.0" },
+    { capabilities: { completions: {} } }
+  );
+  const promptArgumentCompletions = new Map<string, string[]>([
+    ["code_review:language", ["python", "pydantic", "pytest", "pytorch", "pyright", "rust"]],
+  ]);
+  const maxValues = 3;
+
+  server.setRequestHandler(CompleteRequestSchema, async (request) => {
+    if (request.params.ref.type !== "ref/prompt") {
+      return {
+        completion: {
+          values: [],
+        },
+      };
+    }
+
+    const completionKey = `${request.params.ref.name}:${request.params.argument.name}`;
+    const candidates = promptArgumentCompletions.get(completionKey) ?? [];
+    const partialValue = request.params.argument.value.toLowerCase();
+    const matchingValues = candidates.filter((candidate) =>
+      candidate.toLowerCase().startsWith(partialValue)
+    );
+    const values = matchingValues.slice(0, maxValues);
+
+    if (values.length < matchingValues.length) {
+      return {
+        completion: {
+          values,
+          hasMore: true,
+          total: matchingValues.length,
+        },
+      };
+    }
+
+    return {
+      completion: {
+        values,
+      },
+    };
+  });
+
+  return server;
+}
+
+export async function createMockProgressServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-progress-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const totalSteps = 4;
+  const tool = {
+    name: "slow_task",
+    description: "Runs a simulated slow task and streams progress updates.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {},
+      additionalProperties: false,
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    if (request.params.name !== "slow_task") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    const progressToken = request.params._meta?.progressToken;
+    if (progressToken !== undefined) {
+      for (let step = 1; step <= totalSteps; step += 1) {
+        await extra.sendNotification({
+          method: "notifications/progress",
+          params: {
+            progressToken,
+            progress: step,
+            total: totalSteps,
+            message: `Completed step ${step} of ${totalSteps}`,
+          },
+        });
+
+        await new Promise<void>((resolve) => {
+          setTimeout(resolve, 5);
+        });
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: "slow_task complete",
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export interface MockSlowToolServerOptions {
+  delayMs?: number;
+  pollIntervalMs?: number;
+}
+
+export async function createMockSlowToolServer(
+  options: MockSlowToolServerOptions = {}
+): Promise<
+  SdkServerConnection & {
+    wasStarted: () => boolean;
+    getStartedRequestIds: () => RequestId[];
+    wasCancelled: () => boolean;
+    getCancelledRequestIds: () => RequestId[];
+  }
+> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const defaultDelayMs = options.delayMs ?? 1_000;
+  const pollIntervalMs = options.pollIntervalMs ?? 10;
+  if (!Number.isFinite(defaultDelayMs) || defaultDelayMs < 0) {
+    throw new Error("createMockSlowToolServer delayMs must be a finite non-negative number");
+  }
+  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+    throw new Error("createMockSlowToolServer pollIntervalMs must be a finite positive number");
+  }
+
+  const server = new Server(
+    { name: "mock-slow-tool-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const startedRequestIds = new Set<RequestId>();
+  const cancelledRequestIds = new Set<RequestId>();
+  const tool = {
+    name: "slow",
+    description: "Delays the response and supports cancellation.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        delayMs: {
+          type: "number",
+        },
+      },
+      additionalProperties: false,
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    if (request.params.name !== "slow") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+    startedRequestIds.add(extra.requestId);
+
+    const delayArgument = request.params.arguments?.delayMs;
+    const delayMs =
+      delayArgument === undefined
+        ? defaultDelayMs
+        : typeof delayArgument === "number" && Number.isFinite(delayArgument) && delayArgument >= 0
+          ? delayArgument
+          : NaN;
+    if (!Number.isFinite(delayMs)) {
+      throw new Error("slow tool delayMs argument must be a finite non-negative number");
+    }
+
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < delayMs) {
+      if (extra.signal.aborted) {
+        cancelledRequestIds.add(extra.requestId);
+        throw new Error("slow tool cancelled");
+      }
+
+      const elapsedMs = Date.now() - startedAt;
+      const remainingMs = delayMs - elapsedMs;
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, Math.max(0, Math.min(pollIntervalMs, remainingMs)));
+      });
+    }
+
+    if (extra.signal.aborted) {
+      cancelledRequestIds.add(extra.requestId);
+      throw new Error("slow tool cancelled");
+    }
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `slow complete after ${delayMs}ms`,
+        },
+      ],
+    };
+  });
+
+  return Object.assign(server, {
+    wasStarted: (): boolean => startedRequestIds.size > 0,
+    getStartedRequestIds: (): RequestId[] => Array.from(startedRequestIds),
+    wasCancelled: (): boolean => cancelledRequestIds.size > 0,
+    getCancelledRequestIds: (): RequestId[] => Array.from(cancelledRequestIds),
+  });
+}
+
+export async function createMockErrorServer(): Promise<SdkServerConnection> {
+  const [
+    { Server },
+    { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError: SdkMcpError },
+  ] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/index.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]);
+
+  const server = new Server(
+    { name: "mock-error-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const tools = [
+    {
+      name: "invalid_params",
+      description: "Returns a JSON-RPC Invalid Params error.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+        additionalProperties: false,
+      },
+    },
+    {
+      name: "is_error",
+      description: "Returns a tools/call result with isError: true.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+        additionalProperties: false,
+      },
+    },
+    {
+      name: "internal_error",
+      description: "Throws an internal server error.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+        additionalProperties: false,
+      },
+    },
+  ];
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === "invalid_params") {
+      throw new SdkMcpError(
+        ErrorCode.InvalidParams,
+        "Intentional invalid params error from mock-error-server."
+      );
+    }
+
+    if (request.params.name === "is_error") {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text" as const,
+            text: "Intentional isError tool failure.",
+          },
+        ],
+      };
+    }
+
+    if (request.params.name === "internal_error") {
+      throw new Error("Intentional internal error from mock-error-server.");
+    }
+
+    throw new Error(`Unknown tool: ${request.params.name}`);
+  });
+
+  return server;
+}
+
+export async function createMockSamplingServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-sampling-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const tool = {
+    name: "sample_message",
+    description: "Requests sampling/createMessage from the client and returns the sampled text.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        topic: {
+          type: "string",
+        },
+      },
+      required: ["topic"],
+      additionalProperties: false,
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== "sample_message") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    const topic = request.params.arguments?.topic;
+    if (typeof topic !== "string") {
+      throw new Error("sample_message requires a string topic argument");
+    }
+
+    const samplingResult = await server.createMessage({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Provide a concise sentence about ${topic}.`,
+          },
+        },
+      ],
+      maxTokens: 64,
+      modelPreferences: {
+        hints: [{ name: "mock-sampling-model" }],
+        speedPriority: 0.2,
+        intelligencePriority: 0.9,
+      },
+      systemPrompt: "Return exactly one concise sentence.",
+    });
+
+    const sampledText =
+      samplingResult.content.type === "text"
+        ? samplingResult.content.text
+        : JSON.stringify(samplingResult.content);
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Sampled response: ${sampledText}`,
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export async function createMockRootsServer(): Promise<SdkServerConnection> {
+  const [
+    { Server },
+    {
+      CallToolRequestSchema,
+      ListToolsRequestSchema,
+      RootsListChangedNotificationSchema,
+    },
+  ] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-roots-server", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  const tool = {
+    name: "roots_summary",
+    description: "Requests roots/list from the client and returns a summary of roots.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {},
+      additionalProperties: false,
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
+    await server.listRoots();
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== "roots_summary") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    const rootsResult = await server.listRoots();
+    const rootSummary = rootsResult.roots
+      .map((root) => (root.name === undefined ? root.uri : `${root.name} (${root.uri})`))
+      .join(", ");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: rootSummary.length === 0 ? "Roots: none" : `Roots: ${rootSummary}`,
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export async function createMockLoggingServer(): Promise<SdkServerConnection> {
+  const [{ Server }, { CallToolRequestSchema, ListToolsRequestSchema }] =
+    await Promise.all([
+      import("@modelcontextprotocol/sdk/server/index.js"),
+      import("@modelcontextprotocol/sdk/types.js"),
+    ]);
+
+  const server = new Server(
+    { name: "mock-logging-server", version: "1.0.0" },
+    { capabilities: { tools: {}, logging: {} } }
+  );
+  const tool = {
+    name: "emit_logs",
+    description: "Emits mock log messages at multiple levels.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {},
+      additionalProperties: false,
+    },
+  };
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== "emit_logs") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    await server.sendLoggingMessage({
+      level: "debug",
+      logger: "mock-logging-server",
+      data: { message: "Debug message" },
+    });
+    await server.sendLoggingMessage({
+      level: "info",
+      logger: "mock-logging-server",
+      data: { message: "Info message" },
+    });
+    await server.sendLoggingMessage({
+      level: "error",
+      logger: "mock-logging-server",
+      data: { message: "Error message" },
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: "Emitted log messages.",
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+export async function createMockFullFeaturedServer(): Promise<SdkServerConnection> {
+  const [
+    { Server },
+    {
+      CallToolRequestSchema,
+      CompleteRequestSchema,
+      GetPromptRequestSchema,
+      ListPromptsRequestSchema,
+      ListResourcesRequestSchema,
+      ListToolsRequestSchema,
+      ReadResourceRequestSchema,
+    },
+  ] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/index.js"),
+    import("@modelcontextprotocol/sdk/types.js"),
+  ]);
+
+  const server = new Server(
+    { name: "mock-full-featured-server", version: "1.0.0" },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {},
+        logging: {},
+        completions: {},
+      },
+    }
+  );
+  const tool = {
+    name: "full_featured_ping",
+    description: "Returns a text response and emits an info log.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {},
+      additionalProperties: false,
+    },
+  };
+  const resources = [
+    {
+      uri: "file:///full-featured.txt",
+      name: "full-featured.txt",
+      mimeType: "text/plain",
+    },
+  ];
+  const prompts = [
+    {
+      name: "full_featured_prompt",
+      description: "Returns a short prompt message for a topic.",
+      arguments: [
+        {
+          name: "topic",
+          description: "Topic to include in the prompt output.",
+          required: false,
+        },
+      ],
+    },
+  ];
+  const completionValues = ["alpha", "beta", "gamma"];
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [tool],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== "full_featured_ping") {
+      throw new Error(`Unknown tool: ${request.params.name}`);
+    }
+
+    await server.sendLoggingMessage({
+      level: "info",
+      logger: "mock-full-featured-server",
+      data: {
+        message: "full_featured_ping called",
+      },
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: "full_featured_ping ok",
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources,
+  }));
+
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    if (request.params.uri !== "file:///full-featured.txt") {
+      throw new Error(`Unknown resource: ${request.params.uri}`);
+    }
+
+    return {
+      contents: [
+        {
+          uri: "file:///full-featured.txt",
+          mimeType: "text/plain",
+          text: "Mock full-featured resource",
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts,
+  }));
+
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    if (request.params.name !== "full_featured_prompt") {
+      throw new Error(`Unknown prompt: ${request.params.name}`);
+    }
+
+    const topic = request.params.arguments?.topic;
+    const topicText = typeof topic === "string" && topic.length > 0 ? topic : "general";
+
+    return {
+      description: "Mock prompt from full-featured server.",
+      messages: [
+        {
+          role: "user" as const,
+          content: {
+            type: "text" as const,
+            text: `Provide a short summary for ${topicText}.`,
+          },
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(CompleteRequestSchema, async (request) => {
+    if (
+      request.params.ref.type !== "ref/prompt" ||
+      request.params.ref.name !== "full_featured_prompt" ||
+      request.params.argument.name !== "topic"
+    ) {
+      return {
+        completion: {
+          values: [],
+        },
+      };
+    }
+
+    const partialValue = request.params.argument.value.toLowerCase();
+    const values = completionValues.filter((value) => value.startsWith(partialValue));
+
+    return {
+      completion: {
+        values,
+      },
+    };
+  });
+
+  return server;
+}
+
+export async function createTestPair<TClient extends McpClientConnection>(
+  server: TinyStdioMcpServer,
+  createClient: () => TClient
+): Promise<SdkTestPair<TClient>> {
+  const { clientTransport, serverTransport } = createInMemoryTransportPair();
+  const serverPromise = server.connect(serverTransport);
+  const client = createClient();
+
+  try {
+    await client.connect(clientTransport);
+  } catch (error) {
+    clientTransport.dispose(new Error("tiny-stdio-mcp-server test pair setup failed"));
+    await serverPromise;
+    throw error;
+  }
+
+  const cleanup = async (): Promise<void> => {
+    await client.close();
+    clientTransport.dispose(new Error("tiny-stdio-mcp-server test pair cleanup"));
+    await serverPromise;
+  };
+
+  return { client, cleanup };
+}
+
+export type StdioSpawn = (
+  command: string,
+  args: ReadonlyArray<string>,
+  options: SpawnOptions
+) => ChildProcessWithoutNullStreams;
+
+export interface StdioTransportOptions {
+  command: string;
+  args?: string[];
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  spawn?: StdioSpawn;
+}
+
+export type HttpTransportFetch = (
+  input: string | URL,
+  init?: RequestInit
+) => Promise<Response>;
+
+export interface HttpTransportOptions {
+  url: string;
+  headers?: HeadersInit;
+  fetch?: HttpTransportFetch;
+  oauth?: OAuthClientProviderOptions;
+  oauthDiscoveryCache?: OAuthDiscoveryCache;
+}
+
+function defaultStdioSpawn(
+  command: string,
+  args: ReadonlyArray<string>,
+  options: SpawnOptions
+): ChildProcessWithoutNullStreams {
+  return spawn(command, args, options) as ChildProcessWithoutNullStreams;
+}
+
+function defaultHttpTransportFetch(input: string | URL, init?: RequestInit): Promise<Response> {
+  return fetch(input, init);
+}
+
+export class StdioTransport implements McpTransport {
+  readonly readable: Readable;
+  readonly writable: Writable;
+  readonly closed: Promise<McpTransportClosedEvent>;
+  private readonly child: ChildProcessWithoutNullStreams;
+  private disposed = false;
+  private stderrOutput = "";
+  private static readonly STDERR_MAX_LENGTH = 65_536;
+
+  constructor({
+    command,
+    args = [],
+    cwd,
+    env,
+    spawn: spawnProcess = defaultStdioSpawn,
+  }: StdioTransportOptions) {
+    this.child = spawnProcess(command, args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const child = this.child;
+
+    this.readable = child.stdout;
+    this.writable = child.stdin;
+    child.stderr.on("data", (chunk: unknown) => {
+      this.stderrOutput += chunkToString(chunk);
+      if (this.stderrOutput.length > StdioTransport.STDERR_MAX_LENGTH) {
+        this.stderrOutput = this.stderrOutput.slice(-StdioTransport.STDERR_MAX_LENGTH);
+      }
+    });
+    this.closed = new Promise((resolve) => {
+      let settled = false;
+      const resolveClosed = (event: McpTransportClosedEvent) => {
+        if (settled) {
+          return;
+        }
+
+        settled = true;
+        resolve(event);
+      };
+
+      child.once("exit", (code, signal) => {
+        const closedEvent: McpTransportClosedEvent = {
+          reason: new Error("Stdio transport process exited"),
+        };
+
+        if (code !== null) {
+          closedEvent.code = code;
+        }
+
+        if (signal !== null) {
+          closedEvent.signal = signal;
+        }
+
+        resolveClosed(closedEvent);
+      });
+
+      child.once("error", (error) => {
+        const closedEvent: McpTransportClosedEvent = {
+          reason: error instanceof Error ? error : new Error(String(error)),
+        };
+
+        if (child.exitCode !== null) {
+          closedEvent.code = child.exitCode;
+        }
+
+        if (child.signalCode !== null) {
+          closedEvent.signal = child.signalCode;
+        }
+
+        resolveClosed(closedEvent);
+      });
+    });
+  }
+
+  getStderrOutput(): string {
+    return this.stderrOutput;
+  }
+
+  dispose(reason = new Error("Stdio transport disposed")): void {
+    void reason;
+
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+
+    if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
+      this.child.stdin.end();
+    }
+
+    if (this.child.exitCode === null && this.child.signalCode === null && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+  }
+}
+
+export class HttpTransport implements McpTransport {
+  readonly readable: Readable;
+  readonly writable: Writable;
+  readonly closed: Promise<McpTransportClosedEvent>;
+  private readonly url: string;
+  private readonly headers: HeadersInit;
+  private readonly fetchImpl: HttpTransportFetch;
+  private readonly readStream = new PassThrough();
+  private readonly writeStream = new PassThrough();
+  private resolveClosed:
+    | ((closedEvent: McpTransportClosedEvent) => void)
+    | undefined;
+  private sessionId: string | undefined;
+  private lastEventId: string | undefined;
+  private getSseStreamStarted = false;
+  private disposed = false;
+  private readonly oauthProvider: OAuthClientProvider | undefined;
+  private readonly oauthMetadataDiscovery: OAuthMetadataDiscovery | undefined;
+  private readonly inFlightFetchAbortControllers = new Set<AbortController>();
+  private readonly openSseReaders = new Set<ReadableStreamDefaultReader<Uint8Array>>();
+
+  constructor({
+    url,
+    headers = {},
+    fetch: fetchImpl = defaultHttpTransportFetch,
+    oauth,
+    oauthDiscoveryCache,
+  }: HttpTransportOptions) {
+    this.url = url;
+    this.headers = headers;
+    this.fetchImpl = fetchImpl;
+    this.oauthProvider = oauth === undefined
+      ? undefined
+      : createOAuthClientProvider(oauth);
+    this.oauthMetadataDiscovery = oauth === undefined
+      ? undefined
+      : new OAuthMetadataDiscovery({
+          fetch: (input, init) => this.fetchWithAbort(input, init ?? {}),
+          cache: oauthDiscoveryCache,
+        });
+    this.readable = this.readStream;
+    this.writable = this.writeStream;
+    this.closed = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+
+    this.readStream.once("error", (error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+    this.writeStream.once("error", (error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+
+    this.consumeWrittenLines().catch((error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+
+  dispose(reason = new Error("HTTP transport disposed")): void {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+    this.abortInFlightFetches();
+    this.cancelOpenSseReaders();
+    this.terminateSession();
+
+    if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
+      this.writeStream.end();
+    }
+
+    if (!this.readStream.destroyed && !this.readStream.writableEnded) {
+      this.readStream.end();
+    }
+
+    const resolveClosed = this.resolveClosed;
+    this.resolveClosed = undefined;
+    resolveClosed?.({ reason });
+  }
+
+  private abortInFlightFetches(): void {
+    for (const abortController of this.inFlightFetchAbortControllers) {
+      abortController.abort();
+    }
+
+    this.inFlightFetchAbortControllers.clear();
+  }
+
+  private cancelOpenSseReaders(): void {
+    for (const reader of this.openSseReaders) {
+      void reader.cancel().catch(() => undefined);
+    }
+
+    this.openSseReaders.clear();
+  }
+
+  private async fetchWithAbort(input: string | URL, init: RequestInit): Promise<Response> {
+    const abortController = new AbortController();
+    this.inFlightFetchAbortControllers.add(abortController);
+
+    try {
+      return await this.fetchImpl(input, {
+        ...init,
+        signal: abortController.signal,
+      });
+    } finally {
+      this.inFlightFetchAbortControllers.delete(abortController);
+    }
+  }
+
+  private async consumeWrittenLines(): Promise<void> {
+    for await (const line of readLines(this.writeStream)) {
+      if (this.disposed || line.length === 0) {
+        continue;
+      }
+
+      const hasSessionId = this.sessionId !== undefined;
+      const response = await this.fetchWithOAuthRetry({
+        method: "POST",
+        createHeaders: () => this.createPostHeaders(),
+        body: line,
+      });
+
+      if (hasSessionId && response.status === 404) {
+        this.sessionId = undefined;
+        this.dispose(new Error("HTTP transport session expired (404 response)"));
+        return;
+      }
+
+      await this.throwForPostHttpError(response);
+      this.captureSessionId(response);
+      this.maybeOpenGetSseStream();
+      await this.forwardResponseMessages(response);
+    }
+  }
+
+  private async createPostHeaders(): Promise<Headers> {
+    const headers = new Headers(this.headers);
+    headers.set("Accept", "application/json, text/event-stream");
+    headers.set("Content-Type", "application/json");
+    if (this.sessionId !== undefined) {
+      headers.set("Mcp-Session-Id", this.sessionId);
+    }
+    return this.authorizeRequestHeaders(headers);
+  }
+
+  private async createGetHeaders(): Promise<Headers> {
+    const headers = new Headers(this.headers);
+    headers.set("Accept", "text/event-stream");
+    if (this.sessionId !== undefined) {
+      headers.set("Mcp-Session-Id", this.sessionId);
+    }
+    if (this.lastEventId !== undefined) {
+      headers.set("Last-Event-ID", this.lastEventId);
+    }
+    return this.authorizeRequestHeaders(headers);
+  }
+
+  private async createDeleteHeaders(sessionId: string): Promise<Headers> {
+    const headers = new Headers(this.headers);
+    headers.set("Mcp-Session-Id", sessionId);
+    return this.authorizeRequestHeaders(headers);
+  }
+
+  private async authorizeRequestHeaders(headers: Headers): Promise<Headers> {
+    await this.oauthProvider?.authorizeRequest?.({
+      requestUrl: new URL(this.url),
+      headers,
+      fetch: this.fetchImpl,
+    });
+    return headers;
+  }
+
+  private captureSessionId(response: Response): void {
+    const sessionId = response.headers.get("Mcp-Session-Id");
+    if (sessionId === null || sessionId.length === 0) {
+      return;
+    }
+
+    this.sessionId = sessionId;
+  }
+
+  private maybeOpenGetSseStream(): void {
+    if (this.disposed || this.sessionId === undefined || this.getSseStreamStarted) {
+      return;
+    }
+
+    this.getSseStreamStarted = true;
+    this.consumeGetSseStream().catch((error) => {
+      if (error instanceof HttpTransportGetSseNotSupportedError || this.disposed) {
+        return;
+      }
+
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+
+  private terminateSession(): void {
+    if (this.sessionId === undefined) {
+      return;
+    }
+
+    const sessionId = this.sessionId;
+    this.sessionId = undefined;
+
+    this.sendSessionTerminationRequest(sessionId).catch(() => undefined);
+  }
+
+  private async sendSessionTerminationRequest(sessionId: string): Promise<void> {
+    const response = await this.fetchImpl(this.url, {
+      method: "DELETE",
+      headers: await this.createDeleteHeaders(sessionId),
+    });
+
+    if (response.status === 405) {
+      return;
+    }
+  }
+
+  private async consumeGetSseStream(): Promise<void> {
+    const response = await this.fetchWithOAuthRetry({
+      method: "GET",
+      createHeaders: () => this.createGetHeaders(),
+    });
+
+    if (response.status === 405) {
+      throw new HttpTransportGetSseNotSupportedError();
+    }
+
+    const contentType = response.headers.get("Content-Type");
+    if (contentType === null) {
+      return;
+    }
+
+    if (contentType.toLowerCase().includes("text/event-stream")) {
+      await this.forwardSseResponseMessages(response);
+      this.getSseStreamStarted = false;
+      if (!this.disposed && this.sessionId !== undefined && this.lastEventId !== undefined) {
+        this.maybeOpenGetSseStream();
+      }
+    }
+  }
+
+  private async throwForPostHttpError(response: Response): Promise<void> {
+    if (response.status < 400) {
+      return;
+    }
+
+    const responseBody = (await response.text()).trim();
+    const statusDescriptor = `${response.status} ${response.statusText}`.trim();
+    const message = responseBody.length === 0
+      ? `HTTP transport POST failed (${statusDescriptor})`
+      : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
+    throw new Error(message);
+  }
+
+  private async maybeHandleUnauthorizedResponse(response: Response): Promise<boolean> {
+    if (response.status !== 401 || this.oauthProvider === undefined) {
+      return false;
+    }
+
+    const discoveryClient = this.oauthMetadataDiscovery;
+    if (discoveryClient === undefined) {
+      return false;
+    }
+
+    const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
+    const resourceMetadataUrl = challenge?.params.resource_metadata;
+    const discovery = await discoveryClient.discover(this.url, {
+      resourceMetadataUrl,
+    });
+    const result = await this.oauthProvider.handleUnauthorized({
+      requestUrl: new URL(this.url),
+      response: response.clone(),
+      challenge,
+      discovery,
+      fetch: this.fetchImpl,
+    });
+
+    if (result.action === "retry") {
+      return true;
+    }
+
+    if (result.error !== undefined) {
+      throw result.error;
+    }
+
+    return false;
+  }
+
+  private async forwardResponseMessages(response: Response): Promise<void> {
+    if (response.status === 202) {
+      return;
+    }
+
+    const contentType = response.headers.get("Content-Type");
+    if (contentType === null) {
+      return;
+    }
+
+    const normalizedContentType = contentType.toLowerCase();
+    if (normalizedContentType.includes("text/event-stream")) {
+      await this.forwardSseResponseMessages(response);
+      return;
+    }
+
+    if (normalizedContentType.includes("application/json")) {
+      await this.forwardJsonResponseMessage(response);
+    }
+  }
+
+  private async forwardSseResponseMessages(response: Response): Promise<void> {
+    if (response.body === null) {
+      return;
+    }
+
+    const parser = new SseParser();
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    this.openSseReaders.add(reader);
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+
+        if (value === undefined) {
+          continue;
+        }
+
+        const messages = parser.push(decoder.decode(value, { stream: true }));
+        this.writeSseMessages(messages);
+        this.lastEventId = parser.lastEventId;
+      }
+
+      const trailingChunk = decoder.decode();
+      if (trailingChunk.length > 0) {
+        this.writeSseMessages(parser.push(trailingChunk));
+        this.lastEventId = parser.lastEventId;
+      }
+
+      this.writeSseMessages(parser.flush());
+      this.lastEventId = parser.lastEventId;
+    } finally {
+      this.openSseReaders.delete(reader);
+      reader.releaseLock();
+    }
+  }
+
+  private async forwardJsonResponseMessage(response: Response): Promise<void> {
+    const payload = await response.text();
+    if (payload.length === 0) {
+      return;
+    }
+
+    const parsedPayload = JSON.parse(payload) as unknown;
+    this.writeReadableLine(JSON.stringify(parsedPayload));
+  }
+
+  private writeSseMessages(messages: ParsedSseMessage[]): void {
+    for (const message of messages) {
+      this.writeReadableLine(message.data);
+    }
+  }
+
+  private writeReadableLine(line: string): void {
+    if (this.disposed || this.readStream.destroyed || this.readStream.writableEnded) {
+      return;
+    }
+
+    this.readStream.write(`${line}\n`);
+  }
+
+  private async fetchWithOAuthRetry(input: {
+    method: "GET" | "POST";
+    createHeaders: () => Promise<Headers>;
+    body?: BodyInit;
+  }): Promise<Response> {
+    const request = async (): Promise<Response> =>
+      this.fetchWithAbort(this.url, {
+        method: input.method,
+        headers: await input.createHeaders(),
+        body: input.body,
+      });
+
+    let response = await request();
+    if (await this.maybeHandleUnauthorizedResponse(response)) {
+      response = await request();
+    }
+
+    const oauthError = this.oauthProvider === undefined
+      ? null
+      : this.readOAuthChallengeError(response);
+    if (oauthError !== null) {
+      throw oauthError;
+    }
+
+    return response;
+  }
+
+  private readOAuthChallengeError(response: Response): OAuthError | null {
+    if (response.status !== 401 && response.status !== 403) {
+      return null;
+    }
+
+    const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
+    const error = challenge?.params.error;
+    if (error === undefined || error.length === 0) {
+      return null;
+    }
+
+    return new OAuthError(
+      {
+        error,
+        error_description: challenge?.params.error_description,
+        error_uri: challenge?.params.error_uri,
+      },
+      response.status
+    );
+  }
+}
+
+class HttpTransportGetSseNotSupportedError extends Error {
+  constructor() {
+    super("HTTP transport server does not support GET SSE streams");
+  }
+}
+
+export interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: RequestId;
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcErrorObject {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+export class McpError extends Error {
+  readonly code: number;
+  declare readonly data?: unknown;
+
+  constructor(code: number, message: string, data?: unknown) {
+    super(message);
+    this.name = "McpError";
+    this.code = code;
+    if (data !== undefined) {
+      this.data = data;
+    }
+  }
+}
+
+export interface JsonRpcSuccessResponse {
+  jsonrpc: "2.0";
+  id: RequestId;
+  result: unknown;
+}
+
+export interface JsonRpcErrorResponse {
+  jsonrpc: "2.0";
+  id: RequestId;
+  error: JsonRpcErrorObject;
+}
+
+export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+
+export type ParsedJsonRpcMessage =
+  | {
+      type: "request";
+      message: JsonRpcRequest;
+    }
+  | {
+      type: "notification";
+      message: JsonRpcNotification;
+    }
+  | {
+      type: "response";
+      message: JsonRpcResponse;
+    }
+  | {
+      type: "invalid";
+      id: RequestId | null;
+      error: McpError;
+    };
+
+export function serializeJsonRpcMessage(message: JsonRpcMessage): string {
+  return `${JSON.stringify(message)}\n`;
+}
+
+function chunkToString(chunk: unknown): string {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+
+  return String(chunk);
+}
+
+function normalizeLine(line: string): string {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+
+export async function* readLines(stream: Readable): AsyncGenerator<string> {
+  let buffer = "";
+
+  for await (const chunk of stream as AsyncIterable<unknown>) {
+    buffer += chunkToString(chunk);
+
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      yield normalizeLine(line);
+    }
+  }
+
+  if (buffer.length > 0) {
+    yield normalizeLine(buffer);
+  }
+}
+
+export interface ParsedSseMessage {
+  data: string;
+  id?: string;
+}
+
+export class SseParser {
+  private buffer = "";
+  private eventType: string | undefined;
+  private dataLines: string[] = [];
+  private eventId = "";
+  private hasEventId = false;
+  private _lastEventId: string | undefined;
+
+  get lastEventId(): string | undefined {
+    return this._lastEventId;
+  }
+
+  push(chunk: string): ParsedSseMessage[] {
+    if (chunk.length === 0) {
+      return [];
+    }
+
+    this.buffer += chunk;
+    const messages: ParsedSseMessage[] = [];
+
+    while (true) {
+      const newlineIndex = this.buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+
+      const line = normalizeLine(this.buffer.slice(0, newlineIndex));
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      this.consumeLine(line, messages);
+    }
+
+    return messages;
+  }
+
+  flush(): ParsedSseMessage[] {
+    const messages: ParsedSseMessage[] = [];
+
+    if (this.buffer.length > 0) {
+      this.consumeLine(normalizeLine(this.buffer), messages);
+      this.buffer = "";
+    }
+
+    this.emitEvent(messages);
+    return messages;
+  }
+
+  private consumeLine(line: string, messages: ParsedSseMessage[]): void {
+    if (line.length === 0) {
+      this.emitEvent(messages);
+      return;
+    }
+
+    if (line.startsWith(":")) {
+      return;
+    }
+
+    const separatorIndex = line.indexOf(":");
+    const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+    const rawValue = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
+    const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+
+    if (field === "event") {
+      this.eventType = value;
+      return;
+    }
+
+    if (field === "data") {
+      this.dataLines.push(value);
+      return;
+    }
+
+    if (field === "id") {
+      if (value.includes("\0")) {
+        return;
+      }
+
+      this.eventId = value;
+      this.hasEventId = true;
+    }
+  }
+
+  private emitEvent(messages: ParsedSseMessage[]): void {
+    const eventType = this.eventType ?? "message";
+
+    if (this.hasEventId) {
+      this._lastEventId = this.eventId;
+    }
+
+    if (this.dataLines.length === 0 || eventType !== "message") {
+      this.resetEvent();
+      return;
+    }
+
+    const message: ParsedSseMessage = {
+      data: this.dataLines.join("\n"),
+    };
+
+    if (this.hasEventId) {
+      message.id = this.eventId;
+    }
+
+    messages.push(message);
+    this.resetEvent();
+  }
+
+  private resetEvent(): void {
+    this.eventType = undefined;
+    this.dataLines = [];
+    this.eventId = "";
+    this.hasEventId = false;
+  }
+}
+
+interface PendingRequest {
+  resolve: (result: unknown) => void;
+  reject: (error: unknown) => void;
+  timeout: ReturnType<typeof setTimeout>;
+}
+
+interface ActiveIncomingRequest {
+  cancelled: boolean;
+}
+
+export interface JsonRpcRequestOptions {
+  timeoutMs?: number;
+  onRequestId?: (requestId: RequestId) => void;
+}
+
+interface JsonRpcRequestContext {
+  id: RequestId;
+  method: string;
+}
+
+type JsonRpcRequestHandler = (
+  params: unknown,
+  context: JsonRpcRequestContext
+) => unknown | Promise<unknown>;
+
+interface JsonRpcNotificationContext {
+  method: string;
+}
+
+type JsonRpcNotificationHandler = (
+  params: unknown,
+  context: JsonRpcNotificationContext
+) => unknown | Promise<unknown>;
+
+export class JsonRpcMessageLayer {
+  readonly requestTimeoutMs: number;
+  private readonly input: Readable;
+  private readonly output: Writable;
+  private readonly inputClosedReason: Promise<Error> | undefined;
+  private nextRequestId = 1;
+  private disposedError: Error | undefined;
+  private readonly pendingRequests = new Map<RequestId, PendingRequest>();
+  private readonly activeIncomingRequests = new Map<RequestId, ActiveIncomingRequest>();
+  private readonly requestHandlers = new Map<string, JsonRpcRequestHandler>();
+  private readonly notificationHandlers = new Map<string, JsonRpcNotificationHandler>();
+
+  constructor(
+    input: Readable,
+    output: Writable,
+    requestTimeoutMs = 30_000,
+    inputClosedReason?: Promise<Error>
+  ) {
+    if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs < 0) {
+      throw new Error("requestTimeoutMs must be a non-negative finite number");
+    }
+
+    this.input = input;
+    this.output = output;
+    this.inputClosedReason = inputClosedReason;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.consumeInput().catch(() => undefined);
+  }
+
+  sendNotification(method: string, params?: unknown): void {
+    if (this.disposedError !== undefined) {
+      throw this.disposedError;
+    }
+
+    const message: JsonRpcNotification = {
+      jsonrpc: "2.0",
+      method,
+    };
+
+    if (params !== undefined) {
+      message.params = params;
+    }
+
+    this.output.write(serializeJsonRpcMessage(message));
+  }
+
+  onRequest(method: string, handler: JsonRpcRequestHandler): void {
+    this.requestHandlers.set(method, handler);
+  }
+
+  onNotification(method: string, handler: JsonRpcNotificationHandler): void {
+    this.notificationHandlers.set(method, handler);
+  }
+
+  sendRequest(
+    method: string,
+    params?: unknown,
+    options: JsonRpcRequestOptions = {}
+  ): Promise<unknown> {
+    if (this.disposedError !== undefined) {
+      throw this.disposedError;
+    }
+
+    const id = this.nextRequestId;
+    this.nextRequestId += 1;
+    const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
+
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new Error("timeoutMs must be a non-negative finite number");
+    }
+    if (options.onRequestId !== undefined) {
+      options.onRequestId(id);
+    }
+
+    const message: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id,
+      method,
+    };
+
+    if (params !== undefined) {
+      message.params = params;
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+
+      try {
+        this.output.write(serializeJsonRpcMessage(message));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingRequests.delete(id);
+        reject(error);
+      }
+    });
+  }
+
+  dispose(reason = new Error("JSON-RPC message layer disposed")): void {
+    if (this.disposedError !== undefined) {
+      return;
+    }
+
+    this.disposedError = reason;
+
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(reason);
+    }
+
+    this.pendingRequests.clear();
+    this.activeIncomingRequests.clear();
+  }
+
+  private async consumeInput(): Promise<void> {
+    try {
+      for await (const line of readLines(this.input)) {
+        if (this.disposedError !== undefined) {
+          break;
+        }
+
+        if (line.length === 0) {
+          continue;
+        }
+
+        let parsedLine: unknown;
+        try {
+          parsedLine = JSON.parse(line);
+        } catch {
+          await this.processParsedMessage({
+            type: "invalid",
+            id: null,
+            error: parseError(),
+          });
+          continue;
+        }
+
+        if (Array.isArray(parsedLine)) {
+          for (const message of parsedLine) {
+            if (this.disposedError !== undefined) {
+              break;
+            }
+
+            await this.processParsedMessage(parseJsonRpcPayload(message));
+          }
+          continue;
+        }
+
+        await this.processParsedMessage(parseJsonRpcPayload(parsedLine));
+      }
+    } catch (error) {
+      if (this.disposedError === undefined) {
+        this.dispose(
+          error instanceof Error
+            ? error
+            : new Error(`JSON-RPC input stream failed: ${String(error)}`)
+        );
+      }
+      return;
+    }
+
+    if (this.disposedError === undefined) {
+      const streamClosedReason = await this.resolveInputStreamClosedReason();
+      if (this.disposedError === undefined) {
+        this.dispose(streamClosedReason);
+      }
+    }
+  }
+
+  private async resolveInputStreamClosedReason(): Promise<Error> {
+    const streamClosedError = new Error("JSON-RPC input stream closed");
+    if (this.inputClosedReason === undefined) {
+      return streamClosedError;
+    }
+
+    try {
+      return await Promise.race([
+        this.inputClosedReason,
+        new Promise<Error>((resolve) => {
+          setTimeout(() => {
+            resolve(streamClosedError);
+          }, 50);
+        }),
+      ]);
+    } catch {
+      return streamClosedError;
+    }
+  }
+
+  private async processParsedMessage(parsed: ParsedJsonRpcMessage): Promise<void> {
+    if (parsed.type === "request") {
+      const handler = this.requestHandlers.get(parsed.message.method);
+      if (handler === undefined) {
+        this.output.write(
+          serializeJsonRpcMessage({
+            jsonrpc: "2.0",
+            id: parsed.message.id,
+            error: {
+              code: ERROR_METHOD_NOT_FOUND,
+              message: `Method not found: ${parsed.message.method}`,
+            },
+          })
+        );
+        return;
+      }
+
+      this.handleIncomingRequest(parsed.message, handler);
+      return;
+    }
+
+    if (parsed.type === "notification") {
+      if (parsed.message.method === "notifications/cancelled") {
+        this.handleCancellationNotification(parsed.message.params);
+      }
+
+      const handler = this.notificationHandlers.get(parsed.message.method);
+      if (handler === undefined) {
+        return;
+      }
+
+      try {
+        await handler(parsed.message.params, {
+          method: parsed.message.method,
+        });
+      } catch {
+        return;
+      }
+      return;
+    }
+
+    if (parsed.type === "invalid") {
+      const errorResponse: {
+        jsonrpc: "2.0";
+        id: RequestId | null;
+        error: JsonRpcErrorObject;
+      } = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        error: {
+          code: parsed.error.code,
+          message: parsed.error.message,
+        },
+      };
+
+      if (parsed.error.data !== undefined) {
+        errorResponse.error.data = parsed.error.data;
+      }
+
+      this.output.write(`${JSON.stringify(errorResponse)}\n`);
+      return;
+    }
+
+    if (parsed.type !== "response") {
+      return;
+    }
+
+    const pending = this.pendingRequests.get(parsed.message.id);
+    if (pending === undefined) {
+      return;
+    }
+
+    this.pendingRequests.delete(parsed.message.id);
+    clearTimeout(pending.timeout);
+    if ("result" in parsed.message) {
+      pending.resolve(parsed.message.result);
+      return;
+    }
+
+    pending.reject(
+      new McpError(
+        parsed.message.error.code,
+        parsed.message.error.message,
+        parsed.message.error.data
+      )
+    );
+  }
+
+  private handleIncomingRequest(message: JsonRpcRequest, handler: JsonRpcRequestHandler): void {
+    const activeRequest: ActiveIncomingRequest = {
+      cancelled: false,
+    };
+    this.activeIncomingRequests.set(message.id, activeRequest);
+
+    void (async () => {
+      try {
+        const result = await handler(message.params, {
+          id: message.id,
+          method: message.method,
+        });
+
+        if (this.disposedError !== undefined || activeRequest.cancelled) {
+          return;
+        }
+
+        this.output.write(
+          serializeJsonRpcMessage({
+            jsonrpc: "2.0",
+            id: message.id,
+            result,
+          })
+        );
+      } catch (error) {
+        if (this.disposedError !== undefined || activeRequest.cancelled) {
+          return;
+        }
+
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.output.write(
+          serializeJsonRpcMessage({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: {
+              code: ERROR_INTERNAL,
+              message: errorMessage,
+            },
+          })
+        );
+      } finally {
+        const inFlightRequest = this.activeIncomingRequests.get(message.id);
+        if (inFlightRequest === activeRequest) {
+          this.activeIncomingRequests.delete(message.id);
+        }
+      }
+    })();
+  }
+
+  private handleCancellationNotification(params: unknown): void {
+    if (!isObjectRecord(params)) {
+      return;
+    }
+
+    const requestId = params.requestId;
+    if (!isRequestId(requestId)) {
+      return;
+    }
+
+    const activeRequest = this.activeIncomingRequests.get(requestId);
+    if (activeRequest === undefined) {
+      return;
+    }
+
+    activeRequest.cancelled = true;
+    this.activeIncomingRequests.delete(requestId);
+  }
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasOwn(
+  value: Record<string, unknown>,
+  property: string
+): property is keyof typeof value {
+  return Object.prototype.hasOwnProperty.call(value, property);
+}
+
+function isRequestId(value: unknown): value is RequestId {
+  return typeof value === "string" || typeof value === "number";
+}
+
+function isLogLevel(value: unknown): value is LogLevel {
+  return (
+    value === "debug" ||
+    value === "info" ||
+    value === "notice" ||
+    value === "warning" ||
+    value === "error" ||
+    value === "critical" ||
+    value === "alert" ||
+    value === "emergency"
+  );
+}
+
+function toRequestId(value: unknown): RequestId | null {
+  return isRequestId(value) ? value : null;
+}
+
+function parseError(): McpError {
+  return new McpError(ERROR_PARSE, "Parse error");
+}
+
+function invalidRequest(): McpError {
+  return new McpError(ERROR_INVALID_REQUEST, "Invalid Request");
+}
+
+function isJsonRpcErrorObject(value: unknown): value is JsonRpcErrorObject {
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+
+  if (typeof value.code !== "number" || typeof value.message !== "string") {
+    return false;
+  }
+
+  return value.data === undefined || hasOwn(value, "data");
+}
+
+export function parseJsonRpcMessage(line: string): ParsedJsonRpcMessage {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return {
+      type: "invalid",
+      id: null,
+      error: parseError(),
+    };
+  }
+
+  return parseJsonRpcPayload(parsed);
+}
+
+function parseJsonRpcPayload(parsed: unknown): ParsedJsonRpcMessage {
+  if (!isObjectRecord(parsed)) {
+    return {
+      type: "invalid",
+      id: null,
+      error: invalidRequest(),
+    };
+  }
+
+  const id = toRequestId(parsed.id);
+
+  if (parsed.jsonrpc !== "2.0") {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest(),
+    };
+  }
+
+  const hasMethod = hasOwn(parsed, "method");
+  const hasId = hasOwn(parsed, "id");
+
+  if (hasMethod) {
+    if (typeof parsed.method !== "string") {
+      return {
+        type: "invalid",
+        id,
+        error: invalidRequest(),
+      };
+    }
+
+    if (hasId) {
+      if (!isRequestId(parsed.id)) {
+        return {
+          type: "invalid",
+          id: null,
+          error: invalidRequest(),
+        };
+      }
+
+      const request: JsonRpcRequest = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        method: parsed.method,
+      };
+
+      if (hasOwn(parsed, "params")) {
+        request.params = parsed.params;
+      }
+
+      return {
+        type: "request",
+        message: request,
+      };
+    }
+
+    const notification: JsonRpcNotification = {
+      jsonrpc: "2.0",
+      method: parsed.method,
+    };
+
+    if (hasOwn(parsed, "params")) {
+      notification.params = parsed.params;
+    }
+
+    return {
+      type: "notification",
+      message: notification,
+    };
+  }
+
+  if (!hasId || !isRequestId(parsed.id)) {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest(),
+    };
+  }
+
+  const hasResult = hasOwn(parsed, "result");
+  const hasError = hasOwn(parsed, "error");
+
+  if (hasResult === hasError) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest(),
+    };
+  }
+
+  if (hasResult) {
+    return {
+      type: "response",
+      message: {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        result: parsed.result,
+      },
+    };
+  }
+
+  if (!isJsonRpcErrorObject(parsed.error)) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest(),
+    };
+  }
+
+  return {
+    type: "response",
+    message: {
+      jsonrpc: "2.0",
+      id: parsed.id,
+      error: parsed.error,
+    },
+  };
+}