@aexol/spectral 0.2.3 → 0.2.6

package/dist/mcp/mcp-setup-panel.js

@@ -0,0 +1,485 @@
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+const DEFAULT_THEME = {
+    border: "2",
+    title: "36",
+    selected: "32",
+    hint: "2",
+    success: "32",
+    warning: "33",
+    muted: "2;3",
+};
+function fg(code, text) {
+    return code ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+function wrapText(text, width) {
+    if (width <= 8)
+        return [text];
+    const words = text.split(/\s+/).filter(Boolean);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        const candidate = current ? `${current} ${word}` : word;
+        if (visibleWidth(candidate) <= width) {
+            current = candidate;
+            continue;
+        }
+        if (current)
+            lines.push(current);
+        current = word;
+    }
+    if (current)
+        lines.push(current);
+    return lines.length > 0 ? lines : [""];
+}
+export class McpSetupPanel {
+    discovery;
+    callbacks;
+    options;
+    done;
+    screen;
+    actionCursor = 0;
+    importCursor = 0;
+    pathCursor = 0;
+    selectedImports = new Set();
+    busy = false;
+    notice = null;
+    tui;
+    t = DEFAULT_THEME;
+    inactivityTimeout = null;
+    static INACTIVITY_MS = 60_000;
+    constructor(discovery, callbacks, options, tui, done) {
+        this.discovery = discovery;
+        this.callbacks = callbacks;
+        this.options = options;
+        this.done = done;
+        this.tui = tui;
+        this.screen = options.mode;
+        for (const entry of discovery.imports) {
+            this.selectedImports.add(entry.kind);
+        }
+        this.resetInactivityTimeout();
+    }
+    resetInactivityTimeout() {
+        if (this.inactivityTimeout)
+            clearTimeout(this.inactivityTimeout);
+        this.inactivityTimeout = setTimeout(() => {
+            this.cleanup();
+            this.done();
+        }, McpSetupPanel.INACTIVITY_MS);
+    }
+    cleanup() {
+        if (this.inactivityTimeout) {
+            clearTimeout(this.inactivityTimeout);
+            this.inactivityTimeout = null;
+        }
+    }
+    getActions() {
+        const actions = [];
+        if (this.screen === "empty") {
+            actions.push({ id: "run-setup", label: "Run setup", description: "Inspect detected configs, adopt imports, and scaffold a minimal `.mcp.json`." });
+        }
+        if (this.discovery.imports.length > 0) {
+            actions.push({ id: "adopt-imports", label: "Adopt detected compatibility imports", description: `Choose which host-specific MCP configs Pi should import into its own override file. ${this.discovery.imports.length} source${this.discovery.imports.length === 1 ? "" : "s"} found.` });
+        }
+        actions.push({ id: "view-example", label: "View example `.mcp.json`", description: "Preview a working shared MCP config you can paste or adapt." });
+        if (!this.discovery.sources.some((source) => source.id === "shared-project" && source.exists)) {
+            actions.push({ id: "scaffold-project", label: "Scaffold project `.mcp.json`", description: "Write a minimal project config using the standard shared MCP file path, then reload Pi." });
+        }
+        actions.push({ id: "show-precedence", label: "Explain config precedence", description: "Show the read order and where Pi writes compatibility settings." });
+        if (this.getDetectedPaths().length > 0) {
+            actions.push({ id: "open-paths", label: "Open detected config paths", description: "Browse the actual config files that Pi discovered on this machine." });
+        }
+        if (!this.discovery.repoPrompt.configured && this.discovery.repoPrompt.executablePath && this.discovery.repoPrompt.targetPath && this.discovery.repoPrompt.entry && this.discovery.repoPrompt.serverName) {
+            actions.push({ id: "add-repoprompt", label: "Add RepoPrompt to shared MCP config", description: "Write a standard MCP entry for RepoPrompt to the recommended shared target, then reload MCP in-session." });
+        }
+        actions.push({ id: "close", label: "Close", description: "Exit the onboarding flow." });
+        return actions;
+    }
+    getDetectedPaths() {
+        const paths = [
+            ...this.discovery.sources.filter((source) => source.exists).map((source) => source.path),
+            ...this.discovery.imports.map((entry) => entry.path),
+        ];
+        return [...new Set(paths)];
+    }
+    getSelectedAction() {
+        const actions = this.getActions();
+        return actions[this.actionCursor] ?? null;
+    }
+    handleInput(data) {
+        this.resetInactivityTimeout();
+        if (!this.busy)
+            this.notice = null;
+        if (matchesKey(data, "ctrl+c")) {
+            this.cleanup();
+            this.done();
+            return;
+        }
+        if (matchesKey(data, "escape")) {
+            if (this.screen === "imports" || this.screen === "paths") {
+                this.screen = this.discovery.hasAnyConfig ? "setup" : "empty";
+                this.tui.requestRender();
+                return;
+            }
+            this.cleanup();
+            this.done();
+            return;
+        }
+        if (this.busy)
+            return;
+        if (this.screen === "imports") {
+            this.handleImportsInput(data);
+            return;
+        }
+        if (this.screen === "paths") {
+            this.handlePathsInput(data);
+            return;
+        }
+        const actions = this.getActions();
+        if (matchesKey(data, "up")) {
+            this.actionCursor = Math.max(0, this.actionCursor - 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "down")) {
+            this.actionCursor = Math.min(actions.length - 1, this.actionCursor + 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "return")) {
+            const selected = this.getSelectedAction();
+            if (selected)
+                void this.runAction(selected.id);
+        }
+    }
+    handleImportsInput(data) {
+        const imports = this.discovery.imports;
+        if (matchesKey(data, "up")) {
+            this.importCursor = Math.max(0, this.importCursor - 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "down")) {
+            this.importCursor = Math.min(imports.length - 1, this.importCursor + 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "space")) {
+            const current = imports[this.importCursor];
+            if (!current)
+                return;
+            if (this.selectedImports.has(current.kind)) {
+                this.selectedImports.delete(current.kind);
+            }
+            else {
+                this.selectedImports.add(current.kind);
+            }
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "return")) {
+            void this.applySelectedImports();
+        }
+    }
+    handlePathsInput(data) {
+        const paths = this.getDetectedPaths();
+        if (matchesKey(data, "up")) {
+            this.pathCursor = Math.max(0, this.pathCursor - 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "down")) {
+            this.pathCursor = Math.min(paths.length - 1, this.pathCursor + 1);
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, "return")) {
+            const selected = paths[this.pathCursor];
+            if (!selected)
+                return;
+            void this.runBusy(async () => {
+                await this.callbacks.openPath(selected);
+                this.notice = { text: `Opened ${selected}`, tone: "success" };
+            });
+        }
+    }
+    async runAction(action) {
+        if (action === "run-setup") {
+            this.screen = "setup";
+            this.actionCursor = 0;
+            this.tui.requestRender();
+            return;
+        }
+        if (action === "adopt-imports") {
+            this.screen = "imports";
+            this.importCursor = 0;
+            this.tui.requestRender();
+            return;
+        }
+        if (action === "open-paths") {
+            this.screen = "paths";
+            this.pathCursor = 0;
+            this.tui.requestRender();
+            return;
+        }
+        if (action === "scaffold-project") {
+            await this.runBusy(async () => {
+                const result = await this.callbacks.scaffoldProjectConfig();
+                this.callbacks.markSetupCompleted();
+                this.notice = { text: `Wrote starter config to ${result.path}. Pi will reload after this panel closes.`, tone: "success" };
+            });
+            return;
+        }
+        if (action === "add-repoprompt") {
+            await this.runBusy(async () => {
+                const result = await this.callbacks.addRepoPrompt();
+                this.callbacks.markSetupCompleted();
+                this.notice = { text: `Added ${result.serverName} to ${result.path}. Pi will reload after this panel closes.`, tone: "success" };
+            });
+            return;
+        }
+        if (action === "close") {
+            this.cleanup();
+            this.done();
+            return;
+        }
+        this.notice = { text: "Review the details below. Press Enter on an action with a side effect to apply it.", tone: "muted" };
+        this.tui.requestRender();
+    }
+    async applySelectedImports() {
+        const selected = this.discovery.imports.filter((entry) => this.selectedImports.has(entry.kind)).map((entry) => entry.kind);
+        if (selected.length === 0) {
+            this.notice = { text: "Select at least one compatibility import first.", tone: "warning" };
+            this.tui.requestRender();
+            return;
+        }
+        await this.runBusy(async () => {
+            const result = await this.callbacks.adoptImports(selected);
+            this.callbacks.markSetupCompleted();
+            this.notice = result.added.length > 0
+                ? { text: `Added ${result.added.join(", ")} to ${result.path}. Pi will reload after this panel closes.`, tone: "success" }
+                : { text: `No changes needed in ${result.path}.`, tone: "muted" };
+            this.screen = this.discovery.hasAnyConfig ? "setup" : "empty";
+            this.actionCursor = 0;
+        });
+    }
+    async runBusy(fn) {
+        this.busy = true;
+        this.notice = { text: "Working...", tone: "muted" };
+        this.tui.requestRender();
+        try {
+            await fn();
+        }
+        catch (error) {
+            this.notice = {
+                text: error instanceof Error ? error.message : String(error),
+                tone: "warning",
+            };
+        }
+        finally {
+            this.busy = false;
+            this.tui.requestRender();
+        }
+    }
+    render(width) {
+        const innerW = Math.max(40, width - 2);
+        const lines = [];
+        const border = fg(this.t.border, "─".repeat(innerW));
+        lines.push(`┌${border}┐`);
+        lines.push(this.padLine(fg(this.t.title, "MCP setup"), innerW));
+        lines.push(this.padLine(this.discoverySummaryLine(), innerW));
+        lines.push(this.padLine(fg(this.t.muted, this.secondarySummaryLine()), innerW));
+        lines.push(this.padLine("", innerW));
+        if (this.notice) {
+            const tone = this.notice.tone === "success" ? this.t.success : this.notice.tone === "warning" ? this.t.warning : this.t.hint;
+            for (const line of wrapText(this.notice.text, innerW - 6)) {
+                lines.push(this.padLine(fg(tone, line), innerW));
+            }
+            lines.push(this.padLine("", innerW));
+        }
+        lines.push(`├${border}┤`);
+        if (this.screen === "imports") {
+            lines.push(...this.renderImports(innerW));
+        }
+        else if (this.screen === "paths") {
+            lines.push(...this.renderPaths(innerW));
+        }
+        else {
+            lines.push(...this.renderActions(innerW));
+        }
+        lines.push(`└${border}┘`);
+        return lines;
+    }
+    renderActions(innerW) {
+        const lines = [];
+        const actions = this.getActions();
+        for (let index = 0; index < actions.length; index++) {
+            const action = actions[index];
+            const selected = index === this.actionCursor;
+            const cursor = selected ? fg(this.t.selected, "›") : " ";
+            lines.push(this.padLine(`${cursor} ${truncateToWidth(action.label, innerW - 4)}`, innerW));
+        }
+        lines.push(this.padLine("", innerW));
+        const preview = this.getActionPreview(this.getSelectedAction()?.id ?? "view-example");
+        for (const line of preview) {
+            lines.push(this.padLine(line, innerW));
+        }
+        lines.push(this.padLine("", innerW));
+        lines.push(this.padLine(fg(this.t.muted, "Enter selects, Esc goes back, Ctrl+C closes."), innerW));
+        return lines;
+    }
+    renderImports(innerW) {
+        const lines = [];
+        lines.push(this.padLine("Select compatibility imports. Space toggles, Enter saves, Esc goes back.", innerW));
+        lines.push(this.padLine("", innerW));
+        for (let index = 0; index < this.discovery.imports.length; index++) {
+            const entry = this.discovery.imports[index];
+            const selected = this.selectedImports.has(entry.kind) ? "[x]" : "[ ]";
+            const cursor = index === this.importCursor ? fg(this.t.selected, "›") : " ";
+            lines.push(this.padLine(`${cursor} ${selected} ${entry.kind}  ${entry.path}`, innerW));
+        }
+        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)) {
+            lines.push(this.padLine(line, innerW));
+        }
+        return lines;
+    }
+    renderPaths(innerW) {
+        const lines = [];
+        lines.push(this.padLine("Select a detected config path to open. Enter opens it, Esc goes back.", innerW));
+        lines.push(this.padLine("", innerW));
+        const paths = this.getDetectedPaths();
+        for (let index = 0; index < paths.length; index++) {
+            const cursor = index === this.pathCursor ? fg(this.t.selected, "›") : " ";
+            lines.push(this.padLine(`${cursor} ${paths[index]}`, innerW));
+        }
+        return lines;
+    }
+    discoverySummaryLine() {
+        if (!this.discovery.hasAnyConfig) {
+            return fg(this.t.warning, this.options.onboardingState.setupCompleted
+                ? "No MCP servers are active right now."
+                : "No MCP config is active yet.");
+        }
+        if (this.discovery.totalServerCount === 0 && (this.discovery.imports.length > 0 || !!this.discovery.repoPrompt.executablePath)) {
+            return fg(this.t.warning, "Pi found MCP-related setup options, but none are active in Pi yet.");
+        }
+        const shared = this.discovery.sources.filter((source) => source.kind === "shared" && source.serverCount > 0).length;
+        const piOwned = this.discovery.sources.filter((source) => source.kind === "pi" && source.serverCount > 0).length;
+        return fg(this.t.hint, `Detected ${this.discovery.totalServerCount} configured servers across ${shared} shared and ${piOwned} Pi-owned source${shared + piOwned === 1 ? "" : "s"}.`);
+    }
+    secondarySummaryLine() {
+        if (!this.discovery.hasAnyConfig) {
+            return "Create a shared `.mcp.json`, adopt host imports, or quick-add RepoPrompt from this screen.";
+        }
+        if (this.discovery.totalServerCount === 0 && this.discovery.imports.length > 0) {
+            return `Detected ${this.discovery.imports.length} compatibility import source${this.discovery.imports.length === 1 ? "" : "s"}. Adopt them into Pi or inspect the underlying files.`;
+        }
+        return "Shared MCP files are preferred. Pi-owned files are only for compatibility imports and adapter-specific overrides.";
+    }
+    getActionPreview(action) {
+        switch (action) {
+            case "run-setup":
+                return this.formatPreview([
+                    "Run setup to adopt host-specific imports, inspect detected paths, and scaffold a minimal `.mcp.json` if needed.",
+                ]);
+            case "adopt-imports":
+                return this.formatWritePreview("Compatibility import write preview", this.callbacks.previewImports(this.discovery.imports.filter((entry) => this.selectedImports.has(entry.kind)).map((entry) => entry.kind)), [
+                    `Detected imports: ${this.discovery.imports.map((entry) => `${entry.kind} (${entry.serverCount} servers)`).join(", ")}`,
+                    "Selected imports are written into the Pi agent dir config as Pi-owned compatibility state.",
+                ]);
+            case "view-example":
+                return this.formatPreview([
+                    "Example shared `.mcp.json`:",
+                    "{",
+                    '  "mcpServers": {',
+                    '    "chrome-devtools": {',
+                    '      "command": "npx",',
+                    '      "args": ["-y", "chrome-devtools-mcp@latest"]',
+                    "    }",
+                    "  }",
+                    "}",
+                    "",
+                    "Use Scaffold project `.mcp.json` when you want a safe empty shell instead of a live example server.",
+                ]);
+            case "show-precedence":
+                return this.formatPreview([
+                    "Read order:",
+                    "1. ~/.config/mcp/mcp.json",
+                    "2. <Pi agent dir>/mcp.json",
+                    "3. .mcp.json",
+                    "4. .pi/mcp.json",
+                    "Pi writes compatibility imports and adapter-only overrides to Pi-owned files.",
+                ]);
+            case "open-paths":
+                return this.formatPreview(this.getDetectedPaths().length > 0
+                    ? ["Detected paths:", ...this.getDetectedPaths()]
+                    : ["No config paths were detected."]);
+            case "add-repoprompt": {
+                const repoPrompt = this.discovery.repoPrompt;
+                const preview = this.callbacks.previewRepoPrompt();
+                if (!preview) {
+                    return this.formatPreview(["RepoPrompt is not available to add from this setup screen."]);
+                }
+                return this.formatWritePreview("RepoPrompt write preview", preview, [
+                    `Executable: ${repoPrompt.executablePath ?? "not found"}`,
+                    `Target: ${repoPrompt.targetPath ?? "n/a"}`,
+                    `Server name: ${repoPrompt.serverName ?? "repoprompt"}`,
+                ]);
+            }
+            case "scaffold-project":
+                return this.formatWritePreview("Starter project `.mcp.json` write preview", this.callbacks.previewStarterProject(), [
+                    "This writes a minimal `.mcp.json` in the current project using the shared MCP layout.",
+                    "It intentionally avoids adding a fake placeholder server that would fail on first reload.",
+                ]);
+            case "close":
+            default:
+                return this.formatPreview(["Close the setup flow."]);
+        }
+    }
+    formatPreview(lines) {
+        const preview = [];
+        for (const line of lines) {
+            preview.push(...wrapText(line, 74));
+        }
+        return preview;
+    }
+    formatWritePreview(title, preview, intro = []) {
+        const lines = [];
+        for (const line of intro) {
+            lines.push(...wrapText(line, 74));
+        }
+        if (intro.length > 0)
+            lines.push("");
+        lines.push(...wrapText(`${title}: ${preview.path}`, 74));
+        lines.push(...wrapText(preview.existed ? "Existing file detected. Showing exact before/after diff." : "New file will be created. Showing exact content diff.", 74));
+        lines.push("");
+        const diffLines = preview.diffText.split("\n");
+        const maxLines = 18;
+        const shown = diffLines.slice(0, maxLines);
+        for (const line of shown) {
+            lines.push(...wrapText(line, 74));
+        }
+        if (diffLines.length > maxLines) {
+            lines.push(...wrapText(`… ${diffLines.length - maxLines} more diff line${diffLines.length - maxLines === 1 ? "" : "s"}`, 74));
+        }
+        return lines;
+    }
+    padLine(text, innerW) {
+        const inset = 2;
+        const contentW = Math.max(0, innerW - inset * 2);
+        const fitted = truncateToWidth(text, contentW, "…", true);
+        const plainWidth = visibleWidth(fitted);
+        const padding = Math.max(0, contentW - plainWidth);
+        return `│${" ".repeat(inset)}${fitted}${" ".repeat(padding)}${" ".repeat(inset)}│`;
+    }
+    invalidate() { }
+    dispose() {
+        this.cleanup();
+    }
+}
+export function createMcpSetupPanel(discovery, callbacks, options, tui, done) {
+    return new McpSetupPanel(discovery, callbacks, options, tui, done);
+}

