@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162214.308bda0

package/src/mcp/mcp-oauth-provider.ts

@@ -38,23 +38,16 @@ import {
 import { openInHostBrowser } from "../util/browser.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
+import {
+  MCP_OAUTH_CREDENTIAL_LEAVES,
+  mcpOAuthCredentialKey,
+  type McpOAuthCredentialTarget,
+  pluginMcpOAuthCredentialPrefix,
+  workspaceMcpOAuthCredentialTarget,
+} from "./credential-target.js";
 
 const log = getLogger("mcp-oauth");
 
-// Credential store key helpers
-function tokensKey(serverId: string): string {
-  return `mcp:${serverId}:tokens`;
-}
-function clientInfoKey(serverId: string): string {
-  return `mcp:${serverId}:client_info`;
-}
-function discoveryKey(serverId: string): string {
-  return `mcp:${serverId}:discovery`;
-}
-function clientBindingKey(serverId: string): string {
-  return `mcp:${serverId}:client_binding`;
-}
-
 /**
  * Logo shown on an authorization server's consent screen.
  *
@@ -91,12 +84,15 @@ export interface McpOAuthProviderOptions {
    * URL to the IPC caller (CLI / web client).
    */
   onAuthorizationUrl?: (url: string) => void;
+  /** Credential identity. Defaults to the legacy workspace server id. */
+  credentialTarget?: McpOAuthCredentialTarget;
 }
 
 export class McpOAuthProvider implements OAuthClientProvider {
   private readonly serverId: string;
   private readonly serverUrl: string;
   private readonly interactive: boolean;
+  private readonly credentialTarget: McpOAuthCredentialTarget;
   private _codeVerifier: string | undefined;
   private _state: string | undefined;
   private _redirectUrl: string | undefined;
@@ -121,6 +117,8 @@ export class McpOAuthProvider implements OAuthClientProvider {
     this.serverUrl = serverUrl;
     this.interactive = interactive;
     this._onAuthorizationUrl = options.onAuthorizationUrl;
+    this.credentialTarget =
+      options.credentialTarget ?? workspaceMcpOAuthCredentialTarget(serverId);
   }
 
   // --- redirectUrl ---
@@ -167,7 +165,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
   // --- Tokens ---
 
   async tokens(): Promise<OAuthTokens | undefined> {
-    const raw = await getSecureKeyAsync(tokensKey(this.serverId));
+    const raw = await getSecureKeyAsync(
+      mcpOAuthCredentialKey(this.credentialTarget, "tokens"),
+    );
     if (!raw) {
       return undefined;
     }
@@ -191,7 +191,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
     // the previous refresh_token when the incoming response omits one.
     let toPersist: OAuthTokens = tokens;
     if (!tokens.refresh_token) {
-      const previous = await getSecureKeyAsync(tokensKey(this.serverId));
+      const previous = await getSecureKeyAsync(
+        mcpOAuthCredentialKey(this.credentialTarget, "tokens"),
+      );
       if (previous) {
         try {
           const parsed = JSON.parse(previous) as OAuthTokens;
@@ -204,7 +206,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
       }
     }
     const ok = await setSecureKeyAsync(
-      tokensKey(this.serverId),
+      mcpOAuthCredentialKey(this.credentialTarget, "tokens"),
       JSON.stringify(toPersist),
     );
     if (!ok) {
@@ -263,7 +265,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
    * fronts the resource.
    */
   async clientInformation(): Promise<OAuthClientInformationMixed | undefined> {
-    const raw = await getSecureKeyAsync(clientInfoKey(this.serverId));
+    const raw = await getSecureKeyAsync(
+      mcpOAuthCredentialKey(this.credentialTarget, "client_info"),
+    );
     if (!raw) {
       return undefined;
     }
@@ -294,7 +298,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
     info: OAuthClientInformationMixed,
   ): Promise<void> {
     const ok = await setSecureKeyAsync(
-      clientInfoKey(this.serverId),
+      mcpOAuthCredentialKey(this.credentialTarget, "client_info"),
       JSON.stringify(info),
     );
     if (!ok) {
@@ -313,7 +317,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
         redirectUri: this._redirectUrl,
       };
       const boundOk = await setSecureKeyAsync(
-        clientBindingKey(this.serverId),
+        mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
         JSON.stringify(binding),
       );
       if (!boundOk) {
@@ -349,7 +353,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
    * redirect check already covers the case this plugin actually changes.
    */
   private async describeStaleBinding(): Promise<string | null> {
-    const raw = await getSecureKeyAsync(clientBindingKey(this.serverId));
+    const raw = await getSecureKeyAsync(
+      mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
+    );
     if (!raw) {
       // Registered before the binding was recorded. Keep it: discarding
       // every pre-existing registration would remake all of them at once.
@@ -410,7 +416,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
   // --- Discovery State ---
 
   async discoveryState(): Promise<OAuthDiscoveryState | undefined> {
-    const raw = await getSecureKeyAsync(discoveryKey(this.serverId));
+    const raw = await getSecureKeyAsync(
+      mcpOAuthCredentialKey(this.credentialTarget, "discovery"),
+    );
     if (!raw) {
       return undefined;
     }
@@ -423,7 +431,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
 
   async saveDiscoveryState(state: OAuthDiscoveryState): Promise<void> {
     const ok = await setSecureKeyAsync(
-      discoveryKey(this.serverId),
+      mcpOAuthCredentialKey(this.credentialTarget, "discovery"),
       JSON.stringify(state),
     );
     if (!ok) {
@@ -498,7 +506,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
     );
 
     if (scope === "all" || scope === "tokens") {
-      const result = await deleteSecureKeyAsync(tokensKey(this.serverId));
+      const result = await deleteSecureKeyAsync(
+        mcpOAuthCredentialKey(this.credentialTarget, "tokens"),
+      );
       if (result === "error") {
         log.warn(
           { serverId: this.serverId },
@@ -512,7 +522,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
       }
     }
     if (scope === "all" || scope === "client") {
-      const result = await deleteSecureKeyAsync(clientInfoKey(this.serverId));
+      const result = await deleteSecureKeyAsync(
+        mcpOAuthCredentialKey(this.credentialTarget, "client_info"),
+      );
       if (result === "error") {
         log.warn(
           { serverId: this.serverId },
@@ -527,14 +539,18 @@ export class McpOAuthProvider implements OAuthClientProvider {
       // The binding describes the registration being dropped, so it goes
       // with it. Leaving it would let a later registration inherit the
       // previous one's issuer and redirect URI.
-      await deleteSecureKeyAsync(clientBindingKey(this.serverId));
+      await deleteSecureKeyAsync(
+        mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
+      );
     }
     if (scope === "all" || scope === "verifier") {
       this._codeVerifier = undefined;
       this._state = undefined;
     }
     if (scope === "all" || scope === "discovery") {
-      const result = await deleteSecureKeyAsync(discoveryKey(this.serverId));
+      const result = await deleteSecureKeyAsync(
+        mcpOAuthCredentialKey(this.credentialTarget, "discovery"),
+      );
       if (result === "error") {
         log.warn(
           { serverId: this.serverId },
@@ -617,8 +633,10 @@ export class McpOAuthProvider implements OAuthClientProvider {
 /**
  * Check whether OAuth tokens exist in the credential store for a server.
  */
-export async function hasMcpOAuthTokens(serverId: string): Promise<boolean> {
-  const raw = await getSecureKeyAsync(tokensKey(serverId));
+export async function hasMcpOAuthTokens(
+  target: McpOAuthCredentialTarget,
+): Promise<boolean> {
+  const raw = await getSecureKeyAsync(mcpOAuthCredentialKey(target, "tokens"));
   return raw != null && raw.length > 0;
 }
 
@@ -631,10 +649,14 @@ export async function deleteMcpOAuthCredentials(
 ): Promise<{ ok: boolean; failedKeys: string[] }> {
   const [tokensResult, clientResult, bindingResult, discoveryResult] =
     await Promise.all([
-      deleteSecureKeyAsync(tokensKey(serverId)),
-      deleteSecureKeyAsync(clientInfoKey(serverId)),
-      deleteSecureKeyAsync(clientBindingKey(serverId)),
-      deleteSecureKeyAsync(discoveryKey(serverId)),
+      ...MCP_OAUTH_CREDENTIAL_LEAVES.map((leaf) =>
+        deleteSecureKeyAsync(
+          mcpOAuthCredentialKey(
+            workspaceMcpOAuthCredentialTarget(serverId),
+            leaf,
+          ),
+        ),
+      ),
     ]);
   const results = [
     { key: "tokens", result: tokensResult },
@@ -660,3 +682,49 @@ export async function deleteMcpOAuthCredentials(
   );
   return { ok, failedKeys };
 }
+
+export interface PluginMcpOAuthCleanupResult {
+  readonly ok: boolean;
+  readonly unreachable: boolean;
+  readonly matchedKeys: string[];
+  readonly failedKeys: string[];
+}
+
+/** Delete every endpoint-scoped MCP OAuth record owned by one plugin. */
+export async function deletePluginMcpOAuthCredentials(
+  pluginName: string,
+): Promise<PluginMcpOAuthCleanupResult> {
+  const { listSecureKeysAsync } = await import("../security/secure-keys.js");
+  const listed = await listSecureKeysAsync();
+  if (listed.unreachable) {
+    return {
+      ok: false,
+      unreachable: true,
+      matchedKeys: [],
+      failedKeys: [],
+    };
+  }
+
+  const prefix = pluginMcpOAuthCredentialPrefix(pluginName);
+  const matchedKeys = listed.accounts.filter((key) => key.startsWith(prefix));
+  const deletionResults = await Promise.all(
+    matchedKeys.map(async (key) => {
+      try {
+        return { key, result: await deleteSecureKeyAsync(key) };
+      } catch {
+        return { key, result: "error" as const };
+      }
+    }),
+  );
+  const failedKeys = deletionResults
+    .filter(({ result }) => result === "error")
+    .map(({ key }) => key);
+  const ok = failedKeys.length === 0;
+  if (!ok) {
+    log.warn(
+      { pluginName, failedKeys },
+      "Some plugin MCP OAuth credentials could not be deleted",
+    );
+  }
+  return { ok, unreachable: false, matchedKeys, failedKeys };
+}

package/src/mcp/spec-schema.ts

@@ -0,0 +1,111 @@
+/**
+ * Agent Plugins 1.0.0 `mcp.json` wire schema and projections onto the
+ * assistant's in-memory `McpTransport` union.
+ *
+ * Workspace `/workspace/mcp.json` and each plugin's root `mcp.json` share
+ * this document shape. Origin (`workspace` vs `plugin`) is resolved from
+ * which file was read, never from a field in the file.
+ */
+
+import { z } from "zod";
+
+import type { McpTransport } from "../config/schemas/mcp.js";
+
+/** Canonical `$schema` value for an Agent Plugins 1.0.0 MCP document. */
+export const AGENT_PLUGINS_MCP_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+
+const SpecStdioServerSchema = z.object({
+  type: z.literal("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional(),
+});
+
+/**
+ * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
+ * default. MCP's current remote transport is Streamable HTTP, so this
+ * host fills omitted `type` and the Claude-style `http` alias as
+ * `streamable-http`. `sse` stays explicit.
+ */
+const SpecHttpServerSchema = z.object({
+  type: z
+    .union([
+      z.literal("streamable-http"),
+      z.literal("sse"),
+      z.literal("http").transform(() => "streamable-http" as const),
+    ])
+    .default("streamable-http"),
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
+export const SpecMcpServerSchema = z.union([
+  SpecStdioServerSchema,
+  SpecHttpServerSchema,
+]);
+
+export const SpecMcpDocumentSchema = z.object({
+  $schema: z.string().optional(),
+  mcpServers: z.record(z.string(), z.unknown()),
+});
+
+export type SpecMcpServer = z.infer<typeof SpecMcpServerSchema>;
+export type SpecMcpDocument = z.infer<typeof SpecMcpDocumentSchema>;
+
+/**
+ * Project one spec-shaped entry onto the assistant's transport union. The
+ * two vocabularies already agree on type names and required fields, so this
+ * is a field copy plus an optional expander for plugin path variables.
+ */
+export function projectSpecServerToTransport(
+  entry: SpecMcpServer,
+  expand?: (value: string) => string,
+): McpTransport {
+  if (entry.type === "stdio") {
+    const map = expand ?? ((value: string) => value);
+    return {
+      type: "stdio",
+      command: entry.command,
+      args: (entry.args ?? []).map(map),
+      ...(entry.env && {
+        env: Object.fromEntries(
+          Object.entries(entry.env).map(([key, value]) => [key, map(value)]),
+        ),
+      }),
+    };
+  }
+  return {
+    type: entry.type,
+    url: entry.url,
+    ...(entry.headers && { headers: entry.headers }),
+  };
+}
+
+/**
+ * Project an in-memory transport onto a spec server entry. Headers are
+ * omitted: workspace secrets live in the credential store, and a write
+ * must not copy them into `mcp.json`.
+ */
+export function projectTransportToSpecServer(
+  transport: McpTransport,
+): Record<string, unknown> {
+  if (transport.type === "stdio") {
+    const entry: Record<string, unknown> = {
+      type: "stdio",
+      command: transport.command,
+    };
+    if (transport.args && transport.args.length > 0) {
+      entry.args = transport.args;
+    }
+    if (transport.env) {
+      entry.env = transport.env;
+    }
+    return entry;
+  }
+  return {
+    type: transport.type,
+    url: transport.url,
+  };
+}

package/src/mcp/startup.ts

@@ -13,13 +13,20 @@
  * further process that starts hosting turns has one call to make.
  */
 
-import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import { invalidateConfigCache } from "../config/loader.js";
 import type { McpConfig } from "../config/schemas/mcp.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
 import { buildEffectiveMcpConfig } from "./effective-config.js";
 import { getMcpServerManager, stopMcpServerManager } from "./manager.js";
+import {
+  EMPTY_MCP_STARTUP_SNAPSHOT,
+  type McpStartupSnapshot,
+} from "./tool-caps.js";
+import { loadWorkspaceMcpConfig } from "./workspace-mcp-config.js";
+
+export type { McpStartupSnapshot } from "./tool-caps.js";
 
 const log = getLogger("mcp-startup");
 
@@ -36,22 +43,29 @@ const log = getLogger("mcp-startup");
  * is a startup step in processes whose other work must not be held hostage to
  * a third-party server being up.
  *
- * @param workspaceMcpConfig The `mcp` block of the assistant config, if any.
- * @returns The number of tools registered across all servers.
+ * @param workspaceMcpConfig The projected workspace MCP config. Callers
+ * that omit it read `/workspace/mcp.json`.
+ * @returns A count snapshot of configured/connected servers and the tools
+ * that reached this process's registry after caps.
  */
 export async function startConfiguredMcpServers(
   workspaceMcpConfig?: McpConfig,
-): Promise<number> {
-  let registered = 0;
+): Promise<McpStartupSnapshot> {
+  let snapshot: McpStartupSnapshot = EMPTY_MCP_STARTUP_SNAPSHOT;
   try {
-    const mcpConfig = buildEffectiveMcpConfig(workspaceMcpConfig);
-    if (Object.keys(mcpConfig.servers).length === 0) {
-      return 0;
+    const mcpConfig = buildEffectiveMcpConfig(
+      workspaceMcpConfig ?? loadWorkspaceMcpConfig(),
+    );
+    const configuredServerCount = Object.keys(mcpConfig.servers).length;
+    snapshot = { ...EMPTY_MCP_STARTUP_SNAPSHOT, configuredServerCount };
+    if (configuredServerCount === 0) {
+      return snapshot;
     }
 
     const manager = getMcpServerManager();
-    const serverToolInfos = await manager.start(mcpConfig);
-    for (const { serverId, serverConfig, tools } of serverToolInfos) {
+    const started = await manager.start(mcpConfig);
+    let registered = 0;
+    for (const { serverId, serverConfig, tools } of started.servers) {
       const mcpTools = createMcpToolsFromServer(
         tools,
         serverId,
@@ -60,16 +74,26 @@ export async function startConfiguredMcpServers(
       );
       registered += registerMcpTools(serverId, mcpTools).length;
     }
+    snapshot = {
+      configuredServerCount: started.configuredServerCount,
+      connectedServerCount: started.connectedServerCount,
+      discoveredToolCount: started.discoveredToolCount,
+      registeredToolCount: registered,
+      droppedToolCount: started.droppedToolCount,
+      truncatedServerIds: started.truncatedServerIds,
+      errorServerCount: started.errorServerCount,
+      needsAuthServerCount: started.needsAuthServerCount,
+    };
   } catch (err) {
     log.error(
-      { err },
+      { err, ...snapshot },
       "MCP server initialization failed, continuing without MCP tools",
     );
-    return registered;
+    return snapshot;
   }
 
-  log.info({ toolCount: registered }, "MCP tools registered");
-  return registered;
+  log.info(snapshot, "MCP tools registered");
+  return snapshot;
 }
 
 /**
@@ -87,9 +111,9 @@ export async function startConfiguredMcpServers(
  * The window between the teardown and the reconnect has no MCP tools
  * registered, so an `mcp__*` call landing inside it fails as an unknown tool.
  *
- * @returns The number of tools registered after the reconnect.
+ * @returns A count snapshot of the tools registered after the reconnect.
  */
-export async function restartConfiguredMcpServers(): Promise<number> {
+export async function restartConfiguredMcpServers(): Promise<McpStartupSnapshot> {
   try {
     await stopMcpServerManager();
   } catch (err) {
@@ -97,5 +121,5 @@ export async function restartConfiguredMcpServers(): Promise<number> {
   }
   unregisterAllMcpTools();
   invalidateConfigCache();
-  return startConfiguredMcpServers(getConfig().mcp);
+  return startConfiguredMcpServers(loadWorkspaceMcpConfig());
 }

package/src/mcp/tool-caps.ts

@@ -0,0 +1,176 @@
+/**
+ * Code-owned MCP tool-count caps and the selection used when they bind.
+ *
+ * Caps live here, not in workspace config: migration 153 strips
+ * `maxTools` / `globalMaxTools` from `config.json`. The numbers are a
+ * context-window budget, not a permission gate. Allowlists and risk
+ * still decide what a turn may call.
+ *
+ * The global cap is applied by a deterministic round-robin across
+ * servers sorted by id. Insertion order must not empty a later server
+ * while earlier ones keep every tool.
+ */
+
+import {
+  MCP_GLOBAL_MAX_TOOLS,
+  MCP_MAX_TOOLS_PER_SERVER,
+} from "../config/schemas/mcp.js";
+
+export interface McpServerToolSet<T> {
+  serverId: string;
+  tools: readonly T[];
+}
+
+export interface McpToolCapDecision {
+  serverId: string;
+  discovered: number;
+  kept: number;
+  droppedByPerServerCap: number;
+  droppedByGlobalCap: number;
+}
+
+export interface McpToolCapResult<T> {
+  servers: Array<{ serverId: string; tools: T[] }>;
+  discoveredToolCount: number;
+  keptToolCount: number;
+  droppedToolCount: number;
+  globalCap: number;
+  perServerCap: number;
+  decisions: McpToolCapDecision[];
+}
+
+export function applyMcpToolCaps<T>(
+  servers: ReadonlyArray<McpServerToolSet<T>>,
+  options?: { globalMax?: number; perServerMax?: number },
+): McpToolCapResult<T> {
+  const globalCap = options?.globalMax ?? MCP_GLOBAL_MAX_TOOLS;
+  const perServerCap = options?.perServerMax ?? MCP_MAX_TOOLS_PER_SERVER;
+  const discoveredToolCount = servers.reduce(
+    (sum, server) => sum + server.tools.length,
+    0,
+  );
+
+  const afterPerServer = servers.map((server) => {
+    const droppedByPerServerCap = Math.max(
+      0,
+      server.tools.length - perServerCap,
+    );
+    return {
+      serverId: server.serverId,
+      tools: server.tools.slice(0, perServerCap),
+      discovered: server.tools.length,
+      droppedByPerServerCap,
+    };
+  });
+
+  const afterPerServerCount = afterPerServer.reduce(
+    (sum, server) => sum + server.tools.length,
+    0,
+  );
+  if (afterPerServerCount <= globalCap) {
+    const decisions = afterPerServer.map((server) => ({
+      serverId: server.serverId,
+      discovered: server.discovered,
+      kept: server.tools.length,
+      droppedByPerServerCap: server.droppedByPerServerCap,
+      droppedByGlobalCap: 0,
+    }));
+    return {
+      servers: afterPerServer.map((server) => ({
+        serverId: server.serverId,
+        tools: [...server.tools],
+      })),
+      discoveredToolCount,
+      keptToolCount: afterPerServerCount,
+      droppedToolCount: discoveredToolCount - afterPerServerCount,
+      globalCap,
+      perServerCap,
+      decisions,
+    };
+  }
+
+  const order = [...afterPerServer].sort((a, b) =>
+    a.serverId.localeCompare(b.serverId),
+  );
+  const selected = new Map<string, T[]>(
+    order.map((server) => [server.serverId, []]),
+  );
+  const cursors = new Map<string, number>(
+    order.map((server) => [server.serverId, 0]),
+  );
+  let kept = 0;
+  let progressed = true;
+  while (kept < globalCap && progressed) {
+    progressed = false;
+    for (const server of order) {
+      if (kept >= globalCap) {
+        break;
+      }
+      const cursor = cursors.get(server.serverId) ?? 0;
+      const tool = server.tools[cursor];
+      if (tool !== undefined) {
+        selected.get(server.serverId)?.push(tool);
+        cursors.set(server.serverId, cursor + 1);
+        kept += 1;
+        progressed = true;
+      }
+    }
+  }
+
+  const decisions = afterPerServer.map((server) => {
+    const keptTools = selected.get(server.serverId) ?? [];
+    return {
+      serverId: server.serverId,
+      discovered: server.discovered,
+      kept: keptTools.length,
+      droppedByPerServerCap: server.droppedByPerServerCap,
+      droppedByGlobalCap: server.tools.length - keptTools.length,
+    };
+  });
+
+  return {
+    servers: afterPerServer.map((server) => ({
+      serverId: server.serverId,
+      tools: [...(selected.get(server.serverId) ?? [])],
+    })),
+    discoveredToolCount,
+    keptToolCount: kept,
+    droppedToolCount: discoveredToolCount - kept,
+    globalCap,
+    perServerCap,
+    decisions,
+  };
+}
+
+export interface McpStartupSnapshot {
+  configuredServerCount: number;
+  connectedServerCount: number;
+  discoveredToolCount: number;
+  registeredToolCount: number;
+  droppedToolCount: number;
+  truncatedServerIds: string[];
+  errorServerCount: number;
+  needsAuthServerCount: number;
+}
+
+export const EMPTY_MCP_STARTUP_SNAPSHOT: McpStartupSnapshot = {
+  configuredServerCount: 0,
+  connectedServerCount: 0,
+  discoveredToolCount: 0,
+  registeredToolCount: 0,
+  droppedToolCount: 0,
+  truncatedServerIds: [],
+  errorServerCount: 0,
+  needsAuthServerCount: 0,
+};
+
+export function truncatedServerIdsFromCaps(
+  decisions: readonly McpToolCapDecision[],
+): string[] {
+  return decisions
+    .filter(
+      (decision) =>
+        decision.droppedByPerServerCap > 0 || decision.droppedByGlobalCap > 0,
+    )
+    .map((decision) => decision.serverId);
+}