@herbertgao/pi-extensions 2026.8.1 → 2026.8.2

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 {

package/node_modules/pi-mcp-adapter/metadata-cache.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "
 import { dirname } from "node:path";
 import { getAgentPath } from "./agent-dir.ts";
 import { createHash } from "node:crypto";
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
+import { getToolUiResourceUri } from "./ui-app-bridge-helpers.ts";
 import type {
   CachedPrompt,
   CachedResource,
@@ -91,6 +91,7 @@ export function computeServerHash(definition: ServerEntry): string {
     url: resolveServerUrl(definition),
     headers: interpolateEnvRecord(definition.headers),
     auth: definition.auth,
+    protocolVersion: definition.protocolVersion,
     bearerToken: resolveBearerToken(definition),
     bearerTokenEnv: definition.bearerTokenEnv,
     exposeResources: definition.exposeResources,
@@ -201,10 +202,10 @@ export function reconstructToolMetadata(
       name,
       originalName: tool.name,
       description: tool.description ?? "",
-      inputSchema: tool.inputSchema,
-      uiResourceUri: tool.uiResourceUri,
-      uiVisibility: tool.uiVisibility,
-      uiStreamMode: tool.uiStreamMode,
+      ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
+      ...(tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {}),
+      ...(tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {}),
+      ...(tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}),
     });
   }
 