package/dist/mcp/metadata-cache.js

@@ -0,0 +1,158 @@
+// metadata-cache.ts - Persistent MCP metadata cache
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAgentPath } from "./agent-dir.js";
+import { createHash } from "node:crypto";
+import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
+import { formatToolName, isToolExcluded } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath } from "./utils.js";
+const CACHE_VERSION = 1;
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function getMetadataCachePath() {
+    return getAgentPath("mcp-cache.json");
+}
+export function loadMetadataCache() {
+    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) {
+    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, debug — those are runtime behavior settings
+    // that don't change which tools a server exposes.
+    const identity = {
+        command: definition.command,
+        args: definition.args,
+        env: interpolateEnvRecord(definition.env),
+        cwd: resolveConfigPath(definition.cwd),
+        url: definition.url,
+        headers: interpolateEnvRecord(definition.headers),
+        auth: definition.auth,
+        bearerToken: resolveBearerToken(definition),
+        bearerTokenEnv: definition.bearerTokenEnv,
+        exposeResources: definition.exposeResources,
+        excludeTools: definition.excludeTools,
+    };
+    const normalized = stableStringify(identity);
+    return createHash("sha256").update(normalized).digest("hex");
+}
+export function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS) {
+    if (!entry || entry.configHash !== computeServerHash(definition))
+        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 reconstructToolMetadata(serverName, entry, prefix, definition) {
+    const metadata = [];
+    for (const tool of entry.tools ?? []) {
+        if (!tool?.name)
+            continue;
+        if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) {
+            continue;
+        }
+        metadata.push({
+            name: formatToolName(tool.name, serverName, prefix),
+            originalName: tool.name,
+            description: tool.description ?? "",
+            inputSchema: tool.inputSchema,
+            uiResourceUri: tool.uiResourceUri,
+            uiStreamMode: tool.uiStreamMode,
+        });
+    }
+    if (definition.exposeResources !== false) {
+        for (const resource of entry.resources ?? []) {
+            if (!resource?.name || !resource?.uri)
+                continue;
+            const baseName = `get_${resourceNameToToolName(resource.name)}`;
+            if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) {
+                continue;
+            }
+            metadata.push({
+                name: formatToolName(baseName, serverName, prefix),
+                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 => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+        uiResourceUri: tryGetToolUiResourceUri(t),
+        uiStreamMode: extractToolUiStreamMode(t._meta),
+    }));
+}
+export function serializeResources(resources) {
+    return resources
+        .filter(r => r?.name && r?.uri)
+        .map(r => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+    }));
+}
+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;
+    }
+}