@fitchmultz/pi-mcp-adapter 6.0.0 → 7.0.0

package/dist/config.js

@@ -1,7 +1,9 @@
 // config.ts - Config loading with import support
-import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync, renameSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync, renameSync, statSync, chmodSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { parse as parseToml } from "smol-toml";
 import stripJsonComments from "strip-json-comments";
 import { getAdapterPath } from "./agent-dir.js";
@@ -367,6 +369,14 @@ function mergeServerMaps(base, next) {
                 delete baseEntry.oauth;
             }
         }
+        // Stdio env belongs to the program that received it, not just the server name.
+        if (existing?.command && ((definition.command !== undefined && definition.command !== existing.command)
+            || (definition.args !== undefined && !isDeepStrictEqual(definition.args, existing.args ?? []))
+            || (definition.cwd !== undefined && definition.cwd !== existing.cwd))) {
+            if (baseEntry === existing)
+                baseEntry = { ...existing };
+            delete baseEntry.env;
+        }
         merged[name] = { ...baseEntry, ...definition };
     }
     return merged;
@@ -533,8 +543,10 @@ function mergeOpenCodeConfigs(base, next) {
                         delete safeBase.cwd;
                     }
                 }
+                if (Object.hasOwn(override, "cwd") && override.cwd !== safeBase.cwd)
+                    delete safeBase.environment;
                 const mergedEntry = { ...safeBase, ...override };