@@ -237,14 +238,19 @@ export function reconstructToolMetadata(
 export function serializeTools(tools: McpTool[]): CachedTool[] {
   return tools
     .filter(t => t?.name)
-    .map(t => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema,
-      uiResourceUri: tryGetToolUiResourceUri(t),
-      uiVisibility: extractUiToolVisibility(t._meta),
-      uiStreamMode: extractToolUiStreamMode(t._meta),
-    }));
+    .map(t => {
+      const uiResourceUri = tryGetToolUiResourceUri(t);
+      const uiVisibility = extractUiToolVisibility(t._meta);
+      const uiStreamMode = extractToolUiStreamMode(t._meta);
+      return {
+        name: t.name,
+        ...(t.description !== undefined ? { description: t.description } : {}),
+        ...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
+        ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
+        ...(uiVisibility !== undefined ? { uiVisibility } : {}),
+        ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
+      };
+    });
 }
 
 export function serializeResources(resources: McpResource[]): CachedResource[] {
@@ -253,7 +259,7 @@ export function serializeResources(resources: McpResource[]): CachedResource[] {
     .map(r => ({
       uri: r.uri,
       name: r.name,
-      description: r.description,
+      ...(r.description !== undefined ? { description: r.description } : {}),
     }));
 }
 
@@ -262,15 +268,17 @@ export function serializePrompts(prompts: McpPrompt[]): CachedPrompt[] {
     .filter(prompt => prompt?.name)
     .map(prompt => ({
       name: prompt.name,
-      title: prompt.title,
-      description: prompt.description,
-      arguments: Array.isArray(prompt.arguments)
-        ? prompt.arguments.filter(argument => argument?.name).map(argument => ({
-            name: argument.name,
-            description: argument.description,
-            required: argument.required,
-          }))
-        : undefined,
+      ...(prompt.title !== undefined ? { title: prompt.title } : {}),
+      ...(prompt.description !== undefined ? { description: prompt.description } : {}),
+      ...(Array.isArray(prompt.arguments)
+        ? {
+            arguments: prompt.arguments.filter(argument => argument?.name).map(argument => ({
+              name: argument.name,
+              ...(argument.description !== undefined ? { description: argument.description } : {}),
+              ...(argument.required !== undefined ? { required: argument.required } : {}),
+            })),
+          }
+        : {}),
     }));
 }
 
@@ -285,15 +293,15 @@ export function reconstructPromptMetadata(
     const args: McpPromptArgument[] = Array.isArray(prompt.arguments)
       ? prompt.arguments.filter(argument => argument?.name).map(argument => ({
           name: argument.name,
-          description: argument.description,
-          required: argument.required,
+          ...(argument.description !== undefined ? { description: argument.description } : {}),
+          ...(argument.required !== undefined ? { required: argument.required } : {}),
         }))
       : [];
     return {
       serverName,
       originalName: prompt.name,
       commandName: formatPromptCommandName(prompt.name, serverName, effectivePrefix),
-      title: prompt.title,
+      ...(prompt.title !== undefined ? { title: prompt.title } : {}),
       description: prompt.description ?? "",
       arguments: args,
     };

package/node_modules/pi-mcp-adapter/npx-resolver.ts

@@ -95,6 +95,7 @@ function parseNpxArgs(args: string[]): ParsedInvocation | null {
 
   for (let i = 0; i < before.length; i++) {
     const arg = before[i];
+    if (arg === undefined) return null;
     if (foundFirstPositional) {
       positionals.push(arg);
       continue;
@@ -149,6 +150,7 @@ function parseNpmExecArgs(args: string[]): ParsedInvocation | null {
   let packageSpec: string | undefined;
   for (let i = 0; i < before.length; i++) {
     const arg = before[i];
+    if (arg === undefined) return null;
     if (arg === "-y" || arg === "--yes") continue;
     if (arg === "--package") {
       const value = before[i + 1];
@@ -239,7 +241,7 @@ function resolveFromNpmCache(packageSpec: string, binName?: string): NpxCacheEnt
   return {
     resolvedBin,
     resolvedAt: Date.now(),
-    packageVersion: pkg?.version,
+    ...(pkg?.version !== undefined ? { packageVersion: pkg.version } : {}),
     isJs,
   };
 }
@@ -329,9 +331,9 @@ function parsePackageSpec(spec: string): ParsedPackageSpec | null {
   const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
   return {
     packageName,
-    exactVersion: normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion)
-      ? normalizedVersion
-      : undefined,
+    ...(normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion)
+      ? { exactVersion: normalizedVersion }
+      : {}),
   };
 }
 

package/node_modules/pi-mcp-adapter/oauth-handler.ts

@@ -1,5 +1,5 @@
 // oauth-handler.ts - OAuth token compatibility helpers for MCP servers
-import type { OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { OAuthTokens } from "@modelcontextprotocol/client";
 import { getAuthEntry } from "./mcp-auth.ts";
 
 /**

package/node_modules/pi-mcp-adapter/onboarding-state.ts

@@ -30,7 +30,9 @@ export function loadOnboardingState(): McpOnboardingState {
       version: 1,
       sharedConfigHintShown: raw.sharedConfigHintShown === true,
       setupCompleted: raw.setupCompleted === true,
-      lastDiscoveryFingerprint: typeof raw.lastDiscoveryFingerprint === "string" ? raw.lastDiscoveryFingerprint : undefined,
+      ...(typeof raw.lastDiscoveryFingerprint === "string"
+        ? { lastDiscoveryFingerprint: raw.lastDiscoveryFingerprint }
+        : {}),
     };
   } catch {
     return { ...DEFAULT_STATE };
@@ -52,17 +54,23 @@ export function updateOnboardingState(updater: (state: McpOnboardingState) => Mc
 }
 
 export function markSharedConfigHintShown(fingerprint?: string): McpOnboardingState {
-  return updateOnboardingState((state) => ({
-    ...state,
-    sharedConfigHintShown: true,
-    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
-  }));
+  return updateOnboardingState((state) => {
+    const lastDiscoveryFingerprint = fingerprint ?? state.lastDiscoveryFingerprint;
+    return {
+      ...state,
+      sharedConfigHintShown: true,
+      ...(lastDiscoveryFingerprint !== undefined ? { lastDiscoveryFingerprint } : {}),
+    };
+  });
 }
 
 export function markSetupCompleted(fingerprint?: string): McpOnboardingState {
-  return updateOnboardingState((state) => ({
-    ...state,
-    setupCompleted: true,
-    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
-  }));
+  return updateOnboardingState((state) => {
+    const lastDiscoveryFingerprint = fingerprint ?? state.lastDiscoveryFingerprint;
+    return {
+      ...state,
+      setupCompleted: true,
+      ...(lastDiscoveryFingerprint !== undefined ? { lastDiscoveryFingerprint } : {}),
+    };
+  });
 }