@fitchmultz/pi-mcp-adapter 5.0.0 → 6.0.0

package/dist/resource-tools.d.ts

@@ -1 +1,16 @@
+import type { McpExtensionState } from "./state.ts";
+import { type McpOperationContext, type McpToolCallIdentity } from "./types.ts";
+export declare function executeResourceList(state: McpExtensionState, server: string, limit?: number, offset?: number, signal?: AbortSignal): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>> | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        mode: string;
+        error: string;
+        server: string;
+        message: string;
+    };
+}>;
+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

@@ -1,4 +1,29 @@
-// resource-tools.ts - MCP resource name utilities
+import { isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { executeCall, prepareMcpConnection } from "./proxy-modes.js";
+import { paginate } from "./search-ranking.js";
+import { throwIfAborted } from "./abort.js";
+import { combineAbortSignals } from "./runtime-owner.js";
+export async function executeResourceList(state, server, limit = 12, offset = 0, signal) {
+    throwIfAborted(combineAbortSignals(state.owner?.signal, signal));
+    const definition = state.config.mcpServers[server];
+    if (!definition || isServerDisabled(definition)) {
+        return { content: [{ type: "text", text: `Server "${server}" is ${definition ? "disabled" : "not configured"}.` }], details: { mode: "resources", server, error: definition ? "server_disabled" : "server_not_found" } };
+    }
+    if (!state.toolMetadata.has(server) || state.manager.getConnection(server)?.status === "connected") {
+        const prepared = await prepareMcpConnection(state, server, signal);
+        if (prepared.error)
+            return prepared.error;
+    }
+    const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
+    const page = paginate((state.toolMetadata.get(server) ?? [])
+        .filter(tool => tool.resourceUri !== undefined && definition.exposeResources !== false
+        && isToolAllowed(tool.originalName, server, prefix, definition.includeTools, definition.excludeTools))
+        .map(tool => tool.resourceDescriptor ?? { uri: tool.resourceUri, description: tool.description }), offset, limit);
+    return { content: [{ type: "text", text: JSON.stringify({ server, ...page }, null, 2) }], details: { mode: "resources", server, ...page } };
+}
+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, "_")

package/dist/sampling-handler.js

@@ -28,12 +28,15 @@ export async function handleSamplingRequest(options, request) {
     throwIfAborted(signal);
     await confirmSampling(options, "Approve MCP sampling request", formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages));
     throwIfAborted(signal);
+    const supportsTemperature = model.compat && "supportsTemperature" in model.compat
+        ? model.compat.supportsTemperature !== false
+        : !(model.id === "gpt-6-astra" && (model.api === "openai-responses" || model.api === "openai-codex-responses"));
     const result = await options.modelRegistry.complete(model, {
         ...(params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {}),
         messages,
     }, {
         maxTokens: params.maxTokens,
-        ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
+        ...(supportsTemperature && params.temperature !== undefined ? { temperature: params.temperature } : {}),
         ...(params.metadata !== undefined ? { metadata: params.metadata } : {}),
         ...(signal ? { signal } : {}),
     });

package/dist/search-ranking.d.ts

@@ -8,8 +8,6 @@ export interface RankedToolMatch {
     score: number;
 }
 export declare function normalizeSearchText(value: string): string;
