@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/dist/mcp-bearer-store.js

@@ -0,0 +1,311 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+const require = createRequire(import.meta.url);
+const BEARER_SECRET_SERVICE = "dm-mcp-adapter.bearer";
+const TEST_AUTH_STORE_ENV = "DM_MCP_ADAPTER_TEST_AUTH_STORE";
+const BEARER_SECRET_CHUNK_SIZE = 1000;
+const BEARER_SECRET_VALUE_LIMIT = 1280;
+let KeyringEntryClass;
+const memoryBearerEntries = new Map;
+let testBearerSecretStoreReadCount = 0;
+
+export class BearerCredentialStoreError extends Error {
+  code = "BEARER_CREDENTIAL_STORE_UNAVAILABLE";
+  operation;
+  constructor(message, operation, cause) {
+    super(message, { cause });
+    this.name = "BearerCredentialStoreError";
+    this.operation = operation;
+  }
+}
+const memoryBearerSecretStore = {
+  read(account) {
+    testBearerSecretStoreReadCount++;
+    return memoryBearerEntries.get(account);
+  },
+  write(account, payload) {
+    memoryBearerEntries.set(account, payload);
+  },
+  remove(account) {
+    memoryBearerEntries.delete(account);
+  }
+};
+const sizeLimitedBearerSecretStore = {
+  read(account) {
+    testBearerSecretStoreReadCount++;
+    return memoryBearerEntries.get(account);
+  },
+  write(account, payload) {
+    if (payload.length > BEARER_SECRET_VALUE_LIMIT) {
+      throw new Error(`Value of 'password encoded as UTF-16' is longer than the platform limit of ${BEARER_SECRET_VALUE_LIMIT * 2} chars`);
+    }
+    memoryBearerEntries.set(account, payload);
+  },
+  remove(account) {
+    memoryBearerEntries.delete(account);
+  }
+};
+const unavailableBearerSecretStore = {
+  read() {
+    testBearerSecretStoreReadCount++;
+    throw new Error("simulated secure credential store unavailable");
+  },
+  write() {
+    throw new Error("simulated secure credential store unavailable");
+  },
+  remove() {
+    throw new Error("simulated secure credential store unavailable");
+  }
+};
+const keyringBearerSecretStore = {
+  read(account) {
+    return getKeyringEntry(account).getPassword() ?? undefined;
+  },
+  write(account, payload) {
+    getKeyringEntry(account).setPassword(payload);
+  },
+  remove(account) {
+    getKeyringEntry(account).deleteCredential();
+  }
+};
+function getBearerSecretStore() {
+  if (process.env[TEST_AUTH_STORE_ENV] === "memory")
+    return memoryBearerSecretStore;
+  if (process.env[TEST_AUTH_STORE_ENV] === "sizelimited")
+    return sizeLimitedBearerSecretStore;
+  if (process.env[TEST_AUTH_STORE_ENV] === "unavailable")
+    return unavailableBearerSecretStore;
+  return keyringBearerSecretStore;
+}
+function getKeyringEntry(account) {
+  try {
+    KeyringEntryClass ??= loadKeyringEntryClass();
+    return new KeyringEntryClass(BEARER_SECRET_SERVICE, account);
+  } catch (error) {
+    throw new Error("Bearer token secure credential storage is unavailable. Configure the OS credential store and retry.", { cause: error });
+  }
+}
+function loadKeyringEntryClass(keyringRequire = require, platform = process.platform, arch = process.arch) {
+  try {
+    return keyringRequire("@napi-rs/keyring").Entry;
+  } catch (loaderError) {
+    try {
+      return loadKeyringNativeBindingFallback(keyringRequire, platform, arch).Entry;
+    } catch (fallbackError) {
+      const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+      throw new Error(`Failed to load @napi-rs/keyring; absolute-path native binding fallback also failed: ${message}`, { cause: loaderError });
+    }
+  }
+}
+function loadKeyringNativeBindingFallback(keyringRequire, platform, arch) {
+  const targets = getKeyringNativeBindingSuffixes(platform, arch).map((suffix) => ({
+    packageName: `@napi-rs/keyring-${suffix}`,
+    bindingFile: `keyring.${suffix}.node`
+  }));
+  let lastError;
+  for (const target of targets) {
+    try {
+      const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
+      return keyringRequire(join(dirname(packageJsonPath), target.bindingFile));
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function getKeyringNativeBindingSuffixes(platform, arch) {
+  if (platform === "darwin") {
+    if (arch === "arm64")
+      return ["darwin-arm64"];
+    if (arch === "x64")
+      return ["darwin-x64"];
+  }
+  if (platform === "win32") {
+    if (arch === "arm64")
+      return ["win32-arm64-msvc"];
+    if (arch === "x64")
+      return ["win32-x64-msvc"];
+    if (arch === "ia32")
+      return ["win32-ia32-msvc"];
+  }
+  if (platform === "linux") {
+    if (arch === "arm64")
+      return ["linux-arm64-gnu", "linux-arm64-musl"];
+    if (arch === "arm")
+      return ["linux-arm-gnueabihf"];
+    if (arch === "riscv64")
+      return ["linux-riscv64-gnu"];
+    if (arch === "x64")
+      return ["linux-x64-gnu", "linux-x64-musl"];
+  }
+  if (platform === "freebsd" && arch === "x64")
+    return ["freebsd-x64"];
+  return [];
+}
+function getBearerAccount(serverName) {
+  if (typeof serverName !== "string") {
+    throw new Error(`Invalid MCP server name: ${JSON.stringify(serverName)}`);
+  }
+  return `sha256-${createHash("sha256").update(serverName, "utf8").digest("hex")}`;
+}
+function parseBearerPayload(serverName, payload) {
+  const parsed = parseStoredBearerJson(serverName, payload);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Stored bearer token record for ${serverName} has invalid shape`);
+  }
+  const record = parsed;
+  if (typeof record.token !== "string" || typeof record.serverUrl !== "string") {
+    throw new Error(`Stored bearer token record for ${serverName} has invalid shape`);
+  }
+  return { token: record.token, serverUrl: record.serverUrl };
+}
+function parseStoredBearerJson(serverName, payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    throw new Error(`Failed to parse stored bearer token record for ${serverName}`);
+  }
+}
+function isBearerChunkManifest(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const manifest = value;
+  return manifest.__piMcpAdapterBearerChunked === 1 && typeof manifest.chunkCount === "number" && Number.isInteger(manifest.chunkCount) && manifest.chunkCount > 0 && typeof manifest.chunkDigest === "string" && /^[a-f0-9]{16}$/.test(manifest.chunkDigest);
+}
+function readManifest(serverName, payload) {
+  const parsed = parseStoredBearerJson(serverName, payload);
+  return isBearerChunkManifest(parsed) ? parsed : undefined;
+}
+function chunkAccount(account, manifest, index) {
+  return `${account}.chunk.${manifest.chunkDigest}.${index}`;
+}
+function chunkAccounts(account, manifest) {
+  return Array.from({ length: manifest.chunkCount }, (_, index) => chunkAccount(account, manifest, index));
+}
+function createManifest(payload) {
+  return {
+    __piMcpAdapterBearerChunked: 1,
+    chunkCount: Math.ceil(payload.length / BEARER_SECRET_CHUNK_SIZE),
+    chunkDigest: createHash("sha256").update(payload, "utf8").digest("hex").slice(0, 16)
+  };
+}
+function readExistingManifest(store, serverName, account) {
+  try {
+    const payload = store.read(account);
+    return payload === undefined ? undefined : readManifest(serverName, payload);
+  } catch {
+    return;
+  }
+}
+function removeChunks(store, account, manifest) {
+  if (!manifest)
+    return;
+  for (const accountName of chunkAccounts(account, manifest))
+    store.remove(accountName);
+}
+function tryRemoveChunks(store, account, manifest) {
+  try {
+    removeChunks(store, account, manifest);
+  } catch {}
+}
+function readBearerRecordFromStore(store, serverName) {
+  const account = getBearerAccount(serverName);
+  let payload;
+  try {
+    payload = store.read(account);
+  } catch (error) {
+    throw new BearerCredentialStoreError(`Failed to read bearer token for ${serverName} from the OS secure credential store`, "read", error);
+  }
+  if (payload === undefined)
+    return;
+  try {
+    const manifest = readManifest(serverName, payload);
+    const recordPayload = manifest ? chunkAccounts(account, manifest).map((chunkName) => {
+      const chunk = store.read(chunkName);
+      if (chunk === undefined)
+        throw new Error(`Missing bearer token chunk for ${serverName}`);
+      return chunk;
+    }).join("") : payload;
+    return parseBearerPayload(serverName, recordPayload);
+  } catch (error) {
+    throw new BearerCredentialStoreError(`Failed to read bearer token for ${serverName} from the OS secure credential store`, "read", error);
+  }
+}
+function writeBearerRecordToStore(store, serverName, record) {
+  const account = getBearerAccount(serverName);
+  const payload = JSON.stringify(record);
+  const previousManifest = readExistingManifest(store, serverName, account);
+  const manifest = payload.length > BEARER_SECRET_CHUNK_SIZE ? createManifest(payload) : undefined;
+  try {
+    if (manifest) {
+      for (let index = 0;index < manifest.chunkCount; index++) {
+        store.write(chunkAccount(account, manifest, index), payload.slice(index * BEARER_SECRET_CHUNK_SIZE, (index + 1) * BEARER_SECRET_CHUNK_SIZE));
+      }
+      store.write(account, JSON.stringify(manifest));
+    } else {
+      store.write(account, payload);
+    }
+    if (previousManifest?.chunkDigest !== manifest?.chunkDigest) {
+      tryRemoveChunks(store, account, previousManifest);
+    }
+  } catch (error) {
+    if (previousManifest?.chunkDigest !== manifest?.chunkDigest) {
+      tryRemoveChunks(store, account, manifest);
+    }
+    throw new BearerCredentialStoreError(`Failed to write bearer token for ${serverName} to the OS secure credential store`, "write", error);
+  }
+}
+function removeBearerRecordFromStore(store, serverName) {
+  const account = getBearerAccount(serverName);
+  try {
+    const payload = store.read(account);
+    const manifest = payload === undefined ? undefined : readManifest(serverName, payload);
+    removeChunks(store, account, manifest);
+    store.remove(account);
+  } catch (error) {
+    throw new BearerCredentialStoreError(`Failed to remove bearer token for ${serverName} from the OS secure credential store`, "remove", error);
+  }
+}
+export function getBearerTokenForUrl(serverName, serverUrl) {
+  const record = readBearerRecordFromStore(getBearerSecretStore(), serverName);
+  if (!record)
+    return;
+  return record.serverUrl === serverUrl ? record.token : undefined;
+}
+export function saveBearerTokenForUrl(serverName, token, serverUrl) {
+  writeBearerRecordToStore(getBearerSecretStore(), serverName, { token, serverUrl });
+}
+export function removeBearerToken(serverName) {
+  removeBearerRecordFromStore(getBearerSecretStore(), serverName);
+}
+export function inspectBearerTokenForUrl(serverName, serverUrl) {
+  try {
+    const record = readBearerRecordFromStore(getBearerSecretStore(), serverName);
+    if (!record)
+      return { status: "missing" };
+    if (record.serverUrl !== serverUrl)
+      return { status: "url-mismatch" };
+    return { status: "present" };
+  } catch (error) {
+    if (!(error instanceof BearerCredentialStoreError))
+      throw error;
+    return { status: "unavailable", message: "Bearer token secure credential store unavailable. Configure or unlock the OS credential store and retry." };
+  }
+}
+export function resetTestBearerTokenStore() {
+  memoryBearerEntries.clear();
+  testBearerSecretStoreReadCount = 0;
+}
+export function getTestBearerTokenStoreEntries() {
+  return [...memoryBearerEntries.entries()];
+}
+export function removeTestBearerTokenStoreEntry(account) {
+  memoryBearerEntries.delete(account);
+}
+export function setTestBearerTokenStoreEntry(account, payload) {
+  memoryBearerEntries.set(account, payload);
+}
+export function getTestBearerTokenStoreReadCount() {
+  return testBearerSecretStoreReadCount;
+}

package/extensions/dm-mcp-adapter/dist/metadata-cache.js

@@ -0,0 +1,285 @@
+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 "./ui-app-bridge-helpers.js";
+import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { extractToolUiStreamMode, interpolateEnvRecord, interpolateEnvVars, 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 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 {}
+  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, environment = process.env) {
+  const identity = {
+    command: definition.command,
+    args: definition.args,
+    socket: resolveConfigPath(definition.socket, environment),
+    env: interpolateEnvRecord(definition.env, environment),
+    cwd: resolveConfigPath(definition.cwd, environment),
+    url: resolveServerUrl(definition, environment),
+    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, definition, maxAgeMs = CACHE_MAX_AGE_MS, environment = process.env) {
+  let configHash;
+  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) {
+  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, configuredServers, cache, sharedSelectorCandidateIndex) {
+  const metadata = [];
+  const seenNames = new Set;
+  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);
+    if (seenNames.has(name)) {
+      continue;
+    }
+    seenNames.add(name);
+    metadata.push({
+      name,
+      originalName: tool.name,
+      description: tool.description ?? "",
+      ...tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {},
+      ...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);
+      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 createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix) {
+  const candidates = new Set;
+  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) {
+  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 } : {},
+      ...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;
+  }
+}