@herbertgao/pi-extensions 2026.9.16 → 2026.9.18

package/node_modules/pi-mcp-adapter/mcp-trace.ts

@@ -1,306 +0,0 @@
-import { appendFile, mkdir, writeFile } from "node:fs/promises";
-import { Buffer } from "node:buffer";
-import { dirname, isAbsolute, resolve } from "node:path";
-import type { Transport } from "@modelcontextprotocol/client";
-import type { JSONRPCMessage, MessageExtraInfo } from "@modelcontextprotocol/client";
-
-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;
-
-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>;
-}
-
-function boundedPositiveInteger(value: number | undefined, fallback: number): number {
-  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: string, maxLength = 160): string {
-  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: JSONRPCMessage): McpTraceMessageKind {
-  if ("method" in message) return "id" in message ? "request" : "notification";
-  return "response";
-}
-
-function traceId(value: unknown): string | number | null | undefined {
-  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: JSONRPCMessage): number | undefined {
-  try {
-    return Buffer.byteLength(JSON.stringify(message), "utf8");
-  } catch {
-    return undefined;
-  }
-}
-
-export function createMcpTraceEvent(
-  direction: McpTraceDirection,
-  server: string,
-  transport: McpTraceTransport,
-  message: JSONRPCMessage,
-  status: "sent" | "received" | "error",
-  options?: { relatedRequestId?: unknown; durationMs?: number },
-): McpTraceEvent {
-  const kind = messageKind(message);
-  const bytes = messageBytes(message);
-  const event: McpTraceEvent = {
-    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 {
-  private readonly maxBytes: number;
-  private readonly maxEvents: number;
-  private readonly append: NonNullable<McpTraceWriterOptions["appendFile"]>;
-  private readonly resetFile: NonNullable<McpTraceWriterOptions["writeFile"]>;
-  private readonly makeDirectory: NonNullable<McpTraceWriterOptions["mkdir"]>;
-  private bytesWritten = 0;
-  private eventsWritten = 0;
-  private queue = Promise.resolve();
-  private disabled = false;
-  private initializationFailed = false;
-  private readonly fileReady: Promise<void>;
-
-  constructor(private readonly options: McpTraceWriterOptions) {
-    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(() => {
-        // Tracing must never change MCP request/response behavior.
-        this.initializationFailed = true;
-        this.disabled = true;
-      });
-  }
-
-  get filePath(): string {
-    return this.options.filePath;
-  }
-
-  get isDisabled(): boolean {
-    return this.disabled;
-  }
-
-  get stats(): { bytes: number; events: number } {
-    return { bytes: this.bytesWritten, events: this.eventsWritten };
-  }
-
-  write(event: McpTraceEvent): void {
-    if (this.disabled || this.eventsWritten >= this.maxEvents) return;
-    let line: string;
-    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(() => {
-      // Tracing must never change MCP request/response behavior.
-      this.disabled = true;
-    });
-  }
-
-  async flush(): Promise<void> {
-    await this.fileReady;
-    await this.queue;
-  }
-}
-
-export function createMcpTraceWriter(
-  sessionCwd: string | undefined,
-  settings: McpTraceSettings = {},
-  randomSuffix = Math.random().toString(36).slice(2, 10),
-): McpTraceWriter {
-  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", "mcp-traces", `mcp-${timestamp}-${randomSuffix}.jsonl`);
-  return new McpTraceWriter({
-    filePath,
-    ...(settings.maxBytes !== undefined ? { maxBytes: settings.maxBytes } : {}),
-    ...(settings.maxEvents !== undefined ? { maxEvents: settings.maxEvents } : {}),
-  });
-}
-
-export interface McpTraceObserver {
-  record(event: McpTraceEvent): void;
-}
-
-export function isMcpTraceEnabled(
-  definition: { trace?: boolean },
-  settings?: McpTraceSettings,
-): boolean {
-  return definition.trace ?? settings?.enabled === true;
-}
-
-/**
- * Compose the SDK's transport callbacks in place instead of replacing the
- * transport object. SDK v2 detects its base stdio transport before connect so
- * it can run `server/discover` on a disposable sibling process; returning a
- * wrapper hides that identity and makes tracing change negotiation behavior.
- */
-export function wrapTransportWithMcpTrace(
-  transport: Transport,
-  server: string,
-  transportKind: McpTraceTransport,
-  observer: McpTraceObserver,
-): Transport {
-  let messageHandler = transport.onmessage;
-  let tracedMessageHandler: Transport["onmessage"];
-  const originalSend = transport.send;
-  const record = (event: McpTraceEvent): void => {
-    try {
-      observer.record(event);
-    } catch {
-      // An observer failure must never alter SDK transport behavior.
-    }
-  };
-
-  try {
-    Object.defineProperty(transport, "onmessage", {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return tracedMessageHandler;
-      },
-      set(handler: Transport["onmessage"]) {
-        messageHandler = handler;
-        tracedMessageHandler = handler
-          ? ((message: JSONRPCMessage, extra?: MessageExtraInfo) => {
-              record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
-              handler(message, extra);
-            })
-          : undefined;
-      },
-    });
-    transport.onmessage = messageHandler;
-  } catch {
-    // Some future transport may make onmessage non-configurable. Keep tracing
-    // best-effort rather than changing connection behavior.
-  }
-
-  transport.send = async (message: JSONRPCMessage, options?: Parameters<Transport["send"]>[1]) => {
-    const started = performance.now();
-    const messages = Array.isArray(message) ? message : [message];
-    try {
-      await originalSend.call(transport, 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;
-    }
-  };
-
-  return transport;
-}
-
-export function traceTransportKind(definition: { command?: string; url?: string; socket?: string }, transport: Transport): McpTraceTransport {
-  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/node_modules/pi-mcp-adapter/metadata-cache.ts

@@ -1,362 +0,0 @@
-// 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.ts";
-import { createHash } from "node:crypto";
-import { isBuiltInAgentPlugin } from "./agent-plugin-provenance.ts";
-import { getToolUiResourceUri } from "./ui-app-bridge-helpers.ts";
-import type {
-  CachedPrompt,
-  CachedResource,
-  CachedTool,
-  McpConfig,
-  McpTool,
-  McpResource,
-  McpPrompt,
-  McpPromptArgument,
-  MetadataCache,
-  ServerCacheEntry,
-  ServerEntry,
-  ToolMetadata,
-  PromptMetadata,
-} from "./types.ts";
-import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix, resolveUniqueNameOwnership, type ToolPrefix, type ToolSelectorCandidateIndex } from "./types.ts";
-import { resourceNameToToolName } from "./resource-tools.ts";
-import {
-  extractToolUiStreamMode,
-  interpolateEnvRecord,
-  interpolateEnvVars,
-  resolveBearerToken,
-  resolveConfigPath,
-  resolveServerUrl,
-  stableStringify,
-} from "./utils.ts";
-import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
-
-const CACHE_VERSION = 1;
-const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-
-export type { CachedPrompt, CachedResource, CachedTool, MetadataCache, ServerCacheEntry } from "./types.ts";
-
-export function getMetadataCachePath(): string {
-  return getAgentPath("mcp-cache.json");
-}
-
-export function loadMetadataCache(): MetadataCache | 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 as MetadataCache;
-  } catch {
-    return null;
-  }
-}
-
-export function saveMetadataCache(cache: MetadataCache): void {
-  const cachePath = getMetadataCachePath();
-  const dir = dirname(cachePath);
-  mkdirSync(dir, { recursive: true });
-
-  let merged: MetadataCache = { version: CACHE_VERSION, servers: {} };
-  try {
-    if (existsSync(cachePath)) {
-      const existing = JSON.parse(readFileSync(cachePath, "utf-8")) as MetadataCache;
-      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), "utf-8");
-  renameSync(tmpPath, cachePath);
-}
-
-export function computeServerHash(definition: ServerEntry, environment: NodeJS.ProcessEnv = process.env): string {
-  // 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: Record<string, unknown> = {
-    command: resolveConfigPath(definition.command, environment),
-    args: definition.args,
-    socket: resolveConfigPath(definition.socket, environment),
-    env: isBuiltInAgentPlugin(definition, "env") ? definition.env : interpolateEnvRecord(definition.env, environment),
-    cwd: isBuiltInAgentPlugin(definition, "cwd") ? definition.cwd : resolveConfigPath(definition.cwd, environment),
-    url: resolveServerUrl(definition, environment),
-    headers: isBuiltInAgentPlugin(definition, "headers") ? definition.headers : interpolateEnvRecord(definition.headers, environment),
-    requestHeadersCommand: definition.requestHeadersCommand
-      ? {
-          command: interpolateEnvVars(definition.requestHeadersCommand.command, environment),
-          args: definition.requestHeadersCommand.args?.map((argument) => interpolateEnvVars(argument, environment)),
-          env: interpolateEnvRecord(definition.requestHeadersCommand.env, environment),
-          timeoutMs: definition.requestHeadersCommand.timeoutMs,
-        }
-      : undefined,
-    auth: definition.auth,
-    protocolVersion: definition.protocolVersion,
-    bearerToken: resolveBearerToken(definition, environment),
-    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: ServerCacheEntry,
-  definition: ServerEntry,
-  maxAgeMs: number = CACHE_MAX_AGE_MS,
-  environment: NodeJS.ProcessEnv = process.env,
-): boolean {
-  let configHash: string;
-  try {
-    configHash = computeServerHash(definition, environment);
-  } catch {
-    return false;
-  }
-  if (!entry || entry.configHash !== configHash) return false;
-  if (!entry.cachedAt || typeof entry.cachedAt !== "number") return false;
-  const declaredTtlMs = entry.ttlMs;
-  if (typeof declaredTtlMs === "number" && Number.isSafeInteger(declaredTtlMs) && declaredTtlMs >= 0) {
-    if (declaredTtlMs === 0) return false;
-    const ageMs = Date.now() - entry.cachedAt;
-    const effectiveMaxAge = maxAgeMs > 0 ? Math.min(maxAgeMs, declaredTtlMs) : declaredTtlMs;
-    return ageMs < effectiveMaxAge;
-  }
-  if (maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs) return false;
-  return true;
-}
-
-export function parseDirectToolSelectors(selectors: string[]): {
-  servers: Set<string>;
-  tools: Map<string, Set<string>>;
-} {
-  const servers = new Set<string>();
-  const tools = new Map<string, Set<string>>();
-
-  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<string>();
-        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: McpConfig,
-  cache: MetadataCache | null,
-  envOverride?: string[],
-): string[] {
-  const missing: string[] = [];
-  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: string,
-  entry: ServerCacheEntry,
-  prefix: ToolPrefix,
-  definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">,
-  configuredServers?: Record<string, ServerEntry>,
-  cache?: MetadataCache,
-  sharedSelectorCandidateIndex?: ToolSelectorCandidateIndex,
-): ToolMetadata[] {
-  const metadata: ToolMetadata[] = [];
-  const effectivePrefix = resolveToolPrefix(definition, prefix);
-  const hasToolFilters =
-    (Array.isArray(definition.includeTools) && definition.includeTools.length > 0) ||
-    (Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0);
-  const selectorCandidateIndex = hasToolFilters
-    ? sharedSelectorCandidateIndex ?? (configuredServers && cache
-      ? createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix)
-      : undefined)
-    : undefined;
-
-  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, selectorCandidateIndex)) {
-      continue;
-    }
-
-    const name = formatToolName(tool.name, serverName, effectivePrefix);
-    metadata.push({
-      name,
-      originalName: tool.name,
-      description: tool.description ?? "",
-      ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
-      ...(tool.outputSchema !== undefined ? { outputSchema: tool.outputSchema } : {}),
-      ...(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, selectorCandidateIndex)) {
-        continue;
-      }
-
-      const name = formatToolName(baseName, serverName, effectivePrefix);
-      metadata.push({
-        name,
-        originalName: baseName,
-        description: resource.description ?? `Read resource: ${resource.uri}`,
-        resourceUri: resource.uri,
-      });
-    }
-  }
-
-  return resolveUniqueNameOwnership(metadata, (tool) => tool.name).unique;
-}
-
-export function createCachedToolSelectorCandidateIndex(
-  configuredServers: Record<string, ServerEntry>,
-  cache: MetadataCache,
-  prefix: ToolPrefix,
-): ToolSelectorCandidateIndex {
-  const candidates = new Set<string>();
-  for (const [serverName, definition] of Object.entries(configuredServers)) {
-    const entry = cache.servers[serverName];
-    if (!entry || !isServerCacheValid(entry, definition) || isServerDisabled(definition)) continue;
-    const effectivePrefix = resolveToolPrefix(definition, prefix);
-    for (const tool of entry.tools ?? []) {
-      if (!isUiToolVisibleToModel(tool.uiVisibility)) continue;
-      for (const candidate of getToolNameCandidates(tool.name, serverName, effectivePrefix, false)) candidates.add(candidate);
-    }
-    if (definition.exposeResources !== false) {
-      for (const resource of entry.resources ?? []) {
-        const baseName = `read_${resourceNameToToolName(resource.name)}`;
-        for (const candidate of getToolNameCandidates(baseName, serverName, effectivePrefix, false)) candidates.add(candidate);
-      }
-    }
-  }
-  return createToolSelectorCandidateIndex(candidates);
-}
-
-export function serializeTools(tools: McpTool[]): CachedTool[] {
-  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.outputSchema !== undefined ? { outputSchema: t.outputSchema } : {}),
-        ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
-        ...(uiVisibility !== undefined ? { uiVisibility } : {}),
-        ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
-      };
-    });
-}
-
-export function serializeResources(resources: McpResource[]): CachedResource[] {
-  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: McpPrompt[]): CachedPrompt[] {
-  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: string,
-  prompts: ReadonlyArray<McpPrompt | CachedPrompt>,
-  prefix: ToolPrefix,
-  definition?: Pick<ServerEntry, "toolPrefix">,
-): PromptMetadata[] {
-  const effectivePrefix = resolveToolPrefix(definition, prefix);
-  return (prompts ?? []).filter(prompt => prompt?.name).map(prompt => {
-    const args: McpPromptArgument[] = 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 tryGetToolUiResourceUri(tool: McpTool): string | undefined {
-  try {
-    return getToolUiResourceUri({ _meta: tool._meta });
-  } catch {
-    return undefined;
-  }
-}