-export declare function tokenize(value: string): string[];
-export declare function scoreToolMatch(tool: ToolMetadata, server: string, query: string): number | null;
 export declare function rankToolMatches(state: McpExtensionState, query: string, server?: string): RankedToolMatch[];
 export declare function paginate<T>(items: T[], offset: number, limit: number): {
     items: T[];

package/dist/search-ranking.js

@@ -1,98 +1,75 @@
-import { getServerPrefix, isServerDisabled, resolveToolPrefix } from "./types.js";
-/**
- * Shortest field token allowed to stem-match a longer query token.
- * Real descriptions tokenize possessives into single letters ("project's" -> ["project", "s"]),
- * which would otherwise make every query starting with that letter a match.
- */
-const MIN_STEM_LENGTH = 4;
+import MiniSearch from "minisearch";
+import { getServerPrefix, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
 export const MAX_PAGE_SIZE = 100;
 export const MAX_TOOL_NAME_LENGTH = 512;
-const FIELD_WEIGHTS = {
-    name: 12,
-    originalName: 10,
-    server: 8,
-    description: 5,
-};
 export function normalizeSearchText(value) {
     return value
         .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
         .replace(/[_./:-]+/g, " ")
         .toLowerCase();
 }
-export function tokenize(value) {
-    return normalizeSearchText(value).split(/[^a-z0-9]+/).filter(Boolean);
+function schemaSearchText(schema) {
+    if (!schema || typeof schema !== "object")
+        return "";
+    if (Array.isArray(schema))
+        return schema.map(schemaSearchText).join(" ");
+    return Object.entries(schema).flatMap(([key, value]) => {
+        if ((key === "description" || key === "title" || key === "const") && typeof value === "string")
+            return value;
+        if (key === "enum" && Array.isArray(value))
+            return value.filter(item => typeof item === "string");
+        if (key === "properties" && value && typeof value === "object")
+            return [Object.keys(value).join(" "), schemaSearchText(value)];
+        return schemaSearchText(value);
+    }).join(" ");
 }
-export function scoreToolMatch(tool, server, query) {
-    const normalizedQuery = normalizeSearchText(query).trim();
-    const queryTokens = tokenize(query);
-    if (queryTokens.length === 0)
-        return null;
-    const fields = {
-        name: normalizeSearchText(tool.name),
-        originalName: normalizeSearchText(tool.originalName),
-        server: normalizeSearchText(server),
-        description: normalizeSearchText(tool.description),
-    };
-    let score = 0;
-    let phraseMatched = false;
-    let wholeFieldExact = false;
-    const matchedTokens = new Set();
-    for (const [field, value] of Object.entries(fields)) {
-        const weight = FIELD_WEIGHTS[field];
-        const fieldTokens = tokenize(value);
-        if (value === normalizedQuery) {
-            score += weight * 14;
-            phraseMatched = true;
-            wholeFieldExact = true;
-        }
-        else if (value.startsWith(normalizedQuery)) {
-            score += weight * 9;
-            phraseMatched = true;
-        }
-        else if (value.includes(normalizedQuery)) {
-            score += weight * 6;
-            phraseMatched = true;
-        }
-        for (const token of queryTokens) {
-            if (fieldTokens.includes(token)) {
-                score += weight * 4;
-                matchedTokens.add(token);
-            }
-            else if (fieldTokens.some(fieldToken => fieldToken.startsWith(token) || (fieldToken.length >= MIN_STEM_LENGTH && token.startsWith(fieldToken)))) {
-                score += weight * 2;
-                matchedTokens.add(token);
-            }
-            else if (value.includes(token)) {
-                score += weight;
-                matchedTokens.add(token);
-            }
+const indexes = new WeakMap();
+function getIndex(state) {
+    const cached = indexes.get(state);
+    // Catalog publishers replace each server's metadata array on discovery/reconnect.
+    if (cached && cached.metadata.size === state.toolMetadata.size
+        && [...state.toolMetadata].every(([server, metadata]) => cached.metadata.get(server) === metadata)) {
+        return cached.index;
+    }
+    const index = new MiniSearch({
+        fields: ["name", "originalName", "description", "schema"],
+        storeFields: ["server", "tool"],
+        searchOptions: { fields: ["name", "description", "schema"], boost: { name: 2, description: 1, schema: 1 }, prefix: true },
+    });
+    let id = 0;
+    for (const [server, tools] of state.toolMetadata) {
+        for (const tool of tools) {
+            if (tool.resourceUri !== undefined)
+                continue;
+            index.add({
+                id: id++, server, tool,
+                name: normalizeSearchText(tool.name),
+                originalName: normalizeSearchText(tool.originalName),
+                description: normalizeSearchText([tool.title, tool.description].filter(Boolean).join(" ")),
+                schema: normalizeSearchText(schemaSearchText(tool.inputSchema)),
+            });
         }
     }
-    const coverage = matchedTokens.size / queryTokens.length;
-    if (!phraseMatched && (queryTokens.length <= 2 ? coverage !== 1 : coverage < 0.6))
-        return null;
-    score += coverage === 1 ? 25 : Math.round(coverage * 10);
-    const firstQueryToken = queryTokens[0];
-    if (firstQueryToken !== undefined && tokenize(fields.name).includes(firstQueryToken))
-        score += 8;
-    if (wholeFieldExact)
-        score += 20;
-    return score;
+    indexes.set(state, { metadata: new Map(state.toolMetadata), index });
+    return index;
+}
+function searchCatalog(state, query, server, options) {
+    return getIndex(state).search(normalizeSearchText(query), {
+        ...options,
+        filter: result => {
+            if (server && result.server !== server)
+                return false;
+            const definition = state.config.mcpServers[result.server];
+            if (!definition || isServerDisabled(definition))
+                return false;
+            const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
+            return isToolAllowed(result.tool.originalName, result.server, prefix, definition.includeTools, definition.excludeTools);
+        },
+    }).map(({ server, tool, score }) => ({ server, tool, score }))
+        .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
 }
 export function rankToolMatches(state, query, server) {
-    const matches = [];
-    for (const [serverName, metadata] of state.toolMetadata.entries()) {
-        if (server && serverName !== server)
-            continue;
-        if (isServerDisabled(state.config.mcpServers[serverName]))
-            continue;
-        for (const tool of metadata) {
-            const score = scoreToolMatch(tool, serverName, query);
-            if (score !== null)
-                matches.push({ server: serverName, tool, score });
-        }
-    }
-    return matches.sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
+    return searchCatalog(state, query, server);
 }
 export function paginate(items, offset, limit) {
     const safeOffset = Number.isFinite(offset) ? Math.max(0, Math.trunc(offset)) : 0;
@@ -107,36 +84,6 @@ export function paginate(items, offset, limit) {
         nextOffset: nextOffset < total ? nextOffset : null,
     };
 }
-function editDistance(a, b, maxDistance) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-        return maxDistance + 1;
-    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-    for (let i = 1; i <= a.length; i++) {
-        const current = [i];
-        let rowMin = i;
-        for (let j = 1; j <= b.length; j++) {
-            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-            rowMin = Math.min(rowMin, current[j]);
-        }
-        if (rowMin > maxDistance)
-            return maxDistance + 1;
-        previous = current;
-    }
-    return previous[b.length];
-}
-function rankClosest(tools, query, limit, candidateName) {
-    const normalizedQuery = normalizeSearchText(query).replace(/\s+/g, "_");
-    const maxDistance = Math.max(2, Math.floor(normalizedQuery.length * 0.2));
-    return tools
-        .map(tool => ({
-        tool,
-        distance: editDistance(normalizedQuery, normalizeSearchText(candidateName(tool)).replace(/\s+/g, "_"), maxDistance),
-    }))
-        .filter(({ distance }) => distance <= maxDistance)
-        .sort((a, b) => a.distance - b.distance || a.tool.name.localeCompare(b.tool.name))
-        .slice(0, limit)
-        .map(({ tool }) => tool.name);
-}
 export function rankSuggestions(state, name, limit, server) {
     if (name.length > MAX_TOOL_NAME_LENGTH)
         return [];
@@ -150,31 +97,13 @@ export function rankSuggestions(state, name, limit, server) {
         .filter((candidate) => Boolean(candidate.prefix) && name.startsWith(`${candidate.prefix}_`))
         .sort((a, b) => b.prefix.length - a.prefix.length)[0];
     const matchedServer = server ?? inferred?.server;
-    if (!matchedServer) {
-        const tools = [...state.toolMetadata.entries()]
-            .filter(([candidateServer]) => !isServerDisabled(state.config.mcpServers[candidateServer]))
-            .flatMap(([, metadata]) => metadata);
-        const closest = rankClosest(tools, name, limit, tool => tool.name);
-        return closest.length > 0 ? closest : rankToolMatches(state, name).slice(0, limit).map(match => match.tool.name);
-    }
-    const definition = state.config.mcpServers[matchedServer];
-    if (!definition || isServerDisabled(definition))
+    const definition = matchedServer ? state.config.mcpServers[matchedServer] : undefined;
+    if (matchedServer && (!definition || isServerDisabled(definition)))
         return [];
-    const prefix = inferred?.prefix ?? getServerPrefix(matchedServer, resolveToolPrefix(definition, globalPrefix));
+    const prefix = inferred?.prefix ?? (matchedServer ? getServerPrefix(matchedServer, resolveToolPrefix(definition, globalPrefix)) : "");
     const query = prefix && name.startsWith(`${prefix}_`) ? name.slice(prefix.length + 1) : name;
-    const tools = state.toolMetadata.get(matchedServer) ?? [];
-    const closest = rankClosest(tools, query, limit, tool => tool.originalName);
-    if (closest.length > 0)
-        return closest;
-    const queryTokens = tokenize(query);
-    const tokenMatches = rankToolMatches(state, query, matchedServer)
-        .filter(({ tool }) => {
-        const candidateTokens = tokenize(tool.originalName);
-        return queryTokens.every(token => candidateTokens.some(candidate => candidate === token
-            || candidate.startsWith(token)
-            || (candidate.length >= MIN_STEM_LENGTH && token.startsWith(candidate))));
-    })
-        .slice(0, limit)
-        .map(match => match.tool.name);
-    return tokenMatches.length > 0 || !server ? tokenMatches : rankSuggestions(state, name, limit);
+    const suggestions = searchCatalog(state, query, matchedServer, {
+        fields: [matchedServer ? "originalName" : "name"], combineWith: "AND", fuzzy: 2,
+    }).slice(0, limit).map(match => match.tool.name);
+    return suggestions.length > 0 || !server ? suggestions : rankSuggestions(state, name, limit);
 }

package/dist/state.d.ts

@@ -33,7 +33,7 @@ export interface McpExtensionState {
     manager: McpServerManager;
     lifecycle: McpLifecycleManager;
     toolMetadata: Map<string, ToolMetadata[]>;
-    /** Resource counts retained separately because tool metadata includes resource tools. */
+    /** Native resource counts, separate from callable tools. */
     resourceCounts: Map<string, number>;
     promptMetadata: Map<string, PromptMetadata[]>;
     /** Servers whose prompt inventory came from successful live discovery. */

package/dist/tool-loader.d.ts

@@ -0,0 +1,32 @@
+import type { AgentToolResult, 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;
+};
+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;
+    restore: (ctx: ExtensionContext) => void;
+    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported?: boolean, registerGateways?: (pins: DirectToolSpec[]) => void) => DirectToolSpec[];
+    activate: (matches: Array<{
+        server: string;
+        tool: ToolMetadata;
+    }>) => Reference[];
+    persist: () => void;
+    selectedServers: () => string[];
+};
+export {};

package/dist/tool-loader.js

@@ -0,0 +1,152 @@
+import { Type } from "typebox";
+import { createDirectToolExecutor, directToolSelection } from "./direct-tools.js";
+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 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();
+    let selected = new Map();
+    let inactive = new Map();
+    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()];
+        if (JSON.stringify(active()) === JSON.stringify(unique))
+            return;
+        if (native)
+            pi.setActiveToolReferences(unique);
+        else
+            pi.setActiveTools(unique.map(ref => ref.name));
+    };
+    function capture() {
+        const current = new Set(active().map(refKey));
+        for (const [id, { selection, ref, pinned }] of registered) {
+            if (!available.has(id))
+                continue;
+            if (current.has(refKey(ref))) {
+                if (!pinned)
+                    selected.set(id, selection);
+                inactive.delete(id);
+            }
+            else {
+                selected.delete(id);
+                if (pinned)
+                    inactive.set(id, selection);
+            }
+        }
+    }
+    function persist() {
+        capture();
+        pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()] });
+    }
+    function restore(ctx) {
+        selected = new Map();
+        inactive = new Map();
+        for (const entry of ctx.sessionManager.getBranch()) {
+            if (entry.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object")
+                continue;
+            const data = entry.data;
+            for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]]) {
+                target.clear();
+                for (const selection of Array.isArray(field) ? field : []) {
+                    if (typeof selection?.server === "string" && typeof selection.tool === "string")
+                        target.set(key(selection), selection);
+                }
+            }
+        }
+        restoring = true;
+    }
+    function sync(config, cache, env, asyncSupported = false, 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 specs = [];
+        for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
+            if (isServerDisabled(definition))
+                continue;
+            const entry = cache?.servers[server];
+            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) {
+                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 });
+            }
+        }
+        const counts = new Map();
+        for (const { ref } of specs)
+            counts.set(refKey(ref), (counts.get(refKey(ref)) ?? 0) + 1);
+        available = new Set();
+        const enabled = [];
+        for (const { spec, selection, ref, 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)))
+                continue;
+            available.add(id);
+            const asyncTool = asyncSupported && !beforeExecute && !spec.uiResourceUri && !isToolCallApprovalRequired(config, spec.serverName, spec);
+            const fingerprint = JSON.stringify({ spec, ref, asyncTool });
+            if (registered.get(id)?.fingerprint !== fingerprint) {
+                pi.registerTool({
+                    ...ref,
+                    ...(asyncTool ? { async: true } : {}),
+                    ...(beforeExecute ? { executionMode: "sequential" } : {}),
+                    label: spec.title ?? `MCP: ${spec.originalName}`,
+                    description: spec.description || "(no description)",
+                    parameters: Type.Unsafe(normalizeDirectToolInputSchema(spec.inputSchema)),
+                    execute: createDirectToolExecutor(getState, getInitPromise, spec, beforeExecute),
+                    renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
+                    renderResult: renderMcpToolResult,
+                });
+            }
+            registered.set(id, { selection, ref, fingerprint, pinned });
+            if (selected.has(id) || (pinned && !inactive.has(id)))
+                enabled.push(ref);
+        }
+        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);
+        registerGateways?.(pins);
+        // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
+        const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+        setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
+        restoring = false;
+        return pins;
+    }
+    function activate(matches) {
+        const requested = matches.flatMap(({ server, tool }) => {
+            const id = key({ server, tool: tool.originalName });
+            const registration = available.has(id) ? registered.get(id) : undefined;
+            return registration ? [registration] : [];
+        });
+        // No await between reading and extending the current loadout: parallel searches union their selections.
+        setActive([...active(), ...requested.map(item => item.ref)]);
+        const current = new Set(active().map(refKey));
+        const tools = requested.filter(item => current.has(refKey(item.ref))).map(({ selection, ref }) => {
+            selected.set(key(selection), selection);
+            return ref;
+        });
+        persist();
+        return tools;
+    }
+    return { native, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+}

package/dist/tool-metadata.d.ts

@@ -5,5 +5,72 @@ export declare function buildToolMetadata(tools: McpTool[], resources: McpResour
     failedTools: string[];
 };
 export declare function totalToolCount(state: McpExtensionState): number;
+export declare function toToolDescriptor(server: string, tool: ToolMetadata): {
+    server: string;
+    path: string;
+    name: string;
+    description: string;
+    _meta?: {
+        [x: string]: unknown;
+    } | undefined;
+    icons?: {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+        theme?: "light" | "dark" | undefined;
+    }[] | undefined;
+    title?: string | undefined;
+    inputSchema?: {
+        [x: string]: unknown;
+        type: "object";
+        properties?: {
+            [x: string]: string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null;
+            } | (string | number | boolean | {
+                [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+            } | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+        } | undefined;
+        required?: string[] | undefined;
+    };
+    outputSchema?: {
+        [x: string]: unknown;
+        $schema?: string | undefined;
+    } | undefined;
+    annotations?: {
+        title?: string | undefined;
+        readOnlyHint?: boolean | undefined;
+        destructiveHint?: boolean | undefined;
+        idempotentHint?: boolean | undefined;
+        openWorldHint?: boolean | undefined;
+    } | undefined;
+    execution?: {
+        taskSupport?: "optional" | "required" | "forbidden" | undefined;
+    } | undefined;
+};
+export declare function catalogCoverage(state: McpExtensionState, server?: string): {
+    complete: boolean;
+    knownServers: string[];
+    unknownServers: string[];
+};
 export declare function findToolByName(metadata: ToolMetadata[] | undefined, toolName: string): ToolMetadata | undefined;
 export declare function formatSchema(schema: unknown, indent?: string): string;