@fitchmultz/pi-mcp-adapter 8.0.1 → 8.0.2

package/dist/plain-result-reader.js

@@ -0,0 +1,201 @@
+import { appendFileSync, fstatSync, realpathSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+import { open } from "node:fs/promises";
+import { byteLength } from "./mcp-output-preview.js";
+const indexes = new Map();
+const readers = new Map();
+const MAX_INDEXES = 8;
+const MAX_POINTS = 1024;
+function sameRevision(a, b) {
+    return a.dev === b.dev && a.ino === b.ino && a.size === b.size
+        && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+}
+/** Raw full-content SHA-256. Returns "" on a short read so a truncated verify never matches. */
+async function digestOf(file, size) {
+    const hash = createHash("sha256");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    while (position < size) {
+        const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, size - position), position);
+        if (!bytesRead)
+            return "";
+        hash.update(buffer.subarray(0, bytesRead));
+        position += bytesRead;
+    }
+    return hash.digest("hex");
+}
+function checkpoint(index, point) {
+    if (point.bytes - index.points.at(-1).bytes < index.stride)
+        return;
+    index.points.push(point);
+    if (index.points.length > MAX_POINTS) {
+        index.points = index.points.filter((_, i) => i % 2 === 0);
+        index.stride *= 2;
+    }
+}
+function remember(ref, index) {
+    indexes.delete(ref);
+    indexes.set(ref, index);
+    if (indexes.size > MAX_INDEXES)
+        indexes.delete(indexes.keys().next().value);
+}
+function extend(index, after, text) {
+    // Clone before updating so a shared cached hasher never advances.
+    index.hasher = index.hasher.copy();
+    index.hasher.update(text, "utf8");
+    let position = Number(index.revision.size);
+    checkpoint(index, { bytes: position, characters: index.total });
+    // Index only the accepted delta, keeping checkpoints on complete UTF-8 code points.
+    for (let start = 0; start < text.length;) {
+        let end = Math.min(text.length, start + 16 * 1024);
+        if (end < text.length && text.codePointAt(end - 1) > 0xffff)
+            end++;
+        position += byteLength(text.slice(start, end));
+        checkpoint(index, { bytes: position, characters: index.total + end });
+        start = end;
+    }
+    index.total += text.length;
+    index.revision = after;
+    index.digest = index.hasher.copy().digest("hex");
+}
+/** Only the native, synchronous history writer can certify an append. External changes invalidate. */
+export function appendPlainOutput(ref, text) {
+    let key = ref, cached, before;
+    try {
+        key = indexes.size || readers.size ? realpathSync(ref) : ref;
+        cached = indexes.get(key);
+        indexes.delete(key);
+        if (cached || readers.has(key))
+            before = statSync(ref, { bigint: true });
+    }
+    catch { /* Cache bookkeeping must not change write acceptance. */ }
+    appendFileSync(ref, text, { flush: true });
+    if (!before)
+        return;
+    try {
+        const after = statSync(ref, { bigint: true });
+        if (after.dev !== before.dev || after.ino !== before.ino
+            || after.size !== before.size + BigInt(byteLength(text)))
+            return;
+        if (cached && sameRevision(cached.revision, before) && !text.includes("\ufffd")) {
+            const next = { ...cached, points: [...cached.points] };
+            extend(next, after, text);
+            remember(key, next);
+        }
+        for (const progress of readers.get(key) ?? []) {
+            if (!sameRevision(progress.revision, before))
+                continue;
+            extend(progress, after, text);
+            if (text.includes("\ufffd"))
+                progress.cacheable = false;
+        }
+    }
+    catch { /* The durable append already succeeded; leave its index invalidated. */ }
+}
+/** Sparse byte/UTF16 checkpoints, never retained file contents. Changed/uncacheable files scan afresh. */
+export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const file = await open(ref, "r");
+        let progress;
+        try {
+            // Pair snapshot registration/validation with the synchronous writer without yielding between them.
+            const revision = fstatSync(file.fd, { bigint: true });
+            const cached = indexes.get(ref);
+            const matched = cached !== undefined && sameRevision(cached.revision, revision);
+            const fresh = { revision, total: 0, points: [{ bytes: 0, characters: 0 }],
+                stride: 64 * 1024, digest: "", hasher: createHash("sha256") };
+            let index = matched ? cached : fresh;
+            // Append characters stay relative until the cold scan knows the opened prefix's total.
+            progress = { revision, total: 0, points: [{ bytes: Number(revision.size), characters: 0 }],
+                stride: index.stride, cacheable: true, digest: "", hasher: index.hasher.copy() };
+            const active = readers.get(ref) ?? new Set();
+            active.add(progress);
+            readers.set(ref, active);
+            // Matching stat fields are not an immutability proof: verify the cached digest against current
+            // bytes. Registering the snapshot first keeps live appends paired during the verification read.
+            let valid = matched ? cached : undefined;
+            if (valid && valid.digest !== (await digestOf(file, Number(revision.size)))) {
+                indexes.delete(ref);
+                valid = undefined;
+                index = fresh;
+                progress.hasher = createHash("sha256");
+                progress.stride = fresh.stride;
+            }
+            let point = index.points[0];
+            if (valid) {
+                for (const candidate of index.points) {
+                    if (candidate.characters > offset)
+                        break;
+                    point = candidate;
+                }
+            }
+            let total = point.characters, position = point.bytes;
+            let bytes = 0, lines = 1, page = "", finished = false, cacheable = true;
+            // Bound each attempt to its opened file snapshot, including while native history appends.
+            if (revision.size > 0n) {
+                const decoder = new StringDecoder("utf8");
+                const buffer = Buffer.allocUnsafe(64 * 1024);
+                let readPosition = point.bytes;
+                while (readPosition < Number(revision.size)) {
+                    const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, Number(revision.size) - readPosition), readPosition);
+                    if (!bytesRead)
+                        break;
+                    readPosition += bytesRead;
+                    const chunk = decoder.write(buffer.subarray(0, bytesRead)) + (readPosition === Number(revision.size) ? decoder.end() : "");
+                    if (!valid) {
+                        progress.hasher.update(buffer.subarray(0, bytesRead));
+                        checkpoint(index, { bytes: position, characters: total });
+                        // Invalid/incomplete UTF8 can re-decode differently after append. Keep the full-scan fallback.
+                        if (chunk.includes("\ufffd"))
+                            cacheable = false;
+                        position += byteLength(chunk);
+                    }
+                    const start = Math.max(0, offset - total);
+                    if (!finished && start < chunk.length) {
+                        if (start > 0 && chunk.codePointAt(start - 1) > 0xffff)
+                            throw new Error("offset must not split a Unicode surrogate pair");
+                        for (const char of chunk.slice(start)) {
+                            const nextBytes = bytes + byteLength(char);
+                            const nextLines = lines + (char === "\n" ? 1 : 0);
+                            if (page && (nextBytes > maxBytes || nextLines > maxLines || page.length + char.length > limit)) {
+                                finished = true;
+                                break;
+                            }
+                            page += char;
+                            bytes = nextBytes;
+                            lines = nextLines;
+                        }
+                    }
+                    total += chunk.length;
+                    if (valid && finished)
+                        break;
+                }
+            }
+            // Only verified native appends may advance this snapshot. External edits still invalidate.
+            if (!sameRevision(progress.revision, statSync(ref, { bigint: true })))
+                continue;
+            if (!valid)
+                index.total = total;
+            // Serve the opened prefix; retain verified append checkpoints for the next read.
+            if (cacheable && progress.cacheable) {
+                const next = { ...index, revision: progress.revision, total: index.total + progress.total,
+                    points: [...index.points], digest: progress.hasher.copy().digest("hex"), hasher: progress.hasher };
+                for (const point of progress.points)
+                    checkpoint(next, { bytes: point.bytes, characters: index.total + point.characters });
+                remember(ref, next);
+            }
+            return { page, total: index.total };
+        }
+        finally {
+            if (progress) {
+                const active = readers.get(ref);
+                active.delete(progress);
+                if (!active.size)
+                    readers.delete(ref);
+            }
+            await file.close();
+        }
+    }
+    throw new Error("MCP output artifact changed while reading; retry the page");
+}

