@herbertgao/pi-extensions 2026.8.1 → 2026.8.3

package/node_modules/pi-mcp-adapter/mcp-panel.ts

@@ -52,6 +52,7 @@ function rainbowProgress(filled: number, total: number): string {
   const dots: string[] = [];
   for (let i = 0; i < total; i++) {
     const color = RAINBOW_COLORS[i % RAINBOW_COLORS.length];
+    if (!color) continue;
     dots.push(fg(color, i < filled ? "●" : "○"));
   }
   return dots.join(" ");
@@ -220,7 +221,10 @@ class McpPanel {
             }
 
             const isDirect = toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(baseName));
-            const ct: CachedTool = { name: baseName, description: resource.description };
+            const ct: CachedTool = {
+              name: baseName,
+              ...(resource.description !== undefined ? { description: resource.description } : {}),
+            };
             tools.push({
               name: baseName,
               description: resource.description ?? `Read resource: ${resource.uri}`,
@@ -239,9 +243,9 @@ class McpPanel {
         name: serverName,
         expanded: false,
         source: prov?.kind ?? "user",
-        importKind: prov?.importKind,
-        includeTools: definition.includeTools,
-        excludeTools: definition.excludeTools,
+        ...(prov?.importKind !== undefined ? { importKind: prov.importKind } : {}),
+        ...(definition.includeTools !== undefined ? { includeTools: definition.includeTools } : {}),
+        ...(definition.excludeTools !== undefined ? { excludeTools: definition.excludeTools } : {}),
         exposeResources: definition.exposeResources !== false,
         connectionStatus: status,
         failureMessage,
@@ -276,6 +280,7 @@ class McpPanel {
     this.visibleItems = [];
     for (let si = 0; si < this.servers.length; si++) {
       const server = this.servers[si];
+      if (!server) continue;
       if (query && this.authOnly) {
         const score = mode === "name" ? fuzzyScore(query, server.name) : 0;
         if (score > 0) {
@@ -288,6 +293,7 @@ class McpPanel {
       if (server.expanded || query) {
         for (let ti = 0; ti < server.tools.length; ti++) {
           const tool = server.tools[ti];
+          if (!tool) continue;
           if (query) {
             const score = mode === "name"
               ? Math.max(
@@ -352,7 +358,7 @@ class McpPanel {
       return;
     }
 
-    if (matchesKey(data, "ctrl+s")) {
+    if (this.keys.save(data)) {
       this.cleanup();
       this.done(this.buildResult());
       return;
@@ -422,6 +428,7 @@ class McpPanel {
       const item = this.visibleItems[this.cursorIndex];
       if (!item) return;
       const server = this.servers[item.serverIndex];
+      if (!server) return;
       if (item.type === "server") {
         if (server.connectionStatus === "disabled") return;
         if (this.authOnly || server.connectionStatus === "needs-auth") {
@@ -433,6 +440,7 @@ class McpPanel {
         this.cursorIndex = Math.min(this.cursorIndex, Math.max(0, this.visibleItems.length - 1));
       } else if (item.toolIndex !== undefined) {
         const tool = server.tools[item.toolIndex];
+        if (!tool) return;
         tool.isDirect = !tool.isDirect;
         if (tool.isDirect && server.source === "import") {
           this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
@@ -451,7 +459,8 @@ class McpPanel {
     if (matchesKey(data, "ctrl+r")) {
       const item = this.visibleItems[this.cursorIndex];
       if (!item) return;
-      this.reconnectServer(this.servers[item.serverIndex]);
+      const server = this.servers[item.serverIndex];
+      if (server) this.reconnectServer(server);
       return;
     }
 
@@ -459,7 +468,7 @@ class McpPanel {
       const item = this.visibleItems[this.cursorIndex];
       if (!item) return;
       const server = this.servers[item.serverIndex];
-      if (server.connectionStatus !== "failed" || !server.failureMessage) return;
+      if (!server || server.connectionStatus !== "failed" || !server.failureMessage) return;
       const serverName = sanitizeDisplayText(server.name);
       const failureMessage = sanitizeDisplayText(server.failureMessage);
       copyToClipboard(failureMessage).then(() => {
@@ -502,7 +511,8 @@ class McpPanel {
   }
 
   private authenticateSelectedServer(item: VisibleItem): void {
-    this.authenticateServer(this.servers[item.serverIndex]);
+    const server = this.servers[item.serverIndex];
+    if (server) this.authenticateServer(server);
   }
 
   private authenticateServer(server: ServerState): void {
@@ -574,6 +584,7 @@ class McpPanel {
   private toggleItem(item: VisibleItem): void {
     if (this.authOnly) return;
     const server = this.servers[item.serverIndex];
+    if (!server) return;
     if (item.type === "server") {
       const newState = !server.tools.every((t) => t.isDirect);
       if (server.source === "import" && newState) {
@@ -582,6 +593,7 @@ class McpPanel {
       for (const t of server.tools) t.isDirect = newState;
     } else if (item.toolIndex !== undefined) {
       const tool = server.tools[item.toolIndex];
+      if (!tool) return;
       tool.isDirect = !tool.isDirect;
       if (tool.isDirect && server.source === "import") {
         this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
@@ -654,7 +666,10 @@ class McpPanel {
 
         const prev = existingState.get(baseName);
         const isDirect = prev !== undefined ? prev : false;
-        const ct: CachedTool = { name: baseName, description: resource.description };
+        const ct: CachedTool = {
+          name: baseName,
+          ...(resource.description !== undefined ? { description: resource.description } : {}),
+        };
         newTools.push({
           name: baseName,
           description: resource.description ?? `Read resource: ${resource.uri}`,
@@ -724,8 +739,10 @@ class McpPanel {
 
       for (let i = startIdx; i < endIdx; i++) {
         const item = this.visibleItems[i];
+        if (!item) continue;
         const isCursor = i === this.cursorIndex;
         const server = this.servers[item.serverIndex];
+        if (!server) continue;
 
         if (item.type === "server") {
           lines.push(row(this.renderServerRow(server, isCursor)));
@@ -735,7 +752,8 @@ class McpPanel {
             }
           }
         } else if (item.toolIndex !== undefined) {
-          lines.push(row(this.renderToolRow(server.tools[item.toolIndex], isCursor, innerW)));
+          const tool = server.tools[item.toolIndex];
+          if (tool) lines.push(row(this.renderToolRow(tool, isCursor, innerW)));
         }
       }
 
@@ -784,6 +802,7 @@ class McpPanel {
     }
 
     lines.push(emptyRow());
+    const saveLabel = this.keys.saveLabel();
     const hints = this.authOnly
       ? [
           italic("↑↓") + " navigate",
@@ -800,7 +819,7 @@ class McpPanel {
           italic("ctrl+r") + " reconnect",
           ...(this.selectedServerHasFailureMessage() ? [italic("ctrl+y") + " copy error"] : []),
           italic("?") + " desc search",
-          italic("ctrl+s") + " save",
+          ...(saveLabel ? [italic(saveLabel) + " save"] : []),
           italic("esc") + " clear/close",
           italic("ctrl+c") + " quit",
         ];
@@ -871,7 +890,7 @@ class McpPanel {
     const item = this.visibleItems[this.cursorIndex];
     if (!item) return false;
     const server = this.servers[item.serverIndex];
-    return server.connectionStatus === "failed" && !!server.failureMessage;
+    return server?.connectionStatus === "failed" && !!server.failureMessage;
   }
 
   private wrapText(text: string, width: number): string[] {
@@ -884,11 +903,11 @@ class McpPanel {
       while (visibleWidth(rest) > max) {
         let take = "";
         let index = 0;
-        while (index < rest.length && visibleWidth(take + rest[index]) <= max) {
-          take += rest[index];
+        while (index < rest.length && visibleWidth(take + rest.charAt(index)) <= max) {
+          take += rest.charAt(index);
           index++;
         }
-        if (!take) take = rest[0];
+        if (!take) take = rest.charAt(0);
         lines.push(take);
         rest = rest.slice(take.length);
       }

package/node_modules/pi-mcp-adapter/mcp-probe.ts

@@ -1,25 +1,102 @@
 const PROBE_TIMEOUT_MS = 5_000;
+const MODERN_PROTOCOL_VERSION = "2026-07-28";
+const LEGACY_PROTOCOL_VERSION = "2025-06-18";
+const JSON_ACCEPT = "application/json, text/event-stream";
+const SSE_ACCEPT = "text/event-stream";
+const MODERN_FALLBACK_STATUSES = new Set([400, 401, 404, 405, 406, 415]);
+const POST_ENDPOINT_MISMATCH_STATUSES = new Set([404, 405, 406, 415]);
 
 export interface McpProbeResult {
   isMcp: boolean;
   classification: string;
 }
 
+const DISCOVER_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "server/discover",
+  params: {},
+};
+
 const INITIALIZE_REQUEST = {
   jsonrpc: "2.0",
   id: 1,
   method: "initialize",
   params: {
-    protocolVersion: "2025-06-18",
+    protocolVersion: LEGACY_PROTOCOL_VERSION,
     capabilities: {},
     clientInfo: { name: "pi-mcp-probe", version: "2.1.2" },
   },
 };
 
-function isJsonRpcEnvelope(value: unknown): boolean {
-  return typeof value === "object" && value !== null &&
-    (value as { jsonrpc?: unknown }).jsonrpc === "2.0" &&
-    ("result" in value || "error" in value);
+type ProbeStrategy =
+  | { kind: "modern"; request: RequestInit; allowJson: true }
+  | { kind: "legacy-post"; request: RequestInit; allowJson: true }
+  | { kind: "legacy-sse"; request: RequestInit; allowJson: false };
+
+const MODERN_STRATEGY: ProbeStrategy = {
+  kind: "modern",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
+      "Mcp-Method": "server/discover",
+    },
+    body: JSON.stringify(DISCOVER_REQUEST),
+  },
+  allowJson: true,
+};
+
+const LEGACY_POST_STRATEGY: ProbeStrategy = {
+  kind: "legacy-post",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(INITIALIZE_REQUEST),
+  },
+  allowJson: true,
+};
+
+const LEGACY_SSE_STRATEGY: ProbeStrategy = {
+  kind: "legacy-sse",
+  request: { headers: { Accept: SSE_ACCEPT } },
+  allowJson: false,
+};
+
+type JsonRpcEnvelopeInfo =
+  | { kind: "result"; protocolVersion: unknown }
+  | { kind: "error" };
+
+type ProbeOutcome =
+  | { kind: "mcp"; result: McpProbeResult }
+  | { kind: "unsupported-modern" }
+  | { kind: "unrecognized" };
+
+interface ProbeResult {
+  response: Response;
+  outcome: ProbeOutcome;
+}
+
+function jsonRpcEnvelopeInfo(value: unknown): JsonRpcEnvelopeInfo | null {
+  if (typeof value !== "object" || value === null || (value as { jsonrpc?: unknown }).jsonrpc !== "2.0") {
+    return null;
+  }
+  if ("result" in value) {
+    const result = (value as { result?: unknown }).result;
+    return {
+      kind: "result",
+      protocolVersion: typeof result === "object" && result !== null
+        ? (result as { protocolVersion?: unknown }).protocolVersion
+        : undefined,
+    };
+  }
+  if ("error" in value) return { kind: "error" };
+  return null;
 }
 
 function isBearerChallenge(response: Response): boolean {
@@ -33,29 +110,56 @@ function responseKind(response: Response): string {
   return "an untyped response";
 }
 
-async function hasJsonRpcEnvelope(response: Response): Promise<boolean> {
+async function getJsonRpcEnvelopeInfo(response: Response): Promise<JsonRpcEnvelopeInfo | null> {
   try {
-    return isJsonRpcEnvelope(JSON.parse(await response.text()));
+    return jsonRpcEnvelopeInfo(JSON.parse(await response.text()));
   } catch {
-    return false;
+    return null;
   }
 }
 
-async function classifyResponse(response: Response, allowJson: boolean): Promise<McpProbeResult | null> {
+async function classifyResponse(response: Response, strategy: ProbeStrategy): Promise<ProbeOutcome> {
   const isSse = response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream");
   if (response.ok && isSse) {
-    return { isMcp: true, classification: "endpoint responded with an MCP event stream" };
+    return { kind: "mcp", result: { isMcp: true, classification: "endpoint responded with an MCP event stream" } };
   }
 
-  const isJsonRpc = (allowJson || response.status === 401) && await hasJsonRpcEnvelope(response);
-  if (response.ok && allowJson && isJsonRpc) {
-    return { isMcp: true, classification: "endpoint responded with a JSON-RPC 2.0 envelope" };
+  const envelope = (strategy.allowJson || response.status === 401) ? await getJsonRpcEnvelopeInfo(response) : null;
+  if (response.ok && strategy.allowJson && envelope) {
+    if (strategy.kind === "modern" && (envelope.kind === "error" || envelope.protocolVersion !== MODERN_PROTOCOL_VERSION)) {
+      return { kind: "unsupported-modern" };
+    }
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern"
+          ? `endpoint supports stateless MCP ${MODERN_PROTOCOL_VERSION} server/discover`
+          : "endpoint responded with a JSON-RPC 2.0 envelope",
+      },
+    };
   }
-  if (response.status === 401 && isBearerChallenge(response) && isJsonRpc) {
-    return { isMcp: true, classification: "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error" };
+  if (response.status === 401 && isBearerChallenge(response) && envelope) {
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern"
+          ? `endpoint requires Bearer authentication during MCP ${MODERN_PROTOCOL_VERSION} server/discover probing`
+          : "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error",
+      },
+    };
   }
 
-  return null;
+  return { kind: "unrecognized" };
+}
+
+async function probe(url: string | URL, strategy: ProbeStrategy): Promise<ProbeResult> {
+  const response = await fetch(url, {
+    ...strategy.request,
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+  });
+  return { response, outcome: await classifyResponse(response, strategy) };
 }
 
 function notMcp(response: Response): McpProbeResult {
@@ -67,24 +171,17 @@ function notMcp(response: Response): McpProbeResult {
 
 /** Makes one unauthenticated metadata-only request to identify an HTTP endpoint's protocol shape. */
 export async function probeMcpEndpoint(url: string | URL): Promise<McpProbeResult> {
-  const postResponse = await fetch(url, {
-    method: "POST",
-    headers: {
-      Accept: "application/json, text/event-stream",
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(INITIALIZE_REQUEST),
-    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-  });
-  const postClassification = await classifyResponse(postResponse, true);
-  if (postClassification) return postClassification;
+  const { response: modernResponse, outcome: modernOutcome } = await probe(url, MODERN_STRATEGY);
+  if (modernOutcome.kind === "mcp") return modernOutcome.result;
 
-  if (![404, 405, 406, 415].includes(postResponse.status)) return notMcp(postResponse);
+  if (modernOutcome.kind !== "unsupported-modern" && !MODERN_FALLBACK_STATUSES.has(modernResponse.status)) {
+    return notMcp(modernResponse);
+  }
 
-  const getResponse = await fetch(url, {
-    headers: { Accept: "text/event-stream" },
-    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-  });
-  const getClassification = await classifyResponse(getResponse, false);
-  return getClassification ?? notMcp(getResponse);
+  const { response: postResponse, outcome: postOutcome } = await probe(url, LEGACY_POST_STRATEGY);
+  if (postOutcome.kind === "mcp") return postOutcome.result;
+  if (!POST_ENDPOINT_MISMATCH_STATUSES.has(postResponse.status)) return notMcp(postResponse);
+
+  const { response: getResponse, outcome: getOutcome } = await probe(url, LEGACY_SSE_STRATEGY);
+  return getOutcome.kind === "mcp" ? getOutcome.result : notMcp(getResponse);
 }

package/node_modules/pi-mcp-adapter/mcp-script-worker.mjs

@@ -113,9 +113,9 @@ try {
     console: capturedConsole,
   }), {
     codeGeneration: { strings: false, wasm: false },
-    name: "mcp_script",
+    name: "mcpScript",
   });
-  const script = new vm.Script(`(async () => {\n${workerData.code}\n})()`, { filename: "mcp_script.js" });
+  const script = new vm.Script(`(async () => {\n${workerData.code}\n})()`, { filename: "mcpScript.js" });
   const returnValue = await Promise.resolve(script.runInContext(context));
   parentPort.postMessage(returnValue === undefined
     ? { type: "done" }

package/node_modules/pi-mcp-adapter/mcp-setup-panel.ts

@@ -169,9 +169,9 @@ export class McpSetupPanel {
     return [...new Set(paths)];
   }
 
-  private getSelectedAction(): Action | null {
+  private getSelectedAction(): Action | undefined {
     const actions = this.getActions();
-    return actions[this.actionCursor] ?? null;
+    return actions[this.actionCursor];
   }
 
   handleInput(data: string): void {
@@ -414,6 +414,7 @@ export class McpSetupPanel {
     }
     for (let index = start; index < end; index++) {
       const action = actions[index];
+      if (!action) continue;
       if (action.id === "add-known-server" && (index === start || actions[index - 1]?.id !== "add-known-server")) {
         lines.push(this.padLine(fg(this.t.title, "Add a known server"), innerW));
       }
@@ -442,6 +443,7 @@ export class McpSetupPanel {
     lines.push(this.padLine("", innerW));
     for (let index = 0; index < this.discovery.imports.length; index++) {
       const entry = this.discovery.imports[index];
+      if (!entry) continue;
       const selected = this.selectedImports.has(entry.kind) ? "[x]" : "[ ]";
       const cursor = index === this.importCursor ? fg(this.t.selected, "›") : " ";
       lines.push(this.padLine(`${cursor} ${selected} ${entry.kind}  ${entry.path}`, innerW));
@@ -462,7 +464,8 @@ export class McpSetupPanel {
     const paths = this.getDetectedPaths();
     for (let index = 0; index < paths.length; index++) {
       const cursor = index === this.pathCursor ? fg(this.t.selected, "›") : " ";
-      lines.push(this.padLine(`${cursor} ${paths[index]}`, innerW));
+      const path = paths[index];
+      if (path !== undefined) lines.push(this.padLine(`${cursor} ${path}`, innerW));
     }
     return lines;
   }
@@ -537,7 +540,7 @@ export class McpSetupPanel {
           '  "mcpServers": {',
           '    "chrome-devtools": {',
           '      "command": "npx",',
-          '      "args": ["-y", "chrome-devtools-mcp@latest"]',
+          '      "args": ["-y", "chrome-devtools-mcp@1.6.0"]',
           "    }",
           "  }",
           "}",

package/node_modules/pi-mcp-adapter/mcp-trace.ts

@@ -1,8 +1,8 @@
 import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import { dirname, isAbsolute, resolve } from "node:path";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { JSONRPCMessage, MessageExtraInfo } from "@modelcontextprotocol/sdk/types.js";
+import type { Transport } from "@modelcontextprotocol/client";
+import type { JSONRPCMessage, MessageExtraInfo } from "@modelcontextprotocol/client";
 
 export const MCP_TRACE_SCHEMA_VERSION = 1;
 export const DEFAULT_MCP_TRACE_MAX_BYTES = 256 * 1024;
@@ -95,6 +95,7 @@ export function createMcpTraceEvent(
   options?: { relatedRequestId?: unknown; durationMs?: number },
 ): McpTraceEvent {
   const kind = messageKind(message);
+  const bytes = messageBytes(message);
   const event: McpTraceEvent = {
     version: MCP_TRACE_SCHEMA_VERSION,
     timestamp: new Date().toISOString(),
@@ -103,7 +104,7 @@ export function createMcpTraceEvent(
     transport,
     kind,
     status,
-    bytes: messageBytes(message),
+    ...(bytes !== undefined ? { bytes } : {}),
   };
   if ("method" in message) event.method = redactTraceText(message.method, 120);
   if ("id" in message) event.id = traceId(message.id) ?? null;
@@ -210,8 +211,8 @@ export function createMcpTraceWriter(
     : resolve(sessionCwd ?? process.cwd(), ".pi", "mcp-traces", `mcp-${timestamp}-${randomSuffix}.jsonl`);
   return new McpTraceWriter({
     filePath,
-    maxBytes: settings.maxBytes,
-    maxEvents: settings.maxEvents,
+    ...(settings.maxBytes !== undefined ? { maxBytes: settings.maxBytes } : {}),
+    ...(settings.maxEvents !== undefined ? { maxEvents: settings.maxEvents } : {}),
   });
 }
 
@@ -227,17 +228,20 @@ export function isMcpTraceEnabled(
 }
 
 /**
- * Compose the SDK's transport callbacks instead of replacing them. Protocol
- * assigns `onmessage` during connect, so the setter must keep the observer in
- * front of whichever callback the SDK installs.
+ * Compose the SDK's transport callbacks in place instead of replacing the
+ * transport object. SDK v2 detects its base stdio transport before connect so
+ * it can run `server/discover` on a disposable sibling process; returning a
+ * wrapper hides that identity and makes tracing change negotiation behavior.
  */
-export function wrapTransportWithMcpTrace<T extends Transport>(
-  transport: T,
+export function wrapTransportWithMcpTrace(
+  transport: Transport,
   server: string,
   transportKind: McpTraceTransport,
   observer: McpTraceObserver,
-): T {
-  let messageHandler: Transport["onmessage"];
+): Transport {
+  let messageHandler = transport.onmessage;
+  let tracedMessageHandler: Transport["onmessage"];
+  const originalSend = transport.send;
   const record = (event: McpTraceEvent): void => {
     try {
       observer.record(event);
@@ -245,60 +249,51 @@ export function wrapTransportWithMcpTrace<T extends Transport>(
       // An observer failure must never alter SDK transport behavior.
     }
   };
-  const traced: Transport = {
-    start: () => transport.start(),
-    send: async (message, options) => {
-      const started = performance.now();
-      const messages = Array.isArray(message) ? message : [message];
-      try {
-        await transport.send(message, options);
-        for (const item of messages) {
-          record(createMcpTraceEvent("outbound", server, transportKind, item, "sent", {
-            durationMs: performance.now() - started,
-          }));
-        }
-      } catch (error) {
-        for (const item of messages) {
-          record(createMcpTraceEvent("outbound", server, transportKind, item, "error", {
-            durationMs: performance.now() - started,
-          }));
-        }
-        throw error;
+
+  try {
+    Object.defineProperty(transport, "onmessage", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return tracedMessageHandler;
+      },
+      set(handler: Transport["onmessage"]) {
+        messageHandler = handler;
+        tracedMessageHandler = handler
+          ? ((message: JSONRPCMessage, extra?: MessageExtraInfo) => {
+              record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
+              handler(message, extra);
+            })
+          : undefined;
+      },
+    });
+    transport.onmessage = messageHandler;
+  } catch {
+    // Some future transport may make onmessage non-configurable. Keep tracing
+    // best-effort rather than changing connection behavior.
+  }
+
+  transport.send = async (message: JSONRPCMessage, options?: Parameters<Transport["send"]>[1]) => {
+    const started = performance.now();
+    const messages = Array.isArray(message) ? message : [message];
+    try {
+      await originalSend.call(transport, message, options);
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "sent", {
+          durationMs: performance.now() - started,
+        }));
+      }
+    } catch (error) {
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "error", {
+          durationMs: performance.now() - started,
+        }));
       }
-    },
-    close: () => transport.close(),
-    get onclose() {
-      return transport.onclose;
-    },
-    set onclose(handler) {
-      transport.onclose = handler;
-    },
-    get onerror() {
-      return transport.onerror;
-    },
-    set onerror(handler) {
-      transport.onerror = handler;
-    },
-    get onmessage() {
-      return messageHandler;
-    },
-    set onmessage(handler) {
-      messageHandler = handler;
-      transport.onmessage = handler
-        ? ((message: JSONRPCMessage, extra?: MessageExtraInfo) => {
-            record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
-            handler(message, extra);
-          }) as Transport["onmessage"]
-        : undefined;
-    },
-    get sessionId() {
-      return transport.sessionId;
-    },
-    setProtocolVersion: transport.setProtocolVersion
-      ? version => transport.setProtocolVersion!(version)
-      : undefined,
+      throw error;
+    }
   };
-  return traced as T;
+
+  return transport;
 }
 
 export function traceTransportKind(definition: { command?: string; url?: string; socket?: string }, transport: Transport): McpTraceTransport {