-                for (const field of ["environment", "headers", "oauth"]) {
+                for (const field of ["headers", "oauth"]) {
                     const baseField = safeBase[field];
                     const nextField = override[field];
                     if (baseField && typeof baseField === "object" && !Array.isArray(baseField)
@@ -714,24 +726,37 @@ function buildConfigWritePreview(filePath, nextRaw) {
 function readRawConfigObject(filePath) {
     if (!existsSync(filePath))
         return {};
+    let raw;
     try {
-        const raw = parseJsonConfig(readFileSync(filePath, "utf-8"));
-        return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+        raw = parseJsonConfig(readFileSync(filePath, "utf-8"));
     }
-    catch {
-        return {};
+    catch (error) {
+        throw new Error(`Cannot read MCP config at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`Invalid MCP config at ${filePath}: expected an object`);
     }
+    return raw;
 }
 function writeRawConfigObject(filePath, raw) {
     mkdirSync(dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.${process.pid}.tmp`;
-    writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
+    const existingMode = existsSync(filePath) ? statSync(filePath).mode & 0o7777 : undefined;
+    const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}\n`, {
+        encoding: "utf-8",
+        mode: existingMode ?? 0o666,
+        flag: "wx",
+    });
+    if (existingMode !== undefined)
+        chmodSync(tmpPath, existingMode);
     renameSync(tmpPath, filePath);
 }
-function getServersObject(raw) {
-    const existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
+function getServersObject(raw, filePath) {
+    const existing = raw.mcpServers !== undefined ? raw.mcpServers
+        : raw["mcp-servers"] !== undefined ? raw["mcp-servers"]
+            : {};
     if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-        return {};
+        throw new Error(`Invalid MCP config at ${filePath}: mcpServers must be an object`);
     }
     return existing;
 }
@@ -886,7 +911,7 @@ export function previewCompatibilityImports(importKinds, overridePath) {
     const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : [];
     const merged = [...new Set([...currentImports, ...importKinds])];
     const nextRaw = { ...raw, imports: merged };
-    setServersObject(nextRaw, getServersObject(nextRaw));
+    setServersObject(nextRaw, getServersObject(nextRaw, targetPath));
     return buildConfigWritePreview(targetPath, nextRaw);
 }
 export function ensureCompatibilityImports(importKinds, overridePath) {
@@ -899,7 +924,7 @@ export function ensureCompatibilityImports(importKinds, overridePath) {
         return { path: targetPath, added: [] };
     }
     raw.imports = merged;
-    const servers = getServersObject(raw);
+    const servers = getServersObject(raw, targetPath);
     setServersObject(raw, servers);
     writeRawConfigObject(targetPath, raw);
     return { path: targetPath, added };
@@ -923,14 +948,14 @@ export function writeStarterProjectConfig(cwd = process.cwd()) {
 export function previewSharedServerEntry(filePath, serverName, entry) {
     const raw = readRawConfigObject(filePath);
     const nextRaw = { ...raw };
-    const servers = getServersObject(nextRaw);
+    const servers = getServersObject(nextRaw, filePath);
     servers[serverName] = entry;
     setServersObject(nextRaw, servers);
     return buildConfigWritePreview(filePath, nextRaw);
 }
 export function writeSharedServerEntry(filePath, serverName, entry) {
     const raw = readRawConfigObject(filePath);
-    const servers = getServersObject(raw);
+    const servers = getServersObject(raw, filePath);
     servers[serverName] = entry;
     setServersObject(raw, servers);
     writeRawConfigObject(filePath, raw);
@@ -991,7 +1016,7 @@ export function writeDirectToolsConfig(changes, provenance) {
     }
     for (const [filePath, entries] of byPath) {
         const raw = readRawConfigObject(filePath);
-        const servers = getServersObject(raw);
+        const servers = getServersObject(raw, filePath);
         for (const { name, value } of entries) {
             // Keep inherited connection details in their source file.
             servers[name] = { ...servers[name], directTools: value };

package/dist/gateway-arguments.d.ts

@@ -15,7 +15,7 @@ export type GatewayArguments = {
     fields?: string[];
 };
 export declare const gatewayParameters: Type.TObject<{
-    action: Type.TUnsafe<"status" | "resources" | "connect" | "search" | "list" | "instructions" | "call" | "auth-start" | "auth-complete" | "describe" | "read-resource" | "read-result" | "ui-messages">;
+    action: Type.TUnsafe<"auth-complete" | "auth-start" | "call" | "connect" | "describe" | "instructions" | "list" | "read-resource" | "read-result" | "resources" | "search" | "status" | "ui-messages">;
     server: Type.TOptional<Type.TString>;
     tool: Type.TOptional<Type.TString>;
     args: Type.TOptional<Type.TObject<{}>>;

package/dist/index.js

@@ -552,7 +552,7 @@ function installMcpAdapter(pi, options) {
             : params.server ? (ready.toolMetadata.get(params.server) ?? []).filter(tool => !tool.resourceUri).map(tool => ({ server: params.server, tool })).sort((a, b) => a.tool.name.localeCompare(b.tool.name)) : [];
         const page = paginate(matches, params.offset ?? 0, params.limit ?? 5);
         const tools = toolLoader.activate(page.items);
-        const result = executeSearch(ready, params.query, params.server, tools.length < page.items.length, params.limit ?? 5, params.offset);
+        const result = executeSearch(ready, params.query, params.server, tools.length < page.items.length, params.limit ?? 5, params.offset, "mcp_search");
         const guarded = await guardMcpOutput([
             ...result.content,
             { type: "text", text: tools.length ? `Loaded for the next request: ${JSON.stringify(tools)}` : "No direct tools loaded. Use mcp action call or tools.call in mcp_script with the returned exact names." },

package/dist/lifecycle.d.ts

@@ -4,8 +4,6 @@ import { hasPendingAuth } from "./mcp-auth-flow.ts";
 export type ReconnectCallback = (serverName: string) => void;
 export type ReconnectFailureCallback = (serverName: string, error: unknown) => void;
 export declare class McpLifecycleManager {
-    private readonly manager;
-    private readonly hasPendingAuthForServer;
     private keepAliveServers;
     private allServers;
     private serverSettings;
@@ -23,6 +21,8 @@ export declare class McpLifecycleManager {
     pauseForCheckpoint(): () => void;
     private healthSignal;
     private removeHealthAbortListener;
+    private readonly manager;
+    private readonly hasPendingAuthForServer;
     constructor(manager: McpServerManager, hasPendingAuthForServer?: typeof hasPendingAuth);
     setReconnectCallback(callback: ReconnectCallback): void;
     setReconnectFailureCallback(callback: ReconnectFailureCallback): void;

package/dist/lifecycle.js

@@ -3,8 +3,6 @@ import { hasPendingAuth } from "./mcp-auth-flow.js";
 import { logger } from "./logger.js";
 import { formatTerminalError, sanitizeTerminalText } from "./utils.js";
 export class McpLifecycleManager {
-    manager;
-    hasPendingAuthForServer;
     keepAliveServers = new Map();
     allServers = new Map();
     serverSettings = new Map();
@@ -31,6 +29,8 @@ export class McpLifecycleManager {
     }
     healthSignal;
     removeHealthAbortListener;
+    manager;
+    hasPendingAuthForServer;
     constructor(manager, hasPendingAuthForServer = hasPendingAuth) {
         this.manager = manager;
         this.hasPendingAuthForServer = hasPendingAuthForServer;

package/dist/mcp-auth-flow.js

@@ -9,7 +9,7 @@ import { McpOAuthProvider, issuersMatch, loopbackRedirectsMatch, validateOAuthCl
 import { ensureCallbackServer, waitForCallback, cancelPendingCallback, stopCallbackServer, releaseCallbackServer, takeCallbackResult, } from "./mcp-callback-server.js";
 import { getAuthForUrl, clearAllCredentials, clearClientInfo, clearTokens, clearCodeVerifier, getOAuthState, clearOAuthState, getAuthBaseDir, } from "./mcp-auth.js";
 import { isServerDisabled, isNonInteractiveOAuth, validateServerProtocolConfig } from "./types.js";
-import { formatTerminalError, interpolateEnvRecord, interpolateEnvVars, normalizeRequestTimeoutMs } from "./utils.js";
+import { ADAPTER_VERSION, formatTerminalError, interpolateEnvRecord, interpolateEnvVars, normalizeRequestTimeoutMs } from "./utils.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
 function applyConfiguredScope(discovery, config) {
@@ -255,7 +255,7 @@ async function probeAuthDiscovery(serverUrl, definition, signal) {
     const timeout = normalizeRequestTimeoutMs(definition?.requestTimeoutMs) ?? 5000;
     const discoverySignal = combineAbortSignals(signal, AbortSignal.timeout(Math.ceil(timeout)));
     let discovery = {};
-    const client = new Client({ name: "pi-mcp-auth-discovery", version: "4.3.1" }, {
+    const client = new Client({ name: "pi-mcp-auth-discovery", version: ADAPTER_VERSION }, {
         versionNegotiation: { mode: definition?.protocolVersion ?? "auto" },
         ...(isNonInteractiveOAuth(definition?.oauth)
             ? { capabilities: { extensions: { [definition?.oauth && definition.oauth.crossAppAccess

package/dist/mcp-auth.d.ts

@@ -51,8 +51,8 @@ export interface AuthStorageOptions {
     baseDir?: string;
 }
 export declare class OAuthCredentialStoreError extends Error {
-    readonly operation: 'read' | 'write' | 'remove';
     readonly code = "OAUTH_CREDENTIAL_STORE_UNAVAILABLE";
+    readonly operation: 'read' | 'write' | 'remove';
     constructor(message: string, operation: 'read' | 'write' | 'remove', cause: unknown);
 }
 export type OAuthCredentialStatus = {

package/dist/mcp-auth.js

@@ -15,8 +15,8 @@ import { createRequire } from 'module';
 import { readFileSync, existsSync, rmSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { getAdapterPath, getAgentPath } from "./agent-dir.js";
-import { resolveConfiguredOAuthDir } from "./config.js";
+import { getAdapterPath, getAgentPath } from './agent-dir.js';
+import { resolveConfiguredOAuthDir } from './config.js';
 const require = createRequire(import.meta.url);
 const AUTH_SECRET_SERVICE = 'fitch-mcp-adapter.oauth';
 const LEGACY_AUTH_SECRET_SERVICE = 'pi-mcp-adapter.oauth';
@@ -30,8 +30,8 @@ const TEST_LINUX_KEYRING_RECOVERY_ENV = 'PI_MCP_ADAPTER_TEST_LINUX_KEYRING_RECOV
 const KEYRING_RECOVERY_TIMEOUT_MS = 10_000;
 const AUTH_CHUNK_MANIFEST_KEY = '__piMcpAdapterOAuthChunked';
 export class OAuthCredentialStoreError extends Error {
-    operation;
     code = 'OAUTH_CREDENTIAL_STORE_UNAVAILABLE';
+    operation;
     constructor(message, operation, cause) {
         super(isAndroidKeyringLoadFailure(cause)
             ? `${message}. Android/Termux: @napi-rs/keyring could not load a native binding. Persistent OAuth requires a supported platform with an OS credential store; no plaintext fallback is used.`

package/dist/mcp-code.d.ts

@@ -6,6 +6,12 @@ export declare const runMcpScript: typeof runMcpScriptOperation;
 declare function runMcpScriptOperation(state: McpExtensionState, code: string, timeoutMs?: number | null, getPiTools?: () => ToolInfo[], signal?: AbortSignal, toolCallId?: string, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>): Promise<{
     content: ContentBlock[];
     details: {
+        mode: string;
+        resultRefs?: string[];
+        error?: "aborted" | "call_capture_failed" | "script_error" | "timeout";
+        message?: string | undefined;
+        timeoutMs: number | null;
+        recovery?: {} | null;
         calls?: ({
             operation: "call";
             path: string;
@@ -41,12 +47,6 @@ declare function runMcpScriptOperation(state: McpExtensionState, code: string, t
             error: string;
             durationMs: number;
         })[];
-        recovery?: {} | null;
-        timeoutMs: number | null;
-        error?: "aborted" | "timeout" | "call_capture_failed" | "script_error";
-        message?: string | undefined;
-        resultRefs?: string[];
-        mode: string;
     };
 }>;
 export {};

package/dist/mcp-code.js

@@ -122,7 +122,7 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
             ? Math.max(0, Date.now() - startedAt)
             : operation.durationMs,
     }));
-    let callsSnapshot;
+    const pendingOperations = new Set();
     const resultRefs = new Set();
     const payloadNotices = new Set();
     const recordCall = async (path, dispatch) => {
@@ -149,11 +149,11 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
                     : textFromContent(result.content);
             calls[index] = {
                 operation: "call", path, ok: false, error: errorCode, durationMs: Date.now() - startedAt, startedAt,
-                ...(errorCode === "ambiguous_outcome" ? { recovery: details.recovery } : {}),
+                ...(details.recovery !== undefined ? { recovery: details.recovery } : {}),
             };
             if (errorCode === "call_capture_failed")
                 throw new McpScriptCaptureError(details.recovery, message);
-            if (errorCode === "ambiguous_outcome")
+            if (details.recovery !== undefined)
                 output.push({ type: "text", text: message });
             return {
                 ok: false,
@@ -301,7 +301,7 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
                     reject(new Error(message.message));
                     return;
                 }
-                void (async () => {
+                const operation = (async () => {
                     let envelope;
                     if (message.type === "call") {
                         envelope = await callTool(message.id, message.path, message.args, message.server);
@@ -332,7 +332,9 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
                     }
                     const response = { type: "result", id: message.id, envelope };
                     activeWorker.postMessage(response);
-                })().catch(reject);
+                })();
+                pendingOperations.add(operation);
+                void operation.catch(reject).finally(() => pendingOperations.delete(operation));
             });
             activeWorker.once("error", reject);
             activeWorker.once("exit", (code) => {
@@ -345,7 +347,6 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
                 return;
             const timeoutError = new McpScriptTimeoutError(resolvedTimeoutMs);
             timer = setTimeout(() => {
-                callsSnapshot = snapshotCalls();
                 timeoutController.abort(timeoutError);
                 void activeWorker.terminate();
                 reject(timeoutError);
@@ -354,7 +355,6 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
         const aborted = externalSignal
             ? new Promise((_resolve, reject) => {
                 const onAbort = () => {
-                    callsSnapshot = snapshotCalls();
                     void activeWorker.terminate();
                     reject(abortReasonError(externalSignal.reason));
                 };
@@ -387,14 +387,15 @@ async function runMcpScriptOperation(state, code, timeoutMs = DEFAULT_MCP_SCRIPT
     finally {
         clearTimeout(timer);
         removeAbortListener();
-        // "incomplete" means the call had not settled when the script finished
-        // (deadline, abort, or early return). Snapshot before aborting stragglers.
-        callsSnapshot ??= snapshotCalls();
+        worker?.removeAllListeners("message");
         // A script may finish without awaiting every call; abort leftovers so
         // parent-side dispatches do not outlive the script.
         timeoutController.abort(new Error("mcp_script finished"));
+        // Let cancelled dispatches report whether an outcome is known before taking the trace.
+        await Promise.allSettled(pendingOperations);
         await worker?.terminate();
     }
+    const callsSnapshot = snapshotCalls();
     // Snapshot before the asynchronous output guard; the terminated worker can no longer emit.
     const guarded = await guardMcpOutput([...(output.length > 0 ? output : [{ type: "text", text: "(no output)" }]), ...[...payloadNotices].map(text => ({ type: "text", text })), ...[...resultRefs].map(ref => ({ type: "text", text: formatMcpResultReference(ref) }))], resolveMcpOutputGuardOptions(state.config.settings, state.outputDirectory));
     return {

package/dist/mcp-oauth-provider.d.ts

@@ -49,11 +49,6 @@ export interface McpOAuthCallbacks {
  * Implements the OAuthClientProvider interface from the MCP SDK.
  */
 export declare class McpOAuthProvider implements OAuthClientProvider {
-    private serverName;
-    private serverUrl;
-    private config;
-    private callbacks;
-    private storageOptions;
     private readonly redirectUrlSnapshot;
     readonly clientMetadataUrl?: string;
     private readonly controller;
@@ -66,6 +61,11 @@ export declare class McpOAuthProvider implements OAuthClientProvider {
     private flowDiscoveryState;
     private flowIssuerMismatch;
     private flowState;
+    private serverName;
+    private serverUrl;
+    private config;
+    private callbacks;
+    private storageOptions;
     constructor(serverName: string, serverUrl: string, config: McpOAuthConfig, callbacks: McpOAuthCallbacks, storageOptions?: AuthStorageOptions, runtimeSignal?: AbortSignal, initialState?: string);
     private get isNonInteractive();
     private get discoveredIssuer();

package/dist/mcp-oauth-provider.js

@@ -152,11 +152,6 @@ function addAuthorizationParams(authorizationUrl, params) {
  * Implements the OAuthClientProvider interface from the MCP SDK.
  */
 export class McpOAuthProvider {
-    serverName;
-    serverUrl;
-    config;
-    callbacks;
-    storageOptions;
     redirectUrlSnapshot;
     clientMetadataUrl;
     controller = new AbortController();
@@ -169,6 +164,11 @@ export class McpOAuthProvider {
     flowDiscoveryState;
     flowIssuerMismatch = false;
     flowState;
+    serverName;
+    serverUrl;
+    config;
+    callbacks;
+    storageOptions;
     constructor(serverName, serverUrl, config, callbacks, storageOptions = {}, runtimeSignal, initialState) {
         this.serverName = serverName;
         this.serverUrl = serverUrl;

package/dist/mcp-output-guard.d.ts

@@ -94,11 +94,11 @@ export declare function readMcpResult(input: ReadMcpResultInput, options?: McpOu
         text: string;
     }[];
     details: {
-        path?: string;
         ref: string;
         offset: number;
         nextOffset: number | null;
         totalCharacters: number;
+        path?: string;
         error?: never;
         message?: never;
     };

package/dist/mcp-panel.d.ts

@@ -2,8 +2,6 @@ import { type PanelKeybindings } from "./panel-keys.ts";
 import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
 import { type MetadataCache } from "./metadata-cache.ts";
 declare class McpPanel {
-    private callbacks;
-    private done;
     private noticeLines;
     private prefix;
     private servers;
@@ -25,6 +23,8 @@ declare class McpPanel {
     private keys;
     private static readonly MAX_VISIBLE;
     private static readonly INACTIVITY_MS;
+    private callbacks;
+    private done;
     constructor(config: McpConfig, cache: MetadataCache | null, provenance: Map<string, ServerProvenance>, callbacks: McpPanelCallbacks, tui: {
         requestRender(): void;
     }, done: (result: McpPanelResult) => void, options?: {

package/dist/mcp-panel.js

@@ -93,8 +93,6 @@ function estimateTokens(tool) {
     return Math.ceil((tool.name.length + descLen + schemaLen) / 4) + 10;
 }
 class McpPanel {
-    callbacks;
-    done;
     noticeLines;
     prefix;
     servers = [];
@@ -116,6 +114,8 @@ class McpPanel {
     keys;
     static MAX_VISIBLE = 12;
     static INACTIVITY_MS = 60_000;
+    callbacks;
+    done;
     constructor(config, cache, provenance, callbacks, tui, done, options = {}) {
         this.callbacks = callbacks;
         this.done = done;

package/dist/mcp-setup-panel.d.ts

@@ -31,10 +31,6 @@ export interface SetupPanelOptions {
     keybindings?: PanelKeybindings;
 }
 export declare class McpSetupPanel {
-    private discovery;
-    private callbacks;
-    private options;
-    private done;
     private screen;
     private actionCursor;
     private importCursor;
@@ -47,6 +43,10 @@ export declare class McpSetupPanel {
     private keys;
     private inactivityTimeout;
     private static readonly INACTIVITY_MS;
+    private discovery;
+    private callbacks;
+    private options;
+    private done;
     constructor(discovery: McpDiscoverySummary, callbacks: SetupPanelCallbacks, options: SetupPanelOptions, tui: {
         requestRender(): void;
     }, done: () => void);
@@ -72,6 +72,7 @@ export declare class McpSetupPanel {
     private previewWidth;
     private getActionPreview;
     private formatPreview;
+    private previewOrError;
     private formatWritePreview;
     private padLine;
     invalidate(): void;

package/dist/mcp-setup-panel.js

@@ -38,10 +38,6 @@ function wrapText(text, width) {
     return lines.length > 0 ? lines : [""];
 }
 export class McpSetupPanel {
-    discovery;
-    callbacks;
-    options;
-    done;
     screen;
     actionCursor = 0;
     importCursor = 0;
@@ -54,6 +50,10 @@ export class McpSetupPanel {
     keys;
     inactivityTimeout = null;
     static INACTIVITY_MS = 60_000;
+    discovery;
+    callbacks;
+    options;
+    done;
     constructor(discovery, callbacks, options, tui, done) {
         this.discovery = discovery;
         this.callbacks = callbacks;
@@ -361,7 +361,7 @@ export class McpSetupPanel {
             lines.push(this.padLine(fg(this.t.muted, `… ${actions.length - end} more below`), innerW));
         }
         lines.push(this.padLine("", innerW));
-        const preview = this.getActionPreview(this.getSelectedAction(), this.previewWidth(innerW));
+        const preview = this.previewOrError(width => this.getActionPreview(this.getSelectedAction(), width), innerW);
         for (const line of preview) {
             lines.push(this.padLine(line, innerW));
         }
@@ -384,8 +384,7 @@ export class McpSetupPanel {
         }
         lines.push(this.padLine("", innerW));
         const selected = this.discovery.imports.filter((entry) => this.selectedImports.has(entry.kind)).map((entry) => entry.kind);
-        const preview = this.callbacks.previewImports(selected);
-        for (const line of this.formatWritePreview("Compatibility import write preview", preview, [], this.previewWidth(innerW))) {
+        for (const line of this.previewOrError(width => this.formatWritePreview("Compatibility import write preview", this.callbacks.previewImports(selected), [], width), innerW)) {
             lines.push(this.padLine(line, innerW));
         }
         return lines;
@@ -522,6 +521,15 @@ export class McpSetupPanel {
         }
         return preview;
     }
+    previewOrError(preview, innerW) {
+        const width = this.previewWidth(innerW);
+        try {
+            return preview(width);
+        }
+        catch (error) {
+            return this.formatPreview([`Cannot preview write: ${error instanceof Error ? error.message : String(error)}`], width);
+        }
+    }
     formatWritePreview(title, preview, intro = [], width = DESKTOP_PREVIEW_WIDTH) {
         const lines = [];
         for (const line of intro) {

package/dist/mcp-trace.d.ts

@@ -52,7 +52,6 @@ export declare function createMcpTraceEvent(direction: McpTraceDirection, server
     durationMs?: number;
 }): McpTraceEvent;
 export declare class McpTraceWriter {
-    private readonly options;
     private readonly maxBytes;
     private readonly maxEvents;
     private readonly append;
@@ -65,6 +64,7 @@ export declare class McpTraceWriter {
     private initializationFailed;
     private persistenceError;
     private readonly fileReady;
+    private readonly options;
     constructor(options: McpTraceWriterOptions);
     get filePath(): string;
     get isDisabled(): boolean;

package/dist/mcp-trace.js

@@ -73,7 +73,6 @@ export function createMcpTraceEvent(direction, server, transport, message, statu
     return event;
 }
 export class McpTraceWriter {
-    options;
     maxBytes;
     maxEvents;
     append;
@@ -86,6 +85,7 @@ export class McpTraceWriter {
     initializationFailed = false;
     persistenceError;
     fileReady;
+    options;
     constructor(options) {
         this.options = options;
         this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);

package/dist/npx-resolver.js

@@ -17,13 +17,15 @@ export async function resolveNpxBinary(command, args, signal) {
     if (!parsed)
         return null;
     const packageSpec = parsePackageSpec(parsed.packageSpec);
+    if (!packageSpec)
+        return null;
     const cacheKey = JSON.stringify([command, ...args]);
     const cache = loadCache();
     const cached = cache?.entries?.[cacheKey];
     if (cached
         && Date.now() - cached.resolvedAt < CACHE_TTL_MS
         && existsSync(cached.resolvedBin)
-        && (!packageSpec?.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
+        && (!packageSpec.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
         return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
     }
     const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
@@ -289,11 +291,13 @@ function parsePackageSpec(spec) {
     if (!packageName)
         return null;
     const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
+    // Let npm resolve ranges and tags rather than choosing an arbitrary cached version.
+    if (requestedVersion !== undefined && (!normalizedVersion || !EXACT_PACKAGE_VERSION_RE.test(normalizedVersion))) {
+        return null;
+    }
     return {
         packageName,
-        ...(normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion)
-            ? { exactVersion: normalizedVersion }
-            : {}),
+        ...(normalizedVersion ? { exactVersion: normalizedVersion } : {}),
     };
 }
 function defaultBinName(packageName) {

package/dist/proxy-modes.d.ts

@@ -9,7 +9,7 @@ export declare function executeStatus(state: McpExtensionState): ProxyToolResult
 export declare function executeAuthStart(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<ProxyToolResult>;
 export declare function executeAuthComplete(state: McpExtensionState, serverName: string, input?: string, signal?: AbortSignal): Promise<ProxyToolResult>;
 export declare function executeDescribe(state: McpExtensionState, toolName: string, serverFilter?: string): ProxyToolResult;
-export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number): ProxyToolResult;
+export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number, caller?: "mcp" | "mcp_search"): ProxyToolResult;
 export declare function executeList(state: McpExtensionState, server: string, limit?: number, offset?: number): ProxyToolResult;
 export declare function executeInstructions(state: McpExtensionState, server: string): ProxyToolResult;
 export declare function executeConnect(state: McpExtensionState, serverName: string, signal?: AbortSignal, limit?: number, offset?: number): Promise<ProxyToolResult>;
@@ -63,10 +63,10 @@ export declare function prepareMcpConnection(state: McpExtensionState, serverNam
     recoverAuthConnection?: never;
     autoAuthAttempted?: never;
 } | {
+    error?: never;
     connection: ServerConnection;
     recoverAuthConnection: (serverName: string, signal?: AbortSignal, challenge?: import("./session-recovery.ts").AuthChallengeContext) => Promise<ServerConnection | undefined>;
     autoAuthAttempted: () => boolean;
-    error?: never;
 }>;
 export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>, options?: ExecuteCallOptions): Promise<ProxyToolResult>;
 export {};