package/dist/prompts.js

@@ -1,5 +1,4 @@
 import { isServerDisabled } from "./types.js";
-import { lazyConnect } from "./init.js";
 import { isServerCacheValid, loadMetadataCache, reconstructPromptMetadata } from "./metadata-cache.js";
 import { logger } from "./logger.js";
 import { truncateAtWord } from "./utils.js";
@@ -233,6 +232,7 @@ export function createPromptCommand(pi, getState, metadata) {
                 }
                 return;
             }
+            const { lazyConnect } = await import("./init.js");
             const connected = await lazyConnect(state, metadata.serverName, ctx.signal);
             if (!connected) {
                 if (ctx.hasUI) {

package/dist/proxy-modes.d.ts

@@ -2,7 +2,7 @@ import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent"
 import type { McpExtensionState } from "./state.ts";
 import type { ServerConnection } from "./server-manager.ts";
 import type { ToolMetadata, McpOperationContext, McpToolCallIdentity } from "./types.ts";
-import { type SessionRecoveryDeps } from "./session-recovery.ts";
+import type { SessionRecoveryDeps } from "./session-recovery.ts";
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
 export declare function executeUiMessages(state: McpExtensionState): Promise<ProxyToolResult>;
 export declare function executeStatus(state: McpExtensionState): ProxyToolResult;

package/dist/proxy-modes.js

@@ -1,4 +1,4 @@
-import { DEFAULT_REQUEST_TIMEOUT_MSEC, UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import { isDeepStrictEqual } from "node:util";
 import { getServerPrefix, isServerDisabled, isNonInteractiveOAuth, parseUiPromptHandoff, resolveToolPrefix } from "./types.js";
 import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure } from "./init.js";
 import { abortable, throwIfAborted } from "./abort.js";
@@ -7,10 +7,8 @@ import { buildToolMetadata, catalogCoverage, findToolByName, formatSchema, toToo
 import { reconstructPromptMetadata } from "./metadata-cache.js";
 import { renderMcpResultContent } from "./tool-registrar.js";
 import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGuardOptions, formatMcpResultReference, saveMcpOutputStream } from "./mcp-output-guard.js";
-import { maybeStartUiSession, summarizeUiSessionResult } from "./ui-session.js";
 import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord } from "./utils.js";
-import { authenticate, completeAuthFromInput, startAuth, supportsOAuth } from "./mcp-auth-flow.js";
-import { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { supportsOAuth } from "./mcp-oauth-runtime.js";
 import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { materializeUiMessages, uiMessages } from "./ui-message-history.js";
@@ -96,6 +94,7 @@ async function attemptAutoAuth(state, serverName, signal) {
         };
     }
     try {
+        const { authenticate } = await import("./mcp-auth-flow.js");
         if (state.authStorageOptions) {
             await authenticate(serverName, serverUrl, definition, signal
                 ? { authStorageOptions: state.authStorageOptions, signal, runtime: state.oauthRuntime }
@@ -340,6 +339,7 @@ export function executeStatus(state) {
     };
 }
 export async function executeAuthStart(state, serverName, signal) {
+    const { startAuth } = await import("./mcp-auth-flow.js");
     const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
     throwIfAborted(ownedSignal);
     const definition = state.config.mcpServers[serverName];
@@ -386,6 +386,7 @@ export async function executeAuthStart(state, serverName, signal) {
     }
 }
 export async function executeAuthComplete(state, serverName, input, signal) {
+    const { completeAuthFromInput } = await import("./mcp-auth-flow.js");
     const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
     throwIfAborted(ownedSignal);
     const definition = state.config.mcpServers[serverName];
@@ -715,6 +716,9 @@ export async function executeConnect(state, serverName, signal, limit, offset) {
  * Raw scripts skip content rendering but retain protocol results and artifacts.
  */
 export async function runToolCall(state, serverName, target, args, options) {
+    const { DEFAULT_REQUEST_TIMEOUT_MSEC, UrlElicitationRequiredError } = await import("@modelcontextprotocol/client");
+    const { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery } = await import("./session-recovery.js");
+    const { maybeStartUiSession, summarizeUiSessionResult } = await import("./ui-session.js");
     const { detailsBase, signal, recoverAuthConnection, authRequiredMessage, autoAuthAttempted } = options;
     const configuredOptions = state.manager.getRequestOptions?.(serverName, options.ownedSignal);
     const callerSignal = combineAbortSignals(configuredOptions?.signal, options.ownedSignal);
@@ -746,6 +750,8 @@ export async function runToolCall(state, serverName, target, args, options) {
     try {
         state.manager.touch(serverName);
         state.manager.incrementInFlight(serverName);
+        // Loading the connection-only modules can yield to cancellation or shutdown.
+        throwIfAborted(callerSignal);
         uiSession = !target.resourceUri && target.uiResourceUri
             ? await abortable(maybeStartUiSession(state, {
                 serverName,
@@ -892,6 +898,7 @@ export async function runToolCall(state, serverName, target, args, options) {
 }
 /** Connect/auth once for calls and resource discovery. Recovery stays bounded by withSessionRecovery. */
 export async function prepareMcpConnection(state, serverName, signal) {
+    const { SessionRecoveryAuthRequiredError } = await import("./session-recovery.js");
     const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
     throwIfAborted(ownedSignal);
     let autoAuthAttempted = false;
@@ -951,7 +958,9 @@ export async function prepareMcpConnection(state, serverName, signal) {
         // Use the live descriptor for visibility, filtering, approval, schema and UI hints.
         if (connection.tools) {
             const { metadata } = buildToolMetadata(connection.tools, connection.resources ?? [], definition, serverName, state.config.settings?.toolPrefix ?? "server");
-            state.toolMetadata.set(serverName, metadata);
+            // Search indexes by metadata-array identity, so retain it for unchanged projections.
+            if (!isDeepStrictEqual(state.toolMetadata.get(serverName), metadata))
+                state.toolMetadata.set(serverName, metadata);
         }
         return { connection, recoverAuthConnection, autoAuthAttempted: () => autoAuthAttempted };
     }

package/dist/public-types.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.ts";
+export { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_RESULT_PATCH_METHOD, SERVER_STREAM_RESULT_PATCH_METHOD, UI_STREAM_STRUCTURED_CONTENT_KEY, uiStreamModeSchema, visualizationStreamPhaseSchema, visualizationStreamFrameTypeSchema, visualizationStreamStatusSchema, uiStreamHostContextSchema, visualizationStreamEnvelopeSchema, uiStreamCallToolResultSchema, uiStreamResultPatchNotificationSchema, serverStreamResultPatchNotificationSchema, getUiStreamHostContext, getVisualizationStreamEnvelope, } from "./ui-stream-types.ts";

package/dist/public-types.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_RESULT_PATCH_METHOD, SERVER_STREAM_RESULT_PATCH_METHOD, UI_STREAM_STRUCTURED_CONTENT_KEY, uiStreamModeSchema, visualizationStreamPhaseSchema, visualizationStreamFrameTypeSchema, visualizationStreamStatusSchema, uiStreamHostContextSchema, visualizationStreamEnvelopeSchema, uiStreamCallToolResultSchema, uiStreamResultPatchNotificationSchema, serverStreamResultPatchNotificationSchema, getUiStreamHostContext, getVisualizationStreamEnvelope, } from "./ui-stream-types.js";

package/dist/resource-tools.d.ts

@@ -13,4 +13,3 @@ export declare function executeResourceList(state: McpExtensionState, server: st
     };
 }>;
 export declare function executeResourceRead(state: McpExtensionState, server: string, uri: string, signal?: AbortSignal, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>, raw?: boolean): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>>>;
-export declare function resourceNameToToolName(name: string): string;

package/dist/resource-tools.js

@@ -24,16 +24,3 @@ export async function executeResourceList(state, server, limit = 12, offset = 0,
 export async function executeResourceRead(state, server, uri, signal, identity = {}, beforeDispatch, raw = false) {
     return executeCall(state, uri, {}, server, undefined, signal, identity, beforeDispatch, { resourceUri: uri, raw });
 }
-export function resourceNameToToolName(name) {
-    let result = name
-        .replace(/[^a-zA-Z0-9]/g, "_")
-        .replace(/_+/g, "_")
-        .replace(/^_+/, "") // Remove leading underscores
-        .replace(/_+$/, "") // Remove trailing underscores
-        .toLowerCase();
-    // Ensure we have a valid name
-    if (!result || /^\d/.test(result)) {
-        result = "resource" + (result ? "_" + result : "");
-    }
-    return result;
-}

package/dist/server-manager.d.ts

@@ -1,9 +1,9 @@
-import { Client, type RequestOptions, type GetPromptResult, type ReadResourceResult, type UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import type { Client, RequestOptions, GetPromptResult, ReadResourceResult, UrlElicitationRequiredError } from "@modelcontextprotocol/client";
 import { type McpTool, type McpResource, type McpPrompt, type ServerDefinition, type ServerStreamResultPatchNotification, type Transport, type McpTraceSettings } from "./types.ts";
-import { type McpOAuthRuntime } from "./mcp-auth-flow.ts";
+import { type McpOAuthRuntime } from "./mcp-oauth-runtime.ts";
 import { type AuthStorageOptions } from "./mcp-auth.ts";
-import { type ServerSamplingConfig } from "./sampling-handler.ts";
-import { type ServerElicitationConfig } from "./elicitation-handler.ts";
+import type { ServerSamplingConfig } from "./sampling-handler.ts";
+import type { ServerElicitationConfig } from "./elicitation-handler.ts";
 export interface ServerConnection {
     client: Client;
     transport: Transport;

package/dist/server-manager.js

@@ -1,16 +1,9 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { Client, StreamableHTTPClientTransport, SSEClientTransport, SdkHttpError, auth, extractWWWAuthenticateParams, UnauthorizedError, } from "@modelcontextprotocol/client";
-import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
-import { UnixSocketClientTransport } from "./unix-socket-transport.js";
-import { trackToolTransport, trackToolTransportFailure } from "./session-recovery.js";
-import { isServerDisabled, isNonInteractiveOAuth, validateServerProtocolConfig, serverStreamResultPatchNotificationSchema, } from "./types.js";
+import { clientOperations, drainClientCallbacks, drainClientOperations } from "./client-operations.js";
+import { isServerDisabled, isNonInteractiveOAuth, validateServerProtocolConfig, } from "./types.js";
 import { resolveNpxBinary } from "./npx-resolver.js";
 import { logger } from "./logger.js";
-import { McpOAuthProvider } from "./mcp-oauth-provider.js";
-import { extractOAuthConfig, supportsOAuth, isOAuthChallenge, recordOAuthChallenge, getOAuthRequest, bindOAuthRequestIssuer } from "./mcp-auth-flow.js";
+import { supportsOAuth } from "./mcp-oauth-runtime.js";
 import { getAuthBaseDir } from "./mcp-auth.js";
-import { registerSamplingHandler } from "./sampling-handler.js";
-import { handleUrlElicitation, registerElicitationHandler, } from "./elicitation-handler.js";
 import { ADAPTER_VERSION, normalizeRequestTimeoutMs, resolveBearerToken, resolveCommandSecret, resolveCommandSecretsRecord, resolveConfigPath, resolveServerUrl, } from "./utils.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals } from "./runtime-owner.js";
@@ -18,108 +11,6 @@ import { createMcpTraceWriter, isMcpTraceEnabled, McpTraceWriter, traceTransport
 const MAX_CAPTURED_STDERR_BYTES = 8 * 1024;
 const MAX_CAPTURED_STDERR_LINES = 3;
 const abortCleanupPromises = new WeakMap();
-const clientOperations = new WeakMap();
-async function drainClientCallbacks(client) {
-    for (;;) {
-        const pending = [...(clientOperations.get(client) ?? [])]
-            .filter(([, kind]) => kind === "sampling callback" || kind === "elicitation callback")
-            .map(([operation]) => operation);
-        if (!pending.length)
-            return;
-        await Promise.allSettled(pending);
-    }
-}
-async function drainClientOperations(client) {
-    for (;;) {
-        const pending = [...(clientOperations.get(client)?.keys() ?? [])];
-        if (!pending.length)
-            return;
-        await Promise.allSettled(pending);
-    }
-}
-// Track complete SDK operations, including pagination and pre-request cache awaits.
-class ManagedClient extends Client {
-    serverName = "";
-    oauthProvider;
-    own(operation, kind) {
-        let pending = clientOperations.get(this);
-        if (!pending)
-            clientOperations.set(this, pending = new Map());
-        pending.set(operation, kind);
-        const settled = () => { pending.delete(operation); };
-        void operation.then(settled, settled);
-        return operation;
-    }
-    ownNative(run) {
-        return this.own(run(), "request/refresh");
-    }
-    ownSend(run) {
-        // SDK-generated callback replies also perform HTTP/auth work, without calling callTool().
-        return this.own(Promise.resolve().then(run), "request/refresh");
-    }
-    ownCallback(kind, run) {
-        // Insert before dispatch. Cancellation/close of the SDK response does not settle this promise.
-        return this.own(Promise.resolve().then(run), kind);
-    }
-    async track(start, signal) {
-        const controller = this.oauthProvider ? new AbortController() : undefined;
-        let removeAbortListener = () => { };
-        const operation = this.oauthProvider
-            ? this.oauthProvider.runWithSignal(controller.signal, () => {
-                // Native legacy cancellation notifications must retain their operation's auth context.
-                const abort = AsyncLocalStorage.bind(() => controller.abort(signal?.reason));
-                if (signal?.aborted)
-                    abort();
-                else
-                    signal?.addEventListener("abort", abort, { once: true });
-                removeAbortListener = () => signal?.removeEventListener("abort", abort);
-                return start(controller.signal);
-            })
-            : start(signal);
-        void operation.then(removeAbortListener, () => { controller?.abort(); removeAbortListener(); });
-        return this.own(operation, "request/refresh");
-    }
-    callTool(...args) {
-        return this.track(signal => super.callTool(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    readResource(...args) {
-        return this.track(signal => super.readResource(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    getPrompt(...args) {
-        return this.track(signal => super.getPrompt(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    listTools(...args) {
-        return this.track(signal => super.listTools(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    listResources(...args) {
-        return this.track(signal => super.listResources(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    listPrompts(...args) {
-        return this.track(signal => super.listPrompts(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    complete(...args) {
-        return this.track(signal => super.complete(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    setLoggingLevel(...args) {
-        return this.track(signal => super.setLoggingLevel(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-    listen(...args) {
-        return this.track(async (signal) => {
-            const subscription = await super.listen(args[0], { ...args[1], ...(signal ? { signal } : {}) });
-            this.own(subscription.closed, "subscription");
-            return subscription;
-        }, args[1]?.signal);
-    }
-    subscribeResource(...args) {
-        return this.track(async (signal) => {
-            throwIfAborted(signal);
-            return super.subscribeResource(args[0], { ...args[1], ...(signal ? { signal } : {}) });
-        }, args[1]?.signal);
-    }
-    unsubscribeResource(...args) {
-        return this.track(signal => super.unsubscribeResource(args[0], { ...args[1], ...(signal ? { signal } : {}) }), args[1]?.signal);
-    }
-}
 function boundedStderrChunk(chunk) {
     if (Buffer.isBuffer(chunk)) {
         const start = Math.max(0, chunk.byteLength - MAX_CAPTURED_STDERR_BYTES);
@@ -171,12 +62,12 @@ export class McpServerManager {
     traceWriter;
     stopped = false;
     releaseClientWhenSettled(client) {
-        if (client instanceof ManagedClient)
+        if (this.ownedClients.has(client))
             void drainClientOperations(client).then(() => this.ownedClients.delete(client));
     }
     /** Own native send/auth tails even after a public request has been cancelled. */
     ownTransportSends(transport, client) {
-        if (typeof transport.send === "function" && client instanceof ManagedClient) {
+        if (typeof transport.send === "function") {
             const send = transport.send.bind(transport);
             transport.send = (...args) => client.ownSend(() => send(...args));
         }
@@ -369,7 +260,10 @@ export class McpServerManager {
     async createConnection(name, definition, signal, requestSignal) {
         throwIfAborted(signal);
         validateServerProtocolConfig(definition);
-        let client = this.createClient(name, definition);
+        const runtime = await import("./connection-runtime.js");
+        const { StdioClientTransport, SdkHttpError, UnixSocketClientTransport, trackToolTransport, getOAuthRequest, isOAuthChallenge } = runtime;
+        throwIfAborted(signal);
+        let client = this.createClient(name, definition, runtime);
         const tracingEnabled = isMcpTraceEnabled(definition, this.traceSettings);
         const traceWriter = tracingEnabled
             ? (this.traceWriter ??= createMcpTraceWriter(this.defaultCwd, this.traceSettings ?? {}))
@@ -420,7 +314,7 @@ export class McpServerManager {
         }
         else if (definition.url) {
             // HTTP transport with fallback
-            ({ transport, oauthProvider } = this.createHttpTransport(definition, name, client, false, implicitOAuth, onAuthChallenge));
+            ({ transport, oauthProvider } = this.createHttpTransport(runtime, definition, name, client, false, implicitOAuth, onAuthChallenge));
         }
         else {
             transport = new UnixSocketClientTransport(resolveConfigPath(definition.socket));
@@ -449,13 +343,13 @@ export class McpServerManager {
                         legacySse = true;
                         await client.close();
                         this.releaseClientWhenSettled(client);
-                        client = this.createClient(name, { ...definition, protocolVersion: "legacy" });
-                        ({ transport, oauthProvider } = this.createHttpTransport(definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
+                        client = this.createClient(name, { ...definition, protocolVersion: "legacy" }, runtime);
+                        ({ transport, oauthProvider } = this.createHttpTransport(runtime, definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
                         if (traceObserver)
                             transport = wrapTransportWithMcpTrace(transport, name, traceTransportKind(definition, transport), traceObserver);
                         continue;
                     }
-                    this.attachAdapterNotificationHandlers(name, client);
+                    this.attachAdapterNotificationHandlers(name, client, runtime.serverStreamResultPatchNotificationSchema);
                     const instructions = client.getInstructions?.();
                     const connection = {
                         client,
@@ -501,8 +395,8 @@ export class McpServerManager {
                     implicitOAuth = true;
                     await client.close();
                     this.releaseClientWhenSettled(client);
-                    client = this.createClient(name, legacySse ? { ...definition, protocolVersion: "legacy" } : definition);
-                    ({ transport, oauthProvider } = this.createHttpTransport(definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
+                    client = this.createClient(name, legacySse ? { ...definition, protocolVersion: "legacy" } : definition, runtime);
+                    ({ transport, oauthProvider } = this.createHttpTransport(runtime, definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
                     if (traceObserver)
                         transport = wrapTransportWithMcpTrace(transport, name, traceTransportKind(definition, transport), traceObserver);
                 }
@@ -600,7 +494,8 @@ export class McpServerManager {
                 : {}),
         };
     }
-    createClient(serverName, definition) {
+    createClient(serverName, definition, runtime) {
+        const { ManagedClient, registerSamplingHandler, registerElicitationHandler } = runtime;
         const capabilities = this.buildClientCapabilities(definition);
         let client;
         client = new ManagedClient({ name: `pi-mcp-${serverName}`, version: ADAPTER_VERSION }, {
@@ -693,6 +588,10 @@ export class McpServerManager {
         this.metadataListChangedListener?.(serverName, "resources-list-changed");
     }
     async handleUrlElicitationRequired(serverName, error) {
+        if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl)
+            return "cancel";
+        const { handleUrlElicitation } = await import("./elicitation-handler.js");
+        // The import yields; recheck cancellation and URL support before prompting.
         if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl)
             return "cancel";
         for (const params of error.elicitations) {
@@ -716,7 +615,8 @@ export class McpServerManager {
         }
         accepted.add(elicitationId);
     }
-    createHttpTransport(definition, serverName, client, legacySse = false, implicitOAuth = false, onAuthChallenge) {
+    createHttpTransport(connectionRuntime, definition, serverName, client, legacySse = false, implicitOAuth = false, onAuthChallenge) {
+        const { StreamableHTTPClientTransport, SSEClientTransport, auth, extractWWWAuthenticateParams, UnauthorizedError, McpOAuthProvider, extractOAuthConfig, isOAuthChallenge, recordOAuthChallenge, getOAuthRequest, bindOAuthRequestIssuer, trackToolTransport, trackToolTransportFailure, } = connectionRuntime;
         const serverUrl = resolveServerUrl(definition);
         const url = new URL(serverUrl);
         const storageBase = getAuthBaseDir(this.authStorageOptions);
@@ -901,8 +801,8 @@ export class McpServerManager {
             return [];
         }
     }
-    attachAdapterNotificationHandlers(serverName, client) {
-        client.setNotificationHandler(serverStreamResultPatchNotificationSchema.shape.method.value, { params: serverStreamResultPatchNotificationSchema.shape.params }, params => {
+    attachAdapterNotificationHandlers(serverName, client, schema) {
+        client.setNotificationHandler(schema.shape.method.value, { params: schema.shape.params }, params => {
             this.uiStreamListeners.get(params.streamToken)?.(serverName, params);
         });
     }

package/dist/tool-loader.js

@@ -13,6 +13,7 @@ const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep",
 export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     pi.registerEntryRenderer(ENTRY, () => undefined);
     const registered = new Map();
+    const fingerprints = new WeakMap();
     let available = new Set();
     let selected = new Map();
     let inactive = new Map();
@@ -118,11 +119,12 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             const metadata = getState()?.toolMetadata.get(server) ?? (entry && isServerCacheValid(entry, definition)
                 ? reconstructToolMetadata(server, entry, config.settings?.toolPrefix ?? "server", definition) : []);
             const selection = directToolSelection(config, server, env ?? undefined);
-            for (const { name: prefixedName, ...tool } of metadata) {
+            for (const source of metadata) {
+                const { name: prefixedName, ...tool } = source;
                 if (tool.resourceUri)
                     continue;
                 const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
-                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, name: prefixedName, pinned });
+                specs.push({ spec: { ...tool, prefixedName, serverName: server }, source, selection: { server, tool: tool.originalName }, name: prefixedName, pinned });
             }
         }
         const counts = new Map();
@@ -130,13 +132,17 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             counts.set(name, (counts.get(name) ?? 0) + 1);
         available = new Set();
         const enabled = [];
-        for (const { spec, selection, name, pinned } of specs) {
+        for (const { spec, source, selection, name, pinned } of specs) {
             const id = key(selection);
             if (reserved.has(name) || counts.get(name) > 1 || (existing.has(name) && !previousNames.has(name)))
                 continue;
             available.add(id);
             const instructions = getState()?.serverInstructions.get(spec.serverName) ?? cache?.servers[spec.serverName]?.instructions;
-            const fingerprint = JSON.stringify({ spec, name, instructions });
+            const previous = Object.isFrozen(source) ? fingerprints.get(source) : undefined;
+            const fingerprint = previous?.server === spec.serverName && previous.instructions === instructions
+                ? previous.value : JSON.stringify({ spec, name, instructions });
+            if (Object.isFrozen(source))
+                fingerprints.set(source, { server: spec.serverName, instructions, value: fingerprint });
             if (registered.get(id)?.fingerprint !== fingerprint) {
                 pi.registerTool({
                     name,