@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-mcp-adapter/dist/session-approvals.js

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { logger } from "./logger.js";
+import { stableStringify } from "./utils.js";
+export const MCP_APPROVAL_CUSTOM_TYPE = "mcp-approval-v1";
+const TOOL_APPROVAL_KEYS = [
+  "version",
+  "kind",
+  "decision",
+  "serverName",
+  "originalToolName",
+  "definitionHash",
+  "argsHash"
+];
+const IFRAME_APPROVAL_KEYS = ["version", "kind", "decision", "serverName"];
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+export function computeToolArgumentsHash(args) {
+  return createHash("sha256").update(stableStringify(args ?? {})).digest("hex");
+}
+export function computeToolDefinitionHash(toolMeta) {
+  return createHash("sha256").update(stableStringify({
+    originalName: toolMeta.originalName,
+    inputSchema: toolMeta.inputSchema ?? null,
+    resourceUri: toolMeta.resourceUri ?? null,
+    uiResourceUri: toolMeta.uiResourceUri ?? null
+  })).digest("hex");
+}
+export function makeToolApprovalKey(serverName, originalToolName, definitionHash, argsHash) {
+  return `${serverName}\x00${originalToolName}\x00${definitionHash}\x00${argsHash}`;
+}
+export function getToolApprovalIdentity(serverName, toolMeta, args) {
+  const definitionHash = computeToolDefinitionHash(toolMeta);
+  const argsHash = computeToolArgumentsHash(args);
+  return {
+    definitionHash,
+    argsHash,
+    cacheKey: makeToolApprovalKey(serverName, toolMeta.originalName, definitionHash, argsHash)
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+  const actualKeys = Object.keys(value);
+  return actualKeys.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isSha256(value) {
+  return typeof value === "string" && SHA256_HEX.test(value);
+}
+function isSessionApprovalEntry(value) {
+  if (!isRecord(value) || value.version !== 1 || !isNonEmptyString(value.serverName))
+    return false;
+  if (value.kind === "tool") {
+    return hasExactKeys(value, TOOL_APPROVAL_KEYS) && value.decision === "allow_for_session" && isNonEmptyString(value.originalToolName) && isSha256(value.definitionHash) && isSha256(value.argsHash);
+  }
+  if (value.kind === "iframe") {
+    return hasExactKeys(value, IFRAME_APPROVAL_KEYS) && (value.decision === "allow" || value.decision === "deny");
+  }
+  return false;
+}
+function isApprovalCustomEntry(entry) {
+  return isRecord(entry) && entry.type === "custom" && entry.customType === MCP_APPROVAL_CUSTOM_TYPE;
+}
+export function createSessionApprovalWriter(appendEntry, canAppend = undefined) {
+  return (record) => {
+    if (canAppend && !canAppend())
+      return;
+    try {
+      appendEntry(MCP_APPROVAL_CUSTOM_TYPE, record);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      logger.debug(`MCP: failed to persist session approval: ${detail}`);
+    }
+  };
+}
+export function rememberToolApproval(state, serverName, toolMeta, args) {
+  const { definitionHash, argsHash, cacheKey } = getToolApprovalIdentity(serverName, toolMeta, args);
+  const approvedToolCalls = state.approvedToolCalls ??= new Map;
+  if (approvedToolCalls.has(cacheKey))
+    return;
+  approvedToolCalls.set(cacheKey, true);
+  const record = {
+    version: 1,
+    kind: "tool",
+    decision: "allow_for_session",
+    serverName,
+    originalToolName: toolMeta.originalName,
+    definitionHash,
+    argsHash
+  };
+  try {
+    state.persistSessionApproval?.(record);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    logger.debug(`MCP: session approval persistence callback failed: ${detail}`);
+  }
+}
+export function getServerApprovalIdentity(state, serverName) {
+  if (!Object.hasOwn(state.config.mcpServers, serverName))
+    return;
+  const definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return;
+  return {
+    definition,
+    hash: createHash("sha256").update(stableStringify(definition)).digest("hex")
+  };
+}
+export function restoreSessionApprovalState(state, branchEntries) {
+  const approvedToolCalls = state.approvedToolCalls ??= new Map;
+  approvedToolCalls.clear();
+  state.approvedServers = new Map;
+  state.consentManager.clear();
+  for (const entry of branchEntries) {
+    if (!isApprovalCustomEntry(entry))
+      continue;
+    if (!isSessionApprovalEntry(entry.data))
+      continue;
+    if (entry.data.kind === "tool") {
+      approvedToolCalls.set(makeToolApprovalKey(entry.data.serverName, entry.data.originalToolName, entry.data.definitionHash, entry.data.argsHash), true);
+      continue;
+    }
+    state.consentManager.restoreDecision(entry.data.serverName, entry.data.decision === "allow");
+  }
+}

package/extensions/dm-mcp-adapter/dist/session-recovery.js

@@ -0,0 +1,83 @@
+import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
+import { logger } from "./logger.js";
+import { throwIfAborted } from "./abort.js";
+import { isServerDisabled } from "./types.js";
+import { supportsOAuth } from "./mcp-auth-flow.js";
+import { invalidateAuthEntryCache } from "./mcp-auth.js";
+const CONNECTION_CLOSED_PROTOCOL_CODE = -32000;
+const SERVER_NOT_INITIALIZED_MCP_MESSAGES = new Set([
+  "Server not initialized",
+  "Bad Request: Server not initialized"
+]);
+export function isTerminatedSession(err, hadSessionId) {
+  if (!hadSessionId)
+    return false;
+  if (err instanceof SdkHttpError) {
+    return err.status === 404 || err.status === 400 && /"code"\s*:\s*-32000/.test(err.message) && /"message"\s*:\s*"Bad Request: Server not initialized"/.test(err.message);
+  }
+  return err instanceof ProtocolError && err.code === CONNECTION_CLOSED_PROTOCOL_CODE && SERVER_NOT_INITIALIZED_MCP_MESSAGES.has(err.message);
+}
+function hasSessionId(connection) {
+  const transport = connection.transport;
+  return transport?.sessionId != null;
+}
+
+export class SessionRecoveryAuthRequiredError extends Error {
+  serverName;
+  authMessage;
+  constructor(serverName, authMessage) {
+    super(authMessage ?? `MCP server "${serverName}" requires OAuth authentication after reconnect.`);
+    this.serverName = serverName;
+    this.authMessage = authMessage;
+    this.name = "SessionRecoveryAuthRequiredError";
+  }
+}
+export async function withSessionRecovery(deps, serverName, fn) {
+  if (isServerDisabled(deps.config.mcpServers[serverName])) {
+    throw new Error(`MCP server "${serverName}" is disabled`);
+  }
+  const connection = deps.manager.getConnection(serverName);
+  if (!connection) {
+    throw new Error(`Server "${serverName}" is not connected`);
+  }
+  const hadSessionId = hasSessionId(connection);
+  try {
+    return await fn(connection);
+  } catch (err) {
+    const definition = deps.config.mcpServers[serverName];
+    const unauthorized = err instanceof UnauthorizedError || err instanceof SdkHttpError && err.status === 401;
+    if (definition && supportsOAuth(definition) && unauthorized) {
+      invalidateAuthEntryCache(serverName);
+    }
+    if (!isTerminatedSession(err, hadSessionId) && !(unauthorized && typeof definition?.auth === "object")) {
+      throw err;
+    }
+    if (!definition) {
+      throw err;
+    }
+    throwIfAborted(deps.signal);
+    logger.debug(`MCP session for "${serverName}" expired; reconnecting`, {
+      server: serverName
+    });
+    let freshConnection = deps.signal ? await deps.manager.reconnect(serverName, definition, connection, deps.signal) : await deps.manager.reconnect(serverName, definition, connection);
+    throwIfAborted(deps.signal);
+    if (freshConnection.status === "needs-auth") {
+      freshConnection = await deps.onNeedsAuth?.(serverName) ?? freshConnection;
+      throwIfAborted(deps.signal);
+    }
+    if (freshConnection.status === "needs-auth") {
+      throw new SessionRecoveryAuthRequiredError(serverName);
+    }
+    if (freshConnection.status !== "connected") {
+      throw err;
+    }
+    try {
+      deps.manager.publishMetadataChanged(serverName, freshConnection, "session-reconnect");
+    } catch (publicationError) {
+      const message = publicationError instanceof Error ? publicationError.message : String(publicationError);
+      logger.debug(`MCP metadata publication after reconnect failed for "${serverName}": ${message}`);
+    }
+    throwIfAborted(deps.signal);
+    return fn(freshConnection);
+  }
+}

package/extensions/dm-mcp-adapter/dist/state.js

@@ -0,0 +1 @@
+export {};

package/extensions/dm-mcp-adapter/dist/ts-shape.js

@@ -0,0 +1,157 @@
+const UNSUPPORTED_KEYWORDS = ["if", "then", "else", "allOf", "not", "patternProperties", "additionalProperties"];
+export function renderTsShape(inputSchema) {
+  try {
+    if (!isSchema(inputSchema))
+      return null;
+    const definitions = new Map;
+    for (const key of ["$defs", "definitions"]) {
+      const rawDefinitions = inputSchema[key];
+      if (rawDefinitions === undefined)
+        continue;
+      if (!isSchema(rawDefinitions))
+        return null;
+      for (const [name, definition] of Object.entries(rawDefinitions)) {
+        if (!isSchema(definition))
+          return null;
+        definitions.set(`${key}/${decodePointerToken(name)}`, definition);
+      }
+    }
+    const aliases = new Map;
+    const usedAliases = new Set;
+    let aliasIndex = 0;
+    const aliasFor = (definitionKey) => {
+      let alias = aliases.get(definitionKey);
+      if (alias)
+        return alias;
+      const name = definitionKey.slice(definitionKey.indexOf("/") + 1);
+      alias = /^[A-Za-z_$][\w$]*$/.test(name) && !usedAliases.has(name) ? name : `Definition${++aliasIndex}`;
+      while (usedAliases.has(alias))
+        alias = `Definition${++aliasIndex}`;
+      aliases.set(definitionKey, alias);
+      usedAliases.add(alias);
+      return alias;
+    };
+    const render = (schema) => {
+      if (!isSchema(schema) || hasUnsupportedKeyword(schema))
+        return null;
+      if ("$ref" in schema) {
+        if (typeof schema.$ref !== "string")
+          return null;
+        const match = schema.$ref.match(/^#\/(\$defs|definitions)\/([^/]+)$/);
+        if (!match)
+          return null;
+        const definitionGroup = match[1];
+        const definitionName = match[2];
+        if (definitionGroup === undefined || definitionName === undefined)
+          return null;
+        const definitionKey = `${definitionGroup}/${decodePointerToken(definitionName)}`;
+        if (!definitions.has(definitionKey))
+          return null;
+        return aliasFor(definitionKey);
+      }
+      if (Array.isArray(schema.enum)) {
+        const values = schema.enum.map(renderLiteral);
+        return values.every((value) => value !== null) ? values.join(" | ") : null;
+      }
+      if (Object.hasOwn(schema, "const"))
+        return renderLiteral(schema.const);
+      if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+        const variants = schema.anyOf ?? schema.oneOf;
+        if (variants.length === 0)
+          return null;
+        const rendered = variants.map(render);
+        return rendered.every((value) => value !== null) ? rendered.join(" | ") : null;
+      }
+      if (schema.type === "object" || schema.properties !== undefined) {
+        if (schema.properties === undefined)
+          return "{}";
+        if (!isSchema(schema.properties))
+          return null;
+        const required = new Set(Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : []);
+        const properties = [];
+        for (const [name, property] of Object.entries(schema.properties)) {
+          const rendered = render(property);
+          if (rendered === null)
+            return null;
+          properties.push(`${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${rendered};`);
+        }
+        return properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`;
+      }
+      if (schema.type === "array") {
+        if (schema.items === undefined)
+          return "unknown[]";
+        const item = render(schema.items);
+        return item === null ? null : `${needsParentheses(item) ? `(${item})` : item}[]`;
+      }
+      if (Array.isArray(schema.type)) {
+        const types = schema.type.map(renderType);
+        return types.every((type) => type !== null) ? types.join(" | ") : null;
+      }
+      if (typeof schema.type === "string")
+        return renderType(schema.type);
+      return "unknown";
+    };
+    const root = render(inputSchema);
+    if (root === null)
+      return null;
+    const definitionsText = [];
+    for (const [key, alias] of aliases) {
+      const definition = definitions.get(key);
+      if (!definition)
+        return null;
+      const rendered = render(definition);
+      if (rendered === null)
+        return null;
+      definitionsText.push(`type ${alias} = ${rendered};`);
+    }
+    return definitionsText.length > 0 ? `${definitionsText.join(`
+`)}
+
+${root}` : root;
+  } catch {
+    return null;
+  }
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasUnsupportedKeyword(schema) {
+  return UNSUPPORTED_KEYWORDS.some((keyword) => {
+    if (!Object.hasOwn(schema, keyword))
+      return false;
+    return keyword !== "additionalProperties" || schema.additionalProperties !== false;
+  });
+}
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function renderType(type) {
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object":
+      return "{}";
+    case "array":
+      return "unknown[]";
+    default:
+      return null;
+  }
+}
+function renderLiteral(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+}
+export function formatPropertyName(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function needsParentheses(type) {
+  return type.includes(" | ");
+}

package/extensions/dm-mcp-adapter/dist/types.js

@@ -0,0 +1,286 @@
+import { createHash } from "node:crypto";
+export const MCP_STATUS_EVENT = "dm-mcp-adapter/status/v1";
+export const MCP_STATUS_SNAPSHOT_VERSION = 1;
+export { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_RESULT_PATCH_METHOD, SERVER_STREAM_RESULT_PATCH_METHOD, UI_STREAM_STRUCTURED_CONTENT_KEY, uiStreamModeSchema, visualizationStreamPhaseSchema, visualizationStreamFrameTypeSchema, visualizationStreamStatusSchema, uiStreamHostContextSchema, visualizationStreamEnvelopeSchema, uiStreamCallToolResultSchema, uiStreamResultPatchNotificationSchema, serverStreamResultPatchNotificationSchema, getUiStreamHostContext, getVisualizationStreamEnvelope } from "./ui-stream-types.js";
+export function extractUiPromptText(params) {
+  if (params.type === "prompt" || params.prompt) {
+    const prompt = params.prompt ?? String(params.message ?? "");
+    return prompt || undefined;
+  }
+  if (params.role === "user" && Array.isArray(params.content)) {
+    const text = params.content.map((block) => block && typeof block === "object" && ("text" in block) ? String(block.text ?? "") : "").filter(Boolean).join(`
+
+`);
+    return text || undefined;
+  }
+  return;
+}
+export function parseUiPromptHandoff(prompt) {
+  const newlineIndex = prompt.indexOf(`
+`);
+  if (newlineIndex <= 0) {
+    return;
+  }
+  const intent = prompt.slice(0, newlineIndex).trim();
+  const payloadText = prompt.slice(newlineIndex + 1).trim();
+  if (!intent || !payloadText) {
+    return;
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(intent)) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(payloadText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    return {
+      intent,
+      params: parsed,
+      raw: prompt
+    };
+  } catch {
+    return;
+  }
+}
+export function createUiModelContextUpdate(params, maxChars = 12000) {
+  const payload = Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined));
+  if (Object.keys(payload).length === 0)
+    return;
+  const serialized = JSON.stringify(payload);
+  if (serialized.length <= maxChars) {
+    return { payload, summary: serialized, truncated: false };
+  }
+  return {
+    summary: `${serialized.slice(0, Math.max(0, maxChars - 1))}…`,
+    truncated: true
+  };
+}
+export function isServerDisabled(definition) {
+  return definition?.disabled === true;
+}
+const ENCODED_SERVER_NAMESPACE_MARKER = "_mcpns_";
+const MAX_SERVER_NAMESPACE_LENGTH = 59;
+export function formatServerNamespace(serverName) {
+  const normalized = serverName.replace(/-/g, "_");
+  const safe = /^[A-Za-z0-9_]*$/.test(normalized) && !normalized.startsWith(ENCODED_SERVER_NAMESPACE_MARKER);
+  const body = safe ? normalized : encodeServerNamespace(normalized);
+  const namespace = safe ? body : `${ENCODED_SERVER_NAMESPACE_MARKER}${body}`;
+  if (namespace.length <= MAX_SERVER_NAMESPACE_LENGTH)
+    return namespace;
+  const digest = createHash("sha256").update(namespace, "utf8").digest("hex").slice(0, 16);
+  const hashPrefix = `${ENCODED_SERVER_NAMESPACE_MARKER}_h_`;
+  const head = body.slice(0, MAX_SERVER_NAMESPACE_LENGTH - hashPrefix.length - digest.length - 1);
+  return `${hashPrefix}${head}_${digest}`;
+}
+function encodeServerNamespace(name) {
+  return Array.from(name, (character) => {
+    if (character === "_")
+      return "__";
+    return /^[A-Za-z0-9]$/.test(character) ? character : `_${character.codePointAt(0).toString(16)}_`;
+  }).join("");
+}
+export const MCP_TOOL_APPROVAL_REQUEST_EVENT = "dm-mcp-adapter:tool-approval-request";
+function sanitizeServerPrefix(serverName, preserveProviderValid = true) {
+  const validCharacters = preserveProviderValid ? /^[A-Za-z0-9_-]$/ : /^[A-Za-z0-9]$/;
+  return Array.from(serverName, (char) => validCharacters.test(char) ? char : `_${char.codePointAt(0).toString(16)}_`).join("");
+}
+export function getServerPrefix(serverName, mode) {
+  if (mode === "none")
+    return "";
+  if (mode === "short") {
+    let short = sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""));
+    if (!short)
+      short = "mcp";
+    return short;
+  }
+  if (mode === "mcp")
+    return `mcp__${sanitizeServerPrefix(serverName)}`;
+  return sanitizeServerPrefix(serverName);
+}
+export function formatToolName(toolName, serverName, prefix) {
+  const p = getServerPrefix(serverName, prefix);
+  const sanitized = toolName.replace(/\./g, "_");
+  if (p && sanitized.startsWith(`${p}_`) && sanitized.length > p.length + 1) {
+    return sanitized;
+  }
+  return p ? `${p}_${sanitized}` : sanitized;
+}
+export function resolveToolPrefix(definition, globalPrefix) {
+  return definition?.toolPrefix ?? globalPrefix ?? "server";
+}
+export function resolveUniqueNameOwnership(entries, getName) {
+  const owners = new Map;
+  for (const entry of entries) {
+    const name = getName(entry);
+    const named = owners.get(name) ?? [];
+    named.push(entry);
+    owners.set(name, named);
+  }
+  const collisions = new Map([...owners].filter(([, named]) => named.length > 1));
+  return {
+    unique: entries.filter((entry) => !collisions.has(getName(entry))),
+    collisions
+  };
+}
+export function resolveServerFromToolName(toolName, serverNames, prefix) {
+  if (prefix === "none")
+    return;
+  const candidates = [];
+  for (const name of serverNames) {
+    const p = getServerPrefix(name, prefix);
+    if (p && toolName.startsWith(p + "_"))
+      candidates.push({ name, prefix: p });
+  }
+  if (candidates.length === 0)
+    return;
+  candidates.sort((a, b) => b.prefix.length - a.prefix.length);
+  const best = candidates[0];
+  if (candidates.some((c) => c.prefix === best.prefix && c.name !== best.name)) {
+    return;
+  }
+  return best?.name;
+}
+export function sanitizePromptName(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
+  if (!cleaned)
+    return "prompt";
+  return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+}
+export function formatPromptCommandName(promptName, serverName, prefix) {
+  const serverPart = getServerPrefix(serverName, prefix) || sanitizeServerPrefix(serverName) || "server";
+  return `mcp__${serverPart}__${sanitizePromptName(promptName)}`;
+}
+function getLegacyServerPrefix(serverName, mode) {
+  if (mode === "none")
+    return "";
+  if (mode === "short")
+    return sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""), false) || "mcp";
+  if (mode === "mcp")
+    return `mcp__${sanitizeServerPrefix(serverName, false)}`;
+  return sanitizeServerPrefix(serverName, false);
+}
+function formatLegacyToolName(toolName, serverName, prefix) {
+  const serverPrefix = getLegacyServerPrefix(serverName, prefix);
+  const sanitizedToolName = toolName.replace(/[.-]/g, "_");
+  return serverPrefix ? `${serverPrefix}_${sanitizedToolName}` : sanitizedToolName;
+}
+export function getToolNameCandidates(toolName, serverName, prefix, includeLegacy = true) {
+  const candidates = new Set([
+    toolName,
+    formatToolName(toolName, serverName, prefix),
+    formatToolName(toolName, serverName, "server"),
+    formatToolName(toolName, serverName, "short"),
+    formatToolName(toolName, serverName, "mcp")
+  ]);
+  if (includeLegacy) {
+    const legacyToolName = toolName.replace(/-/g, "_");
+    candidates.add(legacyToolName);
+    candidates.add(formatToolName(legacyToolName, serverName, prefix));
+    candidates.add(formatToolName(legacyToolName, serverName, "server"));
+    candidates.add(formatToolName(legacyToolName, serverName, "short"));
+    candidates.add(formatToolName(legacyToolName, serverName, "mcp"));
+    candidates.add(formatLegacyToolName(toolName, serverName, prefix));
+    candidates.add(formatLegacyToolName(toolName, serverName, "server"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "short"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "mcp"));
+    candidates.add(formatToolName(toolName, serverName, prefix).replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "server").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "short").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "mcp").replace(/-/g, "_"));
+  }
+  return candidates;
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+export function createToolSelectorCandidateIndex(allCurrentCandidates, additionalCurrentCandidatesByToolName) {
+  return {
+    allCurrentCandidates,
+    matchingCountByPattern: new Map,
+    matcherByPattern: new Map,
+    ...additionalCurrentCandidatesByToolName ? { additionalCurrentCandidatesByToolName } : {}
+  };
+}
+export function matchesToolPattern(candidates, patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0)
+    return false;
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string")
+      continue;
+    if (!pattern.includes("*") && !pattern.includes("?") && candidates.has(pattern)) {
+      return true;
+    }
+    if ((pattern.includes("*") || pattern.includes("?")) && [...candidates].some((candidate) => globToRegExp(pattern).test(candidate))) {
+      return true;
+    }
+  }
+  return false;
+}
+function indexHasOtherCurrentMatch(index, toolName, currentCandidates, pattern) {
+  const additionalCandidates = index.additionalCurrentCandidatesByToolName?.get(toolName);
+  const hasCandidate = (candidate) => index.allCurrentCandidates.has(candidate) || additionalCandidates?.has(candidate) === true;
+  const isGlob = pattern.includes("*") || pattern.includes("?");
+  if (!isGlob) {
+    return hasCandidate(pattern) && !currentCandidates.has(pattern);
+  }
+  let matcher = index.matcherByPattern.get(pattern);
+  if (!matcher) {
+    matcher = globToRegExp(pattern);
+    index.matcherByPattern.set(pattern, matcher);
+  }
+  let matchingCount = index.matchingCountByPattern.get(pattern);
+  if (matchingCount === undefined) {
+    matchingCount = 0;
+    for (const candidate of index.allCurrentCandidates) {
+      if (matcher.test(candidate))
+        matchingCount++;
+    }
+    index.matchingCountByPattern.set(pattern, matchingCount);
+  }
+  let totalMatchingCount = matchingCount;
+  if (additionalCandidates) {
+    for (const candidate of additionalCandidates) {
+      if (!index.allCurrentCandidates.has(candidate) && matcher.test(candidate))
+        totalMatchingCount++;
+    }
+  }
+  if (totalMatchingCount === 0)
+    return false;
+  let currentMatchingCount = 0;
+  for (const candidate of currentCandidates) {
+    if (hasCandidate(candidate) && matcher.test(candidate))
+      currentMatchingCount++;
+  }
+  return totalMatchingCount > currentMatchingCount;
+}
+function matchesToolSelector(toolName, serverName, prefix, patterns, otherCurrentCandidates) {
+  if (!Array.isArray(patterns) || patterns.length === 0)
+    return false;
+  const currentCandidates = getToolNameCandidates(toolName, serverName, prefix, false);
+  if (matchesToolPattern(currentCandidates, patterns))
+    return true;
+  if (!otherCurrentCandidates)
+    return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), patterns);
+  const legacyCandidates = getToolNameCandidates(toolName, serverName, prefix);
+  for (const candidate of currentCandidates)
+    legacyCandidates.delete(candidate);
+  return patterns.some((pattern) => {
+    if (typeof pattern !== "string" || !matchesToolPattern(legacyCandidates, [pattern]))
+      return false;
+    const hasCollision = otherCurrentCandidates instanceof Set ? matchesToolPattern(otherCurrentCandidates, [pattern]) : indexHasOtherCurrentMatch(otherCurrentCandidates, toolName, currentCandidates, pattern);
+    return !hasCollision;
+  });
+}
+export function isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates) {
+  if (!Array.isArray(includeTools) || includeTools.length === 0)
+    return true;
+  return matchesToolSelector(toolName, serverName, prefix, includeTools, otherCurrentCandidates);
+}
+export function isToolExcluded(toolName, serverName, prefix, excludeTools, otherCurrentCandidates) {
+  return matchesToolSelector(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
+}
+export function isToolAllowed(toolName, serverName, prefix, includeTools, excludeTools, otherCurrentCandidates) {
+  return isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates) && !isToolExcluded(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
+}