@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/mcp-trace.d.ts

@@ -0,0 +1,95 @@
+import type { Transport } from "@modelcontextprotocol/client";
+import type { JSONRPCMessage } from "@modelcontextprotocol/client";
+export declare const MCP_TRACE_SCHEMA_VERSION = 1;
+export declare const DEFAULT_MCP_TRACE_MAX_BYTES: number;
+export declare const DEFAULT_MCP_TRACE_MAX_EVENTS = 10000;
+export type McpTraceDirection = "outbound" | "inbound";
+export type McpTraceTransport = "stdio" | "unix-socket" | "sse" | "streamable-http" | "unknown";
+export type McpTraceMessageKind = "request" | "response" | "notification";
+export interface McpTraceSettings {
+    /** Enable metadata-only protocol tracing for all servers unless overridden. */
+    enabled?: boolean;
+    /** JSONL destination. Relative paths are resolved from the session cwd. */
+    file?: string;
+    /** Maximum bytes retained in the per-session JSONL file. */
+    maxBytes?: number;
+    /** Maximum events retained in the per-session JSONL file. */
+    maxEvents?: number;
+}
+export interface McpTraceEvent {
+    version: typeof MCP_TRACE_SCHEMA_VERSION;
+    timestamp: string;
+    direction: McpTraceDirection;
+    server: string;
+    transport: McpTraceTransport;
+    kind: McpTraceMessageKind;
+    status: "sent" | "received" | "error";
+    method?: string;
+    id?: string | number | null;
+    relatedRequestId?: string | number;
+    errorCode?: number | string;
+    bytes?: number;
+    durationMs?: number;
+}
+export interface McpTraceWriterOptions {
+    filePath: string;
+    maxBytes?: number;
+    maxEvents?: number;
+    appendFile?: (path: string, data: string, options: {
+        encoding: "utf8";
+    }) => Promise<void>;
+    writeFile?: (path: string, data: string, options: {
+        encoding: "utf8";
+    }) => Promise<void>;
+    mkdir?: (path: string, options: {
+        recursive: true;
+    }) => Promise<string | undefined>;
+}
+/** Redact strings before they can become durable trace metadata. */
+export declare function redactTraceText(value: string, maxLength?: number): string;
+export declare function createMcpTraceEvent(direction: McpTraceDirection, server: string, transport: McpTraceTransport, message: JSONRPCMessage, status: "sent" | "received" | "error", options?: {
+    relatedRequestId?: unknown;
+    durationMs?: number;
+}): McpTraceEvent;
+export declare class McpTraceWriter {
+    private readonly options;
+    private readonly maxBytes;
+    private readonly maxEvents;
+    private readonly append;
+    private readonly resetFile;
+    private readonly makeDirectory;
+    private bytesWritten;
+    private eventsWritten;
+    private queue;
+    private disabled;
+    private initializationFailed;
+    private persistenceError;
+    private readonly fileReady;
+    constructor(options: McpTraceWriterOptions);
+    get filePath(): string;
+    get isDisabled(): boolean;
+    get stats(): {
+        bytes: number;
+        events: number;
+    };
+    write(event: McpTraceEvent): void;
+    flush(strict?: boolean): Promise<void>;
+}
+export declare function createMcpTraceWriter(sessionCwd: string | undefined, settings?: McpTraceSettings, randomSuffix?: string): McpTraceWriter;
+export interface McpTraceObserver {
+    record(event: McpTraceEvent): void;
+}
+export declare function isMcpTraceEnabled(definition: {
+    trace?: boolean;
+}, settings?: McpTraceSettings): boolean;
+/**
+ * Compose the SDK's transport callbacks instead of replacing them. Protocol
+ * assigns `onmessage` during connect, so the setter must keep the observer in
+ * front of whichever callback the SDK installs.
+ */
+export declare function wrapTransportWithMcpTrace(transport: Transport, server: string, transportKind: McpTraceTransport, observer: McpTraceObserver): Transport;
+export declare function traceTransportKind(definition: {
+    command?: string;
+    url?: string;
+    socket?: string;
+}, transport: Transport): McpTraceTransport;

package/dist/mcp-trace.js

@@ -0,0 +1,233 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { dirname, isAbsolute, resolve } from "node:path";
+export const MCP_TRACE_SCHEMA_VERSION = 1;
+export const DEFAULT_MCP_TRACE_MAX_BYTES = 256 * 1024;
+export const DEFAULT_MCP_TRACE_MAX_EVENTS = 10_000;
+function boundedPositiveInteger(value, fallback) {
+    if (!Number.isFinite(value) || value === undefined || value <= 0)
+        return fallback;
+    return Math.floor(value);
+}
+/** Redact strings before they can become durable trace metadata. */
+export function redactTraceText(value, maxLength = 160) {
+    if (/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\b/i.test(value)) {
+        return "[REDACTED]";
+    }
+    let redacted = value
+        .replace(/\b[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/gi, "[REDACTED_URL]")
+        .replace(/\b(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]+/gi, "[REDACTED_AUTH]")
+        .replace(/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]");
+    if (redacted.length > maxLength)
+        redacted = `${redacted.slice(0, maxLength - 1)}…`;
+    return redacted;
+}
+function messageKind(message) {
+    if ("method" in message)
+        return "id" in message ? "request" : "notification";
+    return "response";
+}
+function traceId(value) {
+    if (value === null)
+        return null;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string")
+        return "[REDACTED_ID]";
+    return undefined;
+}
+function messageBytes(message) {
+    try {
+        return Buffer.byteLength(JSON.stringify(message), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createMcpTraceEvent(direction, server, transport, message, status, options) {
+    const kind = messageKind(message);
+    const bytes = messageBytes(message);
+    const event = {
+        version: MCP_TRACE_SCHEMA_VERSION,
+        timestamp: new Date().toISOString(),
+        direction,
+        server: redactTraceText(server, 120),
+        transport,
+        kind,
+        status,
+        ...(bytes !== undefined ? { bytes } : {}),
+    };
+    if ("method" in message)
+        event.method = redactTraceText(message.method, 120);
+    if ("id" in message)
+        event.id = traceId(message.id) ?? null;
+    const relatedRequestId = traceId(options?.relatedRequestId);
+    if (relatedRequestId !== undefined && relatedRequestId !== null)
+        event.relatedRequestId = relatedRequestId;
+    if ("error" in message && message.error && typeof message.error.code === "number") {
+        event.errorCode = message.error.code;
+    }
+    if (options?.durationMs !== undefined && Number.isFinite(options.durationMs)) {
+        event.durationMs = Math.max(0, Math.round(options.durationMs * 100) / 100);
+    }
+    return event;
+}
+export class McpTraceWriter {
+    options;
+    maxBytes;
+    maxEvents;
+    append;
+    resetFile;
+    makeDirectory;
+    bytesWritten = 0;
+    eventsWritten = 0;
+    queue = Promise.resolve();
+    disabled = false;
+    initializationFailed = false;
+    persistenceError;
+    fileReady;
+    constructor(options) {
+        this.options = options;
+        this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);
+        this.maxEvents = boundedPositiveInteger(options.maxEvents, DEFAULT_MCP_TRACE_MAX_EVENTS);
+        this.append = options.appendFile ?? (async (path, data, appendOptions) => {
+            await appendFile(path, data, appendOptions);
+        });
+        this.resetFile = options.writeFile ?? (async (path, data, writeOptions) => {
+            await writeFile(path, data, writeOptions);
+        });
+        this.makeDirectory = options.mkdir ?? (async (path) => {
+            await mkdir(path, { recursive: true });
+            return undefined;
+        });
+        this.fileReady = this.makeDirectory(dirname(this.options.filePath), { recursive: true })
+            .then(() => this.resetFile(this.options.filePath, "", { encoding: "utf8" }))
+            .catch(error => {
+            // Tracing must never change MCP request/response behavior.
+            this.persistenceError = error;
+            this.initializationFailed = true;
+            this.disabled = true;
+        });
+    }
+    get filePath() {
+        return this.options.filePath;
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    get stats() {
+        return { bytes: this.bytesWritten, events: this.eventsWritten };
+    }
+    write(event) {
+        if (this.disabled || this.eventsWritten >= this.maxEvents)
+            return;
+        let line;
+        try {
+            line = `${JSON.stringify(event)}\n`;
+        }
+        catch {
+            this.disabled = true;
+            return;
+        }
+        const bytes = Buffer.byteLength(line, "utf8");
+        if (bytes > this.maxBytes - this.bytesWritten) {
+            this.disabled = true;
+            return;
+        }
+        this.bytesWritten += bytes;
+        this.eventsWritten += 1;
+        this.queue = this.queue.then(async () => {
+            await this.fileReady;
+            if (this.initializationFailed)
+                return;
+            await this.append(this.options.filePath, line, { encoding: "utf8" });
+        }).catch(error => {
+            // Tracing must never change MCP request/response behavior.
+            this.persistenceError ??= error;
+            this.disabled = true;
+        });
+    }
+    async flush(strict = false) {
+        await this.fileReady;
+        await this.queue;
+        if (strict && this.persistenceError !== undefined)
+            throw this.persistenceError;
+    }
+}
+export function createMcpTraceWriter(sessionCwd, settings = {}, randomSuffix = Math.random().toString(36).slice(2, 10)) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const configuredPath = settings.file;
+    const filePath = configuredPath
+        ? (isAbsolute(configuredPath) ? configuredPath : resolve(sessionCwd ?? process.cwd(), configuredPath))
+        : resolve(sessionCwd ?? process.cwd(), ".pi", "fitch-mcp-adapter", "traces", `mcp-${timestamp}-${randomSuffix}.jsonl`);
+    return new McpTraceWriter({
+        filePath,
+        ...(settings.maxBytes !== undefined ? { maxBytes: settings.maxBytes } : {}),
+        ...(settings.maxEvents !== undefined ? { maxEvents: settings.maxEvents } : {}),
+    });
+}
+export function isMcpTraceEnabled(definition, settings) {
+    return definition.trace ?? settings?.enabled === true;
+}
+/**
+ * Compose the SDK's transport callbacks instead of replacing them. Protocol
+ * assigns `onmessage` during connect, so the setter must keep the observer in
+ * front of whichever callback the SDK installs.
+ */
+export function wrapTransportWithMcpTrace(transport, server, transportKind, observer) {
+    let messageHandler = transport.onmessage;
+    const record = (event) => {
+        try {
+            observer.record(event);
+        }
+        catch {
+            // An observer failure must never alter SDK transport behavior.
+        }
+    };
+    // Instrument the native instance: the SDK inspects stdio identity and HTTP
+    // hasPerRequestStream to choose negotiation and cancellation behavior.
+    const send = transport.send.bind(transport);
+    transport.send = async (message, options) => {
+        const started = performance.now();
+        const messages = Array.isArray(message) ? message : [message];
+        try {
+            await send(message, options);
+            for (const item of messages) {
+                record(createMcpTraceEvent("outbound", server, transportKind, item, "sent", {
+                    durationMs: performance.now() - started,
+                }));
+            }
+        }
+        catch (error) {
+            for (const item of messages) {
+                record(createMcpTraceEvent("outbound", server, transportKind, item, "error", {
+                    durationMs: performance.now() - started,
+                }));
+            }
+            throw error;
+        }
+    };
+    Object.defineProperty(transport, "onmessage", {
+        configurable: true,
+        get: () => messageHandler,
+        set: (handler) => {
+            messageHandler = handler ? (message, extra) => {
+                record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
+                handler(message, extra);
+            } : undefined;
+        },
+    });
+    return transport;
+}
+export function traceTransportKind(definition, transport) {
+    if (definition.command)
+        return "stdio";
+    if (definition.socket)
+        return "unix-socket";
+    const constructorName = transport.constructor?.name.toLowerCase() ?? "";
+    if (constructorName.includes("sse"))
+        return "sse";
+    if (constructorName.includes("streamable"))
+        return "streamable-http";
+    return definition.url ? "streamable-http" : "unknown";
+}

package/dist/metadata-cache.d.ts

@@ -0,0 +1,18 @@
+import type { CachedPrompt, CachedResource, CachedTool, McpConfig, McpTool, McpResource, McpPrompt, MetadataCache, ServerCacheEntry, ServerEntry, ToolMetadata, PromptMetadata } from "./types.ts";
+import { type ToolPrefix } from "./types.ts";
+export type { CachedPrompt, CachedResource, CachedTool, MetadataCache, ServerCacheEntry } from "./types.ts";
+export declare function getMetadataCachePath(): string;
+export declare function loadMetadataCache(enabled?: boolean): MetadataCache | null;
+export declare function saveMetadataCache(cache: MetadataCache, enabled?: boolean): void;
+export declare function computeServerHash(definition: ServerEntry): string;
+export declare function isServerCacheValid(entry: ServerCacheEntry, definition: ServerEntry, maxAgeMs?: number): boolean;
+export declare function parseDirectToolSelectors(selectors: string[]): {
+    servers: Set<string>;
+    tools: Map<string, Set<string>>;
+};
+export declare function getMissingConfiguredDirectToolServers(config: McpConfig, cache: MetadataCache | null, envOverride?: string[]): string[];
+export declare function reconstructToolMetadata(serverName: string, entry: ServerCacheEntry, prefix: ToolPrefix, definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">): ToolMetadata[];
+export declare function serializeTools(tools: McpTool[]): CachedTool[];
+export declare function serializeResources(resources: McpResource[]): CachedResource[];
+export declare function serializePrompts(prompts: McpPrompt[]): CachedPrompt[];
+export declare function reconstructPromptMetadata(serverName: string, prompts: ReadonlyArray<McpPrompt | CachedPrompt>, prefix: ToolPrefix, definition?: Pick<ServerEntry, "toolPrefix">): PromptMetadata[];

package/dist/metadata-cache.js

@@ -0,0 +1,277 @@
+// metadata-cache.ts - Persistent MCP metadata cache
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAdapterPath } from "./agent-dir.js";
+import { createHash } from "node:crypto";
+import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
+import { formatPromptCommandName, formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath, resolveServerUrl, } from "./utils.js";
+import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
+const CACHE_VERSION = 1;
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function getMetadataCachePath() {
+    return getAdapterPath("mcp-cache.json");
+}
+export function loadMetadataCache(enabled = true) {
+    if (!enabled)
+        return null;
+    const cachePath = getMetadataCachePath();
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+        if (!raw || typeof raw !== "object")
+            return null;
+        if (raw.version !== CACHE_VERSION)
+            return null;
+        if (!raw.servers || typeof raw.servers !== "object")
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveMetadataCache(cache, enabled = true) {
+    if (!enabled)
+        return;
+    const cachePath = getMetadataCachePath();
+    const dir = dirname(cachePath);
+    mkdirSync(dir, { recursive: true });
+    let merged = { version: CACHE_VERSION, servers: {} };
+    try {
+        if (existsSync(cachePath)) {
+            const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
+            if (existing && existing.version === CACHE_VERSION && existing.servers) {
+                merged.servers = { ...existing.servers };
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors and proceed with empty cache
+    }
+    merged.version = CACHE_VERSION;
+    merged.servers = { ...merged.servers, ...cache.servers };
+    const tmpPath = `${cachePath}.${process.pid}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
+    renameSync(tmpPath, cachePath);
+}
+export function computeServerHash(definition) {
+    // Hash only fields that affect server identity and tool/resource output.
+    // Exclude lifecycle, idleTimeout, requestTimeoutMs, debug — those are runtime behavior settings
+    // that don't change which tools a server exposes.
+    const identity = {
+        command: definition.command,
+        args: definition.args,
+        socket: resolveConfigPath(definition.socket),
+        env: interpolateEnvRecord(definition.env),
+        cwd: resolveConfigPath(definition.cwd),
+        url: resolveServerUrl(definition),
+        headers: interpolateEnvRecord(definition.headers),
+        auth: definition.auth,
+        bearerToken: resolveBearerToken(definition),
+        bearerTokenEnv: definition.bearerTokenEnv,
+        exposeResources: definition.exposeResources,
+        includeTools: definition.includeTools,
+        excludeTools: definition.excludeTools,
+    };
+    const normalized = stableStringify(identity);
+    return createHash("sha256").update(normalized).digest("hex");
+}
+export function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS) {
+    let configHash;
+    try {
+        configHash = computeServerHash(definition);
+    }
+    catch {
+        return false;
+    }
+    if (!entry || entry.configHash !== configHash)
+        return false;
+    if (!entry.cachedAt || typeof entry.cachedAt !== "number")
+        return false;
+    if (maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs)
+        return false;
+    return true;
+}
+export function parseDirectToolSelectors(selectors) {
+    const servers = new Set();
+    const tools = new Map();
+    for (let selector of selectors) {
+        selector = selector.replace(/\/+$/, "");
+        if (selector.includes("/")) {
+            const [server, tool] = selector.split("/", 2);
+            if (server && tool) {
+                const serverTools = tools.get(server) ?? new Set();
+                serverTools.add(tool);
+                tools.set(server, serverTools);
+            }
+            else if (server) {
+                servers.add(server);
+            }
+        }
+        else if (selector) {
+            servers.add(selector);
+        }
+    }
+    return { servers, tools };
+}
+export function getMissingConfiguredDirectToolServers(config, cache, envOverride) {
+    const missing = [];
+    const globalDirect = config.settings?.directTools;
+    const envSelection = envOverride ? parseDirectToolSelectors(envOverride) : null;
+    for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+        if (isServerDisabled(definition))
+            continue;
+        const hasDirectTools = envSelection
+            ? envSelection.servers.has(serverName) || envSelection.tools.has(serverName)
+            : definition.directTools !== undefined
+                ? !!definition.directTools
+                : !!globalDirect;
+        if (!hasDirectTools)
+            continue;
+        const serverCache = cache?.servers?.[serverName];
+        if (!serverCache || !isServerCacheValid(serverCache, definition)) {
+            missing.push(serverName);
+        }
+    }
+    return missing;
+}
+export function reconstructToolMetadata(serverName, entry, prefix, definition) {
+    const metadata = [];
+    const seenNames = new Set();
+    const effectivePrefix = resolveToolPrefix(definition, prefix);
+    for (const tool of entry.tools ?? []) {
+        if (!tool?.name)
+            continue;
+        if (!isUiToolVisibleToModel(tool.uiVisibility)) {
+            continue;
+        }
+        if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
+            continue;
+        }
+        const name = formatToolName(tool.name, serverName, effectivePrefix);
+        if (seenNames.has(name)) {
+            continue;
+        }
+        seenNames.add(name);
+        metadata.push({
+            name,
+            originalName: tool.name,
+            description: tool.description ?? "",
+            ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
+            ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
+            ...(tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {}),
+            ...(tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {}),
+            ...(tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}),
+        });
+    }
+    if (definition.exposeResources !== false) {
+        for (const resource of entry.resources ?? []) {
+            if (!resource?.name || !resource?.uri)
+                continue;
+            const baseName = `read_${resourceNameToToolName(resource.name)}`;
+            if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
+                continue;
+            }
+            const name = formatToolName(baseName, serverName, effectivePrefix);
+            if (seenNames.has(name)) {
+                continue;
+            }
+            seenNames.add(name);
+            metadata.push({
+                name,
+                originalName: baseName,
+                description: resource.description ?? `Read resource: ${resource.uri}`,
+                resourceUri: resource.uri,
+            });
+        }
+    }
+    return metadata;
+}
+export function serializeTools(tools) {
+    return tools
+        .filter(t => t?.name)
+        .map(t => {
+        const uiResourceUri = tryGetToolUiResourceUri(t);
+        const uiVisibility = extractUiToolVisibility(t._meta);
+        const uiStreamMode = extractToolUiStreamMode(t._meta);
+        return {
+            name: t.name,
+            ...(t.description !== undefined ? { description: t.description } : {}),
+            ...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
+            ...(t.annotations !== undefined ? { annotations: t.annotations } : {}),
+            ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
+            ...(uiVisibility !== undefined ? { uiVisibility } : {}),
+            ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
+        };
+    });
+}
+export function serializeResources(resources) {
+    return resources
+        .filter(r => r?.name && r?.uri)
+        .map(r => ({
+        uri: r.uri,
+        name: r.name,
+        ...(r.description !== undefined ? { description: r.description } : {}),
+    }));
+}
+export function serializePrompts(prompts) {
+    return (prompts ?? [])
+        .filter(prompt => prompt?.name)
+        .map(prompt => ({
+        name: prompt.name,
+        ...(prompt.title !== undefined ? { title: prompt.title } : {}),
+        ...(prompt.description !== undefined ? { description: prompt.description } : {}),
+        ...(Array.isArray(prompt.arguments)
+            ? {
+                arguments: prompt.arguments.filter(argument => argument?.name).map(argument => ({
+                    name: argument.name,
+                    ...(argument.description !== undefined ? { description: argument.description } : {}),
+                    ...(argument.required !== undefined ? { required: argument.required } : {}),
+                })),
+            }
+            : {}),
+    }));
+}
+export function reconstructPromptMetadata(serverName, prompts, prefix, definition) {
+    const effectivePrefix = resolveToolPrefix(definition, prefix);
+    return (prompts ?? []).filter(prompt => prompt?.name).map(prompt => {
+        const args = Array.isArray(prompt.arguments)
+            ? prompt.arguments.filter(argument => argument?.name).map(argument => ({
+                name: argument.name,
+                ...(argument.description !== undefined ? { description: argument.description } : {}),
+                ...(argument.required !== undefined ? { required: argument.required } : {}),
+            }))
+            : [];
+        return {
+            serverName,
+            originalName: prompt.name,
+            commandName: formatPromptCommandName(prompt.name, serverName, effectivePrefix),
+            ...(prompt.title !== undefined ? { title: prompt.title } : {}),
+            description: prompt.description ?? "",
+            arguments: args,
+        };
+    });
+}
+function stableStringify(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        const serialized = JSON.stringify(value);
+        return serialized === undefined ? "undefined" : serialized;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(v => stableStringify(v)).join(",")}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function tryGetToolUiResourceUri(tool) {
+    try {
+        return getToolUiResourceUri({ _meta: tool._meta });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/npx-resolver.d.ts

@@ -0,0 +1,6 @@
+export interface NpxResolution {
+    binPath: string;
+    extraArgs: string[];
+    isJs: boolean;
+}
+export declare function resolveNpxBinary(command: string, args: string[], signal?: AbortSignal): Promise<NpxResolution | null>;