@fitchmultz/pi-mcp-adapter 7.1.0 → 7.1.1

package/dist/index.js

@@ -15,7 +15,7 @@ import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-ow
 import { publishMcpStatusShutdown } from "./mcp-status.js";
 import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, runMcpScript } from "./mcp-code.js";
 import { MAX_PAGE_SIZE, paginate, rankToolMatches } from "./search-ranking.js";
-import { createToolLoader, supportsNativeAsync } from "./tool-loader.js";
+import { createToolLoader } from "./tool-loader.js";
 import { gatewayParameters, prepareGatewayArguments } from "./gateway-arguments.js";
 import { executeResourceList, executeResourceRead } from "./resource-tools.js";
 import { guardMcpOutput, guardedMcpDetails, readMcpResult, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
@@ -95,7 +95,6 @@ function installMcpAdapter(pi, options) {
     const envDirectToolOverride = envRaw?.split(",").map(s => s.trim()).filter(Boolean);
     const toolLoader = createToolLoader(pi, () => state, () => initPromise, beforeExecute);
     let runtimeCwd;
-    let nativeAsyncSupported = false;
     let proxyToolRegistered = false;
     let proxyToolDescription = null;
     let directToolsFrozen = false;
@@ -112,7 +111,7 @@ function installMcpAdapter(pi, options) {
     function syncToolSurface(ctx) {
         const config = state?.config ?? currentConfig;
         const cache = loadMetadataCache(state?.metadataCacheEnabled ?? false);
-        toolLoader.sync(config, cache, envRaw === "__none__" ? null : envDirectToolOverride, nativeAsyncSupported, specs => syncGateways(config, cache, specs));
+        toolLoader.sync(config, cache, envRaw === "__none__" ? null : envDirectToolOverride, specs => syncGateways(config, cache, specs));
     }
     const registeredPromptCommands = new Set();
     function registerPromptCommands(specs) {
@@ -202,7 +201,6 @@ function installMcpAdapter(pi, options) {
     }
     async function startSession(ctx) {
         runtimeCwd = ctx.cwd;
-        nativeAsyncSupported = supportsNativeAsync(ctx);
         directToolsFrozen = false;
         const generation = ++lifecycleGeneration;
         const previousState = state;
@@ -249,7 +247,7 @@ function installMcpAdapter(pi, options) {
         toolLoader.restore(ctx);
         registerPromptCommands(resolveCachedPrompts(runtimeConfig, metadataCacheEnabled));
         const runtimeCache = loadMetadataCache(metadataCacheEnabled);
-        toolLoader.sync(runtimeConfig, runtimeCache, envRaw === "__none__" ? null : envDirectToolOverride, nativeAsyncSupported, specs => syncGateways(runtimeConfig, runtimeCache, specs));
+        toolLoader.sync(runtimeConfig, runtimeCache, envRaw === "__none__" ? null : envDirectToolOverride, specs => syncGateways(runtimeConfig, runtimeCache, specs));
         const initialization = startInitialization(ctx, owner, oauthRuntime, runtimeConfig, generation);
         if (envRaw !== undefined && envRaw !== "__none__") {
             const missingEnvDirectTools = getMissingConfiguredDirectToolServers(runtimeConfig, runtimeCache, envDirectToolOverride);
@@ -264,7 +262,6 @@ function installMcpAdapter(pi, options) {
         syncToolSurface(ctx);
     });
     pi.on("model_select", (_event, ctx) => {
-        nativeAsyncSupported = supportsNativeAsync(ctx);
         if (state)
             syncToolSurface(ctx);
     });
@@ -519,7 +516,7 @@ function installMcpAdapter(pi, options) {
         owner?.throwIfInactive();
         return state ?? { content: [{ type: "text", text: "MCP not initialized" }], details: { error: "not_initialized" } };
     }
-    const unavailableFeatures = (enable = [], tools) => enable.filter(feature => !tools.some(tool => tool.name === (feature === "gateway" ? "mcp" : "mcp_script") && !tool.namespace));
+    const unavailableFeatures = (enable = [], tools) => enable.filter(feature => !tools.some(tool => tool.name === (feature === "gateway" ? "mcp" : "mcp_script")));
     async function searchAndLoad(params, signal, ctx) {
         throwIfAborted(signal);
         if (params.query === undefined && !params.enable?.length)
@@ -544,7 +541,7 @@ function installMcpAdapter(pi, options) {
         const page = paginate(matches, params.offset ?? 0, params.limit ?? 5);
         const tools = toolLoader.activate(page.items, params.enable);
         const unavailable = unavailableFeatures(params.enable, tools);
-        const typedCount = tools.filter(tool => tool.namespace || (tool.name !== "mcp" && tool.name !== "mcp_script")).length;
+        const typedCount = tools.filter(tool => tool.name !== "mcp" && tool.name !== "mcp_script").length;
         const result = executeSearch(ready, params.query, params.server, typedCount < page.items.length, params.limit ?? 5, params.offset, "mcp_search");
         const guarded = await guardMcpOutput([
             ...result.content,
@@ -574,10 +571,7 @@ function installMcpAdapter(pi, options) {
             return searchAndLoad(params, signal, ctx);
         },
     };
-    if (toolLoader.native)
-        pi.registerToolSearch(searchDefinition);
-    else
-        pi.registerTool(searchDefinition);
+    pi.registerTool(searchDefinition);
     let scriptToolRegistered = false;
     function registerScriptTool() {
         if (scriptToolRegistered)

package/dist/server-manager.js

@@ -691,7 +691,8 @@ export class McpServerManager {
         let client;
         client = new ManagedClient({ name: `pi-mcp-${serverName}`, version: ADAPTER_VERSION }, {
             versionNegotiation: { mode: definition.protocolVersion ?? (definition.url ? "auto" : "legacy") },
-            listMaxPages: 0,
+            // ponytail: reject catalogs over 1024 pages; raise this native cap if a real catalog needs more.
+            listMaxPages: 1024,
             ...(Object.keys(capabilities).length > 0 ? { capabilities } : {}),
             listChanged: {
                 tools: {

package/dist/tool-loader.d.ts

@@ -1,37 +1,22 @@
-import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { type TSchema } from "typebox";
 import { type MetadataCache } from "./metadata-cache.ts";
 import type { McpExtensionState } from "./state.ts";
 import { type DirectToolSpec, type McpAdapterOptions, type McpConfig, type ToolMetadata } from "./types.ts";
-type Reference = {
-    name: string;
-    namespace?: string;
-};
 export type Feature = "gateway" | "script";
 export type FeaturePolicy = Partial<Record<Feature, {
     eager?: boolean;
 }>>;
-type SearchDefinition<TParams extends TSchema, TDetails> = Omit<ToolDefinition<TParams, TDetails>, "execute"> & {
-    execute: (...args: Parameters<ToolDefinition<TParams, TDetails>["execute"]>) => Promise<AgentToolResult<TDetails> & {
-        tools: Reference[];
-    }>;
-};
-export type SearchAPI = ExtensionAPI & {
-    registerToolSearch?: <TParams extends TSchema, TDetails>(definition: SearchDefinition<TParams, TDetails>) => void;
-    getActiveToolReferences?: () => Reference[];
-    setActiveToolReferences?: (tools: Reference[]) => void;
-};
-export declare function supportsNativeAsync(ctx: ExtensionContext): boolean;
-export declare function createToolLoader(pi: SearchAPI, getState: () => McpExtensionState | null, getInitPromise: () => Promise<McpExtensionState> | null, beforeExecute?: McpAdapterOptions["beforeExecute"]): {
-    native: boolean;
+export declare function createToolLoader(pi: ExtensionAPI, getState: () => McpExtensionState | null, getInitPromise: () => Promise<McpExtensionState> | null, beforeExecute?: McpAdapterOptions["beforeExecute"]): {
     registerFeature: <TParams extends TSchema, TDetails>(feature: Feature, definition: ToolDefinition<TParams, TDetails>) => void;
     restore: (ctx: ExtensionContext) => void;
-    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported?: boolean, registerGateways?: (pins: DirectToolSpec[]) => FeaturePolicy) => DirectToolSpec[];
+    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, registerGateways?: (pins: DirectToolSpec[]) => FeaturePolicy) => DirectToolSpec[];
     activate: (matches: Array<{
         server: string;
         tool: ToolMetadata;
-    }>, enable?: Feature[]) => Reference[];
+    }>, enable?: Feature[]) => {
+        name: string;
+    }[];
     persist: () => void;
     selectedServers: () => string[];
 };
-export {};

package/dist/tool-loader.js

@@ -4,21 +4,11 @@ import { isServerCacheValid, reconstructToolMetadata } from "./metadata-cache.js
 import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-result-renderer.js";
 import { isServerDisabled } from "./types.js";
 import { normalizeDirectToolInputSchema } from "./utils.js";
-import { isToolCallApprovalRequired } from "./tool-approval.js";
-const featureRefs = { gateway: { name: "mcp" }, script: { name: "mcp_script" } };
+const featureNames = { gateway: "mcp", script: "mcp_script" };
 const ENTRY = "mcp-tool-selection";
 const key = (value) => JSON.stringify([value.server, value.tool]);
-const refKey = (value) => JSON.stringify([value.namespace ?? null, value.name]);
 const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "mcp", "mcp_search", "mcp_script"]);
-export function supportsNativeAsync(ctx) {
-    const compat = ctx.model?.compat;
-    return "getPendingToolCalls" in ctx && typeof ctx.getPendingToolCalls === "function"
-        && !!compat && "supportsAsyncTools" in compat && compat.supportsAsyncTools === true;
-}
 export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
-    const native = typeof pi.registerToolSearch === "function"
-        && typeof pi.getActiveToolReferences === "function"
-        && typeof pi.setActiveToolReferences === "function";
     pi.registerEntryRenderer(ENTRY, () => undefined);
     const registered = new Map();
     let available = new Set();
@@ -29,24 +19,21 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     let inactiveFeatures = new Set();
     const registeredFeatures = new Set();
     let restoring = true;
-    const active = () => native ? pi.getActiveToolReferences() : pi.getActiveTools().map(name => ({ name }));
-    const setActive = (refs) => {
-        const unique = [...new Map(refs.map(ref => [refKey(ref), ref])).values()];
+    const active = () => pi.getActiveTools();
+    const setActive = (names) => {
+        const unique = [...new Set(names)];
         if (JSON.stringify(active()) === JSON.stringify(unique))
             return;
-        if (native)
-            pi.setActiveToolReferences(unique);
-        else
-            pi.setActiveTools(unique.map(ref => ref.name));
+        pi.setActiveTools(unique);
     };
     function registerFeature(feature, definition) {
         pi.registerTool(definition);
         registeredFeatures.add(feature);
     }
     function capture() {
-        const current = new Set(active().map(refKey));
+        const current = new Set(active());
         for (const feature of Object.keys(features)) {
-            if (current.has(refKey(featureRefs[feature]))) {
+            if (current.has(featureNames[feature])) {
                 if (!features[feature]?.eager)
                     selectedFeatures.add(feature);
                 inactiveFeatures.delete(feature);
@@ -57,10 +44,10 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                     inactiveFeatures.add(feature);
             }
         }
-        for (const [id, { selection, ref, pinned }] of registered) {
+        for (const [id, { selection, name, pinned }] of registered) {
             if (!available.has(id))
                 continue;
-            if (current.has(refKey(ref))) {
+            if (current.has(name)) {
                 if (!pinned)
                     selected.set(id, selection);
                 inactive.delete(id);
@@ -97,11 +84,11 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
         }
         restoring = true;
     }
-    function sync(config, cache, env, asyncSupported = false, registerGateways) {
+    function sync(config, cache, env, registerGateways) {
         if (!restoring)
             capture();
-        const previousRefs = new Set([...registered.values()].map(item => refKey(item.ref)));
-        const existing = new Set(pi.getAllTools().map(tool => refKey(tool)));
+        const previousNames = new Set([...registered.values()].map(item => item.name));
+        const existing = new Set(pi.getAllTools().map(tool => tool.name));
         const specs = [];
         for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
             if (isServerDisabled(definition))
@@ -114,27 +101,26 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                 if (tool.resourceUri)
                     continue;
                 const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
-                const ref = native && !pinned ? { namespace: `mcp_${server}`, name: tool.originalName } : { name: prefixedName };
-                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, ref, pinned });
+                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, name: prefixedName, pinned });
             }
         }
         const counts = new Map();
-        for (const { ref } of specs)
-            counts.set(refKey(ref), (counts.get(refKey(ref)) ?? 0) + 1);
+        for (const { name } of specs)
+            counts.set(name, (counts.get(name) ?? 0) + 1);
         available = new Set();
         const enabled = [];
-        for (const { spec, selection, ref, pinned } of specs) {
+        for (const { spec, selection, name, pinned } of specs) {
             const id = key(selection);
-            const refId = refKey(ref);
-            if ((!ref.namespace && reserved.has(ref.name)) || counts.get(refId) > 1 || (existing.has(refId) && !previousRefs.has(refId)))
+            if (reserved.has(name) || counts.get(name) > 1 || (existing.has(name) && !previousNames.has(name)))
                 continue;
             available.add(id);
-            const asyncTool = asyncSupported && !beforeExecute && !spec.uiResourceUri && !isToolCallApprovalRequired(config, spec.serverName, spec);
-            const fingerprint = JSON.stringify({ spec, ref, asyncTool });
+            const fingerprint = JSON.stringify({ spec, name });
             if (registered.get(id)?.fingerprint !== fingerprint) {
                 pi.registerTool({
-                    ...ref,
-                    ...(asyncTool ? { async: true } : {}),
+                    name,
+                    namespace: { name: `mcp_${spec.serverName}` },
+                    // Inactive direct tools are not callable through codemode or nested execution.
+                    defaultActive: false,
                     ...(beforeExecute ? { executionMode: "sequential" } : {}),
                     label: spec.title ?? `MCP: ${spec.originalName}`,
                     description: spec.description || "(no description)",
@@ -144,22 +130,22 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                     renderResult: renderMcpToolResult,
                 });
             }
-            registered.set(id, { selection, ref, fingerprint, pinned });
+            registered.set(id, { selection, name, fingerprint, pinned });
             if (selected.has(id) || (pinned && !inactive.has(id)))
-                enabled.push(ref);
+                enabled.push(name);
         }
-        const permitted = new Set(pi.getAllTools().map(refKey));
-        const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(refKey(item.ref))).map(item => item.spec);
+        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
+        const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(item.name)).map(item => item.spec);
         const policy = registerGateways?.(pins);
         if (policy) {
-            const permittedFeatures = new Set(pi.getAllTools().map(refKey));
-            const loaderMissing = !permittedFeatures.has(refKey({ name: "mcp_search" }));
+            const permittedFeatures = new Set(pi.getAllTools().map(tool => tool.name));
+            const loaderMissing = !permittedFeatures.has("mcp_search");
             features = {};
-            for (const feature of Object.keys(featureRefs)) {
-                if (policy[feature] && permittedFeatures.has(refKey(featureRefs[feature]))) {
+            for (const feature of Object.keys(featureNames)) {
+                if (policy[feature] && permittedFeatures.has(featureNames[feature])) {
                     features[feature] = { eager: policy[feature].eager || loaderMissing };
                     if (selectedFeatures.has(feature) || (features[feature]?.eager && !inactiveFeatures.has(feature)))
-                        enabled.push(featureRefs[feature]);
+                        enabled.push(featureNames[feature]);
                 }
                 else {
                     selectedFeatures.delete(feature);
@@ -168,10 +154,10 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             }
         }
         // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
-        const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+        const ownedNames = new Set([...previousNames, ...[...registered.values()].map(item => item.name)]);
         for (const feature of registeredFeatures)
-            ownedRefs.add(refKey(featureRefs[feature]));
-        setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
+            ownedNames.add(featureNames[feature]);
+        setActive([...active().filter(name => !ownedNames.has(name)), ...enabled]);
         restoring = false;
         return pins;
     }
@@ -182,22 +168,22 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             return registration ? [registration] : [];
         });
         // No await between reading and extending the current loadout: parallel searches union their selections.
-        const permitted = new Set(pi.getAllTools().map(refKey));
-        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(refKey(featureRefs[feature])));
-        setActive([...active(), ...requested.map(item => item.ref), ...requestedFeatures.map(feature => featureRefs[feature])]);
-        const current = new Set(active().map(refKey));
-        const tools = requested.filter(item => current.has(refKey(item.ref))).map(({ selection, ref }) => {
+        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
+        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(featureNames[feature]));
+        setActive([...active(), ...requested.map(item => item.name), ...requestedFeatures.map(feature => featureNames[feature])]);
+        const current = new Set(active());
+        const tools = requested.filter(item => current.has(item.name)).map(({ selection, name }) => {
             selected.set(key(selection), selection);
-            return ref;
+            return { name };
         });
         for (const feature of requestedFeatures) {
-            if (!current.has(refKey(featureRefs[feature])))
+            if (!current.has(featureNames[feature]))
                 continue;
             selectedFeatures.add(feature);
-            tools.push(featureRefs[feature]);
+            tools.push({ name: featureNames[feature] });
         }
         persist();
         return tools;
     }
-    return { native, registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+    return { registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-mcp-adapter",
-  "version": "7.1.0",
+  "version": "7.1.1",
   "description": "Fitch's independently maintained MCP adapter for Pi coding agent",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -35,7 +35,7 @@
     "build:bridge": "node ./scripts/build-app-bridge.mjs",
     "prepare": "node ./scripts/prepare.mjs",
     "check:compat": "node scripts/compat-host.mjs && npm run build && npm run typecheck && vitest run --exclude __tests__/interactive-visualizer-server.test.ts && npm run test:oauth && node scripts/compat-package-smoke.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ./scripts/tsc.mjs --noEmit",
     "test": "vitest run && npm run test:oauth",
     "test:watch": "vitest",
     "test:oauth": "PI_MCP_ADAPTER_TEST_AUTH_STORE=memory node --test --test-concurrency=1 mcp-auth.test.ts mcp-auth-flow.test.ts mcp-callback-server.test.ts mcp-oauth-provider.test.ts",
@@ -76,9 +76,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@modelcontextprotocol/client": "2.1.0",
-    "@modelcontextprotocol/core": "2.1.0",
-    "@modelcontextprotocol/ext-apps": "2.0.0",
+    "@modelcontextprotocol/client": "2.2.0",
+    "@modelcontextprotocol/core": "2.2.0",
+    "@modelcontextprotocol/ext-apps": "2.0.3",
     "@napi-rs/keyring": "2.1.0",
     "cross-spawn": "7.0.6",
     "minisearch": "7.2.0",
@@ -108,16 +108,16 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.1",
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
-    "@modelcontextprotocol/server": "2.1.0",
+    "@earendil-works/pi-ai": "0.99.2",
+    "@earendil-works/pi-coding-agent": "0.99.2",
+    "@earendil-works/pi-tui": "0.99.2",
+    "@modelcontextprotocol/server": "2.2.0",
     "@types/cross-spawn": "6.0.6",
     "@types/node": "24.19.0",
     "esbuild": "0.28.2",
-    "typebox": "1.3.34",
+    "typebox": "1.3.27",
     "typescript": "7.0.2",
-    "vitest": "5.0.2"
+    "vitest": "5.0.3"
   },
-  "packageManager": "npm@12.1.0"
+  "packageManager": "npm@12.2.0"
 }