@herbertgao/pi-extensions 2026.8.11 → 2026.8.12

package/node_modules/pi-mcp-adapter/namespace-tools.ts

@@ -0,0 +1,276 @@
+import type { AgentToolResult, ExtensionAPI, ToolInfo } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { McpExtensionState } from "./state.ts";
+import { isServerDisabled, type McpConfig } from "./types.ts";
+import { isServerCacheValid, type MetadataCache } from "./metadata-cache.ts";
+import { executeCall } from "./proxy-modes.ts";
+import { createMcpProxyToolCallRenderer, createMcpToolResultRenderer, resolveMcpToolRenderOptions, type McpToolRenderOptions, type RenderTheme, type McpToolRenderContext } from "./tool-result-renderer.ts";
+export { namespaceProxyName } from "./mcp-references.ts";
+import { hasCallableCachedTargets, isMcpServerDirectlyRegistered, namespaceProxyName, type DirectToolSelectorOverride } from "./mcp-references.ts";
+
+/**
+ * Namespace-proxy tool registration for proxy-only MCP servers.
+ *
+ * For each configured proxy-only server (no `directTools: true` and not a
+ * runtime server forced direct), register exactly one tool named
+ * `mcp__<server>` (matching the harness `_shared/mcp-tools` resolver's
+ * `namespaceProxyName`). Its execute accepts `{tool, args}` and forwards
+ * through the adapter's existing `executeCall`, so it inherits the same
+ * auto-auth, session recovery, output guard, and approval rules as the
+ * single `mcp` proxy tool — without polluting the prompt with one entry
+ * per tool.
+ *
+ * This unblocks `mcp:<server>` references from `tool-groups` and
+ * `slow-mode` against proxy-only servers without flipping `directTools: true`.
+ */
+
+export interface NamespaceProxySpec {
+  serverName: string;
+  toolName: string;
+  description: string;
+}
+
+function namespaceProxyCandidate(
+  config: McpConfig,
+  cache: MetadataCache,
+  envOverride: DirectToolSelectorOverride | null,
+  existingDirectNames: Set<string>,
+  serverName: string,
+): NamespaceProxySpec | null {
+  const definition = config.mcpServers[serverName];
+  if (!definition || isServerDisabled(definition)) return null;
+  if (isMcpServerDirectlyRegistered(definition, config.settings, serverName, envOverride)) return null;
+  const entry = cache.servers?.[serverName];
+  if (!entry || !isServerCacheValid(entry, definition) || !hasCallableCachedTargets(entry, definition)) return null;
+  const toolName = namespaceProxyName(serverName);
+  if (existingDirectNames.has(toolName)) return null;
+  return {
+    serverName,
+    toolName,
+    description:
+      `Namespace-proxy for MCP server "${serverName}". ` +
+      `Forwards \`{tool, args}\` through the adapter's executeCall, so it inherits ` +
+      `the same auth / lifecycle / output-guard rules as the \`mcp\` proxy.`,
+  };
+}
+
+function filterCollidingNamespaceProxyTools(candidates: NamespaceProxySpec[]): NamespaceProxySpec[] {
+  const names = new Map<string, NamespaceProxySpec[]>();
+  for (const spec of candidates) {
+    const colliding = names.get(spec.toolName) ?? [];
+    colliding.push(spec);
+    names.set(spec.toolName, colliding);
+  }
+  return candidates.filter((spec) => {
+    const colliding = names.get(spec.toolName)!;
+    if (colliding.length === 1) return true;
+    if (colliding[0] === spec) {
+      console.warn(`MCP: skipping namespace proxy "${spec.toolName}" because servers ${colliding.map(({ serverName }) => `"${serverName}"`).sort().join(", ")} normalize to the same name`);
+    }
+    return false;
+  });
+}
+
+function resolveNamespaceProxyTools(
+  config: McpConfig | null,
+  cache: MetadataCache | null,
+  envOverride: DirectToolSelectorOverride | null,
+  existingDirectNames: Set<string>,
+  unavailableServers: ReadonlySet<string>,
+): NamespaceProxySpec[] {
+  if (!config || !cache) return [];
+  return filterCollidingNamespaceProxyTools(
+    Object.keys(config.mcpServers)
+      .map((serverName) => namespaceProxyCandidate(config, cache, envOverride, existingDirectNames, serverName))
+      .filter((spec): spec is NamespaceProxySpec => spec !== null),
+  ).filter((spec) => !unavailableServers.has(spec.serverName));
+}
+
+/**
+ * Lazily-required reference to the agent state — passed as a closure so the
+ * namespace proxy tool's execute can call `executeCall` once `state` exists.
+ * `getInitPromise` lets the executor await the first initialization round
+ * the same way `createDirectToolExecutor` does.
+ */
+export type GetState = () => McpExtensionState | null;
+export type GetInitPromise = () => Promise<McpExtensionState> | null;
+export type GetPiTools = () => ToolInfo[];
+
+function namespaceExecute(
+  getState: GetState,
+  getInitPromise: GetInitPromise,
+  serverName: string,
+  getPiTools: GetPiTools,
+) {
+  return async (
+    _toolCallId: string,
+    params: { tool?: string; args?: Record<string, unknown> },
+    signal: AbortSignal | undefined,
+  ): Promise<AgentToolResult<Record<string, unknown>>> => {
+    if (typeof params.tool !== "string" || params.tool.length === 0) {
+      return {
+        content: [{ type: "text" as const, text: `mcp__${serverName} requires a \`tool\` parameter naming the underlying MCP tool.` }],
+        details: { error: "missing_tool", server: serverName },
+      };
+    }
+    let state = getState();
+    if (!state) {
+      const initPromise = getInitPromise();
+      if (initPromise) {
+        try {
+          state = await initPromise;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{ type: "text" as const, text: `MCP initialization failed for ${serverName}: ${message}` }],
+            details: { error: "init_failed", server: serverName, message },
+          };
+        }
+      }
+    }
+    if (!state) {
+      return {
+        content: [{ type: "text" as const, text: `MCP not initialized for ${serverName}.` }],
+        details: { error: "not_initialized", server: serverName },
+      };
+    }
+    return executeCall(
+      state,
+      params.tool,
+      params.args ?? {},
+      serverName,
+      getPiTools,
+      signal,
+      "proxy",
+    );
+  };
+}
+
+const parameters = Type.Object({
+  tool: Type.String({ description: "Underlying MCP tool name to call on this server." }),
+  args: Type.Optional(Type.Object({}, {
+    additionalProperties: true,
+    description: "Arguments for the underlying tool. The exact shape depends on the tool being called; use mcp({ describe: 'server/tool' }) to inspect.",
+  })),
+});
+
+export interface SyncNamespaceProxyToolsInput {
+  config: McpConfig | null;
+  cache: MetadataCache | null;
+  envOverride: DirectToolSelectorOverride | null;
+  existingDirectNames: Set<string>;
+  activeDirectNames?: ReadonlySet<string>;
+  existingNamespaceNames: Set<string>;
+  unavailableServers?: ReadonlySet<string>;
+  pi: ExtensionAPI;
+  getState: GetState;
+  getInitPromise: GetInitPromise;
+  getPiTools: GetPiTools;
+  renderOptions?: McpToolRenderOptions;
+  renderShell?: "self" | "default";
+  renderResult?: unknown;
+}
+
+export interface SyncNamespaceProxyToolsResult {
+  specs: NamespaceProxySpec[];
+  added: string[];
+  updated: string[];
+  deactivated: string[];
+}
+
+function createNamespaceRenderCall(renderOptions: McpToolRenderOptions, serverName: string) {
+  const renderCall = createMcpProxyToolCallRenderer(renderOptions);
+  return (args: { tool?: string; args?: Record<string, unknown> }, theme?: RenderTheme, context?: McpToolRenderContext) => renderCall({
+    ...(args.tool !== undefined ? { tool: args.tool } : {}),
+    ...(args.args !== undefined ? { args: args.args } : {}),
+    server: serverName,
+  }, theme, context);
+}
+
+function registerNamespaceProxyTool(
+  input: SyncNamespaceProxyToolsInput,
+  spec: NamespaceProxySpec,
+  renderOptions: McpToolRenderOptions,
+  renderShell: "self" | "default",
+  renderResult: unknown,
+): void {
+  (input.pi.registerTool as (tool: unknown) => unknown)({
+    name: spec.toolName,
+    label: `MCP: ${spec.serverName}`,
+    description: spec.description,
+    promptSnippet: `MCP namespace proxy for ${spec.serverName}`,
+    parameters,
+    renderShell,
+    renderCall: createNamespaceRenderCall(renderOptions, spec.serverName),
+    renderResult,
+    execute: namespaceExecute(
+      input.getState,
+      input.getInitPromise,
+      spec.serverName,
+      input.getPiTools,
+    ),
+  });
+}
+
+function getActiveToolsForStaleCleanup(pi: ExtensionAPI, staleNames: string[]): string[] | undefined {
+  if (staleNames.length === 0) return undefined;
+  try {
+    return pi.getActiveTools?.();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Action methods cannot be called during extension loading")) return undefined;
+    throw error;
+  }
+}
+
+function deactivateStaleNamespaceTools(input: SyncNamespaceProxyToolsInput, nextNames: Set<string>): string[] {
+  const activeDirectNames = input.activeDirectNames ?? new Set<string>();
+  const staleNames = [...input.existingNamespaceNames].filter(
+    (name) => !nextNames.has(name) && !activeDirectNames.has(name),
+  );
+  const deactivated: string[] = [];
+  const unregisterTool = (input.pi as unknown as {
+    unregisterTool?: (name: string) => boolean;
+  }).unregisterTool;
+  for (const stale of staleNames) {
+    if (unregisterTool?.(stale)) deactivated.push(stale);
+  }
+  const activeTools = getActiveToolsForStaleCleanup(input.pi, staleNames);
+  if (!activeTools) return deactivated;
+
+  const stale = new Set(staleNames);
+  const nextActiveTools = activeTools.filter((name) => !stale.has(name));
+  if (nextActiveTools.length === activeTools.length) return deactivated;
+
+  input.pi.setActiveTools(nextActiveTools);
+  for (const name of staleNames) {
+    if (!deactivated.includes(name)) deactivated.push(name);
+  }
+  return deactivated;
+}
+
+/**
+ * Idempotent sync of namespace-proxy tool registrations.
+ */
+export function syncNamespaceProxyTools(input: SyncNamespaceProxyToolsInput): SyncNamespaceProxyToolsResult {
+  const specs = resolveNamespaceProxyTools(
+    input.config,
+    input.cache,
+    input.envOverride,
+    input.existingDirectNames,
+    input.unavailableServers ?? new Set(),
+  );
+  const nextNames = new Set(specs.map((s) => s.toolName));
+  const result: SyncNamespaceProxyToolsResult = { specs, added: [], updated: [], deactivated: [] };
+  const renderOptions = input.renderOptions ?? resolveMcpToolRenderOptions();
+  const renderShell = input.renderShell ?? (renderOptions.resultRendering === "compact" ? "self" : "default");
+  const renderResult = input.renderResult ?? createMcpToolResultRenderer(renderOptions);
+
+  for (const spec of specs) {
+    registerNamespaceProxyTool(input, spec, renderOptions, renderShell, renderResult);
+    (input.existingNamespaceNames.has(spec.toolName) ? result.updated : result.added).push(spec.toolName);
+  }
+
+  result.deactivated.push(...deactivateStaleNamespaceTools(input, nextNames));
+
+  return result;
+}

package/node_modules/pi-mcp-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.27.0",
+  "version": "2.28.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "types": "./index.ts",
@@ -11,14 +11,24 @@
       "default": "./index.ts"
     },
     "./types": {
-      "types": "./types.ts",
-      "import": "./types.ts",
-      "default": "./types.ts"
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
     },
     "./oauth": {
       "types": "./oauth.ts",
       "import": "./oauth.ts",
       "default": "./oauth.ts"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js",
+      "default": "./dist/config.js"
+    },
+    "./metadata-cache": {
+      "types": "./dist/metadata-cache.d.ts",
+      "import": "./dist/metadata-cache.js",
+      "default": "./dist/metadata-cache.js"
     }
   },
   "license": "MIT",
@@ -30,8 +40,12 @@
     "pi-mcp-adapter": "cli.js"
   },
   "scripts": {
+    "build:public": "tsc -p tsconfig.public.json",
+    "prepack": "npm run build:public",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "node test-runner.mjs",
+    "test:vitest": "vitest run",
+    "test:public-exports": "npm run build:public && node --test public-exports.test.mjs",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:oauth": "PI_MCP_ADAPTER_TEST_AUTH_STORE=memory PI_MCP_ADAPTER_DISABLE_AUTH_CACHE=1 node --import tsx --test --test-concurrency=1 oauth-public-api.test.ts mcp-auth.test.ts mcp-auth-flow.test.ts mcp-callback-server.test.ts mcp-oauth-provider.test.ts",
@@ -76,9 +90,12 @@
     "search-ranking.ts",
     "tool-approval.ts",
     "init.ts",
+    "failure-backoff.ts",
     "ui-session.ts",
     "proxy-modes.ts",
     "direct-tools.ts",
+    "namespace-tools.ts",
+    "mcp-references.ts",
     "commands.ts",
     "prompts.ts",
     "onboarding-state.ts",
@@ -131,7 +148,8 @@
     "skills",
     "README.md",
     "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "dist"
   ],
   "dependencies": {
     "@modelcontextprotocol/client": "2.0.0",

package/node_modules/pi-mcp-adapter/proxy-modes.ts

@@ -1,5 +1,5 @@
 import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent";
-import { UrlElicitationRequiredError, type Client } from "@modelcontextprotocol/client";
+import { UrlElicitationRequiredError, type Client, type Progress, type RequestOptions } from "@modelcontextprotocol/client";
 import { createRequire } from "node:module";
 import type { McpExtensionState } from "./state.ts";
 import type { ToolMetadata, McpContent } from "./types.ts";
@@ -18,6 +18,7 @@ import { authenticate, completeAuthFromInput, startAuth, supportsOAuth } from ".
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.ts";
 import { paginate, rankSuggestions, rankToolMatches, resolveSearchKeywords } from "./search-ranking.ts";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.ts";
+import { isServerInActiveFailureBackoff } from "./failure-backoff.ts";
 
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
 type ClientCallToolResult = Awaited<ReturnType<Client["callTool"]>>;
@@ -37,6 +38,30 @@ type AutoAuthResult =
   | { status: "success" }
   | { status: "failed"; message: string };
 
+let nextProgressInvocationId = 1;
+
+/**
+ * Bridges SDK request-local progress callbacks to the interactive UI notify
+ * path (#437 item 3). The SDK owns `_meta.progressToken` injection when
+ * `onprogress` is set; this never writes the token manually.
+ */
+function withUiProgressBridge(
+  options: RequestOptions | undefined,
+  ui: McpExtensionState["ui"],
+  serverName: string,
+  toolName: string,
+): RequestOptions | undefined {
+  if (!ui) return options;
+  const label = `MCP ${serverName}/${toolName}#${nextProgressInvocationId++}`;
+  return {
+    ...options,
+    onprogress: (progress: Progress) => {
+      const ratio = `${progress.progress}${progress.total === undefined ? "" : `/${progress.total}`}`;
+      ui.notify(progress.message ? `${label}: ${progress.message} (${ratio})` : `${label}: ${ratio}`, "info");
+    },
+  };
+}
+
 function getToolMatches(metadata: ToolMetadata[] | undefined, toolName: string, exact: boolean): ToolMetadata[] {
   if (!metadata) return [];
   if (exact) return metadata.filter(tool => tool.name === toolName);
@@ -53,6 +78,15 @@ function getEnabledToolMatches(state: McpExtensionState, toolName: string, exact
   return matches;
 }
 
+function serverBackoffResult(state: McpExtensionState, mode: string, serverName: string): ProxyToolResult {
+  const failedAgo = getFailureAgeSeconds(state, serverName) ?? 0;
+  const message = `Server "${serverName}" not available (last failed ${failedAgo}s ago)`;
+  return {
+    content: [{ type: "text" as const, text: message }],
+    details: { mode, error: "server_backoff", server: serverName },
+  };
+}
+
 function getSingleToolMatch(metadata: ToolMetadata[] | undefined, toolName: string): ToolMetadata | "ambiguous" | undefined {
   const exactMatches = getToolMatches(metadata, toolName, true);
   const matches = exactMatches.length > 0 ? exactMatches : getToolMatches(metadata, toolName, false);
@@ -284,7 +318,6 @@ export function executeStatus(state: McpExtensionState): ProxyToolResult {
     const disabled = isServerDisabled(definition);
     const connection = disabled ? undefined : state.manager.getConnection(name);
     const metadata = disabled ? undefined : state.toolMetadata.get(name);
-    const toolCount = metadata?.length ?? 0;
     const failedAgo = disabled ? null : getFailureAgeSeconds(state, name);
     let status = disabled ? "disabled" : "not connected";
     if (!disabled && connection?.status === "connected") {
@@ -297,6 +330,8 @@ export function executeStatus(state: McpExtensionState): ProxyToolResult {
       status = "cached";
     }
 
+    const toolCount = status === "failed" ? 0 : metadata?.length ?? 0;
+
     servers.push({ name, status, toolCount, failedAgo, ...(disabled ? { disabled: true } : {}) });
   }
 
@@ -418,7 +453,7 @@ export async function executeAuthComplete(state: McpExtensionState, serverName:
     }
 
     await state.manager.close(serverName);
-    clearFailure(state, serverName);
+    clearFailure(state, serverName, "auth-complete");
     updateStatusBar(state);
     return {
       content: [{ type: "text" as const, text: `OAuth authentication successful for "${serverName}". Run mcp({ connect: "${serverName}" }) to connect with the new token.` }],
@@ -434,15 +469,17 @@ export async function executeAuthComplete(state: McpExtensionState, serverName:
 }
 
 export function executeDescribe(state: McpExtensionState, toolName: string): ProxyToolResult {
-  const exactMatches = getEnabledToolMatches(state, toolName, true);
+  const exactMatches = getEnabledToolMatches(state, toolName, true)
+    .filter((match) => !isServerInActiveFailureBackoff(state, match.server));
   if (exactMatches.length > 1) return ambiguousToolResult("describe", toolName);
-  if (exactMatches.length === 0 && getEnabledToolMatches(state, toolName, false).length > 1) {
+  if (exactMatches.length === 0 && getEnabledToolMatches(state, toolName, false).filter((match) => !isServerInActiveFailureBackoff(state, match.server)).length > 1) {
     return ambiguousToolResult("describe", toolName);
   }
 
   let serverName = exactMatches[0]?.server;
   let toolMeta = exactMatches[0]?.tool;
   let disabledMatch: string | undefined;
+  let failedMatch: string | undefined;
 
   if (!toolMeta) {
     for (const [server, metadata] of state.toolMetadata.entries()) {
@@ -452,6 +489,10 @@ export function executeDescribe(state: McpExtensionState, toolName: string): Pro
         disabledMatch ??= server;
         continue;
       }
+      if (isServerInActiveFailureBackoff(state, server)) {
+        failedMatch ??= server;
+        continue;
+      }
       serverName = server;
       toolMeta = found;
       break;
@@ -460,6 +501,7 @@ export function executeDescribe(state: McpExtensionState, toolName: string): Pro
 
   if (!serverName || !toolMeta) {
     if (disabledMatch) return disabledResult("describe", disabledMatch);
+    if (failedMatch) return serverBackoffResult(state, "describe", failedMatch);
     const suggestions = rankSuggestions(state, toolName, 5);
     const suggestionText = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}` : "";
     return {
@@ -504,6 +546,7 @@ export function executeSearch(
 ): ProxyToolResult {
   const showSchemas = includeSchemas !== false;
   if (server && isServerDisabled(state.config.mcpServers[server])) return disabledResult("search", server);
+  if (server && isServerInActiveFailureBackoff(state, server)) return serverBackoffResult(state, "search", server);
 
   let matches: Array<{ server: string; tool: ToolMetadata; score: number }>;
   if (regex) {
@@ -545,6 +588,7 @@ export function executeSearch(
     for (const [serverName, metadata] of state.toolMetadata.entries()) {
       const definition = state.config.mcpServers[serverName];
       if (isServerDisabled(definition)) continue;
+      if (isServerInActiveFailureBackoff(state, serverName)) continue;
       if (server && serverName !== server) continue;
       for (const tool of metadata) {
         const matched = pattern.test(tool.name) || pattern.test(tool.description)
@@ -644,6 +688,12 @@ export function executeList(state: McpExtensionState, server: string): ProxyTool
   const metadata = state.toolMetadata.get(server);
   const toolNames = metadata?.map(m => m.name) ?? [];
   const connection = state.manager.getConnection(server);
+  if (isServerInActiveFailureBackoff(state, server)) {
+    return {
+      ...serverBackoffResult(state, "list", server),
+      details: { mode: "list", server, tools: [], count: 0, error: "server_backoff" },
+    };
+  }
   const instructions = state.serverInstructions.get(server);
   let instructionsText = "";
   if (instructions) {
@@ -708,6 +758,7 @@ export function executeInstructions(state: McpExtensionState, server: string): P
     };
   }
   if (isServerDisabled(definition)) return disabledResult("instructions", server);
+  if (isServerInActiveFailureBackoff(state, server)) return serverBackoffResult(state, "instructions", server);
 
   const instructions = state.serverInstructions.get(server);
   if (instructions) {
@@ -787,9 +838,9 @@ export async function executeConnect(state: McpExtensionState, serverName: strin
       state.serverInstructions.delete(serverName);
     }
     updateMetadataCache(state, serverName);
-    notifyToolMetadataUpdated(state, serverName, "proxy-connect");
+    const restored = clearFailure(state, serverName, "proxy-connect");
+    if (!restored) notifyToolMetadataUpdated(state, serverName, "proxy-connect");
     markKeepAliveAfterConnect(state, serverName);
-    clearFailure(state, serverName);
     updateStatusBar(state);
     return executeList(state, serverName);
   } catch (error) {
@@ -1100,10 +1151,10 @@ export async function executeCall(
           };
         }
       }
-      clearFailure(state, serverName);
       updateServerMetadata(state, serverName);
       updateMetadataCache(state, serverName);
-      notifyToolMetadataUpdated(state, serverName, "proxy-call-reconnect");
+      const restored = clearFailure(state, serverName, "proxy-call-reconnect");
+      if (!restored) notifyToolMetadataUpdated(state, serverName, "proxy-call-reconnect");
       markKeepAliveAfterConnect(state, serverName);
       updateStatusBar(state);
       const match = getSingleToolMatch(state.toolMetadata.get(serverName), toolName);
@@ -1162,7 +1213,12 @@ export async function executeCall(
   }
 
   let uiSession: UiSessionRuntime | null = null;
-  const requestOptions = state.manager.getRequestOptions?.(serverName, ownedSignal) ?? (ownedSignal ? { signal: ownedSignal } : undefined);
+  const requestOptions = withUiProgressBridge(
+    state.manager.getRequestOptions?.(serverName, ownedSignal) ?? (ownedSignal ? { signal: ownedSignal } : undefined),
+    state.ui,
+    serverName,
+    toolMeta.originalName,
+  );
 
   const outputGuardOptions = resolveMcpOutputGuardOptions(state.config.settings);
   const recoverAuthConnection = async () => {

package/node_modules/pi-mcp-adapter/search-ranking.ts

@@ -1,6 +1,7 @@
 import type { McpExtensionState } from "./state.ts";
 import type { ServerEntry, ToolMetadata, ToolPrefix } from "./types.ts";
 import { getServerPrefix, getToolNameCandidates, isServerDisabled, matchesToolPattern, resolveToolPrefix } from "./types.ts";
+import { isServerInActiveFailureBackoff } from "./failure-backoff.ts";
 
 /**
  * Shortest field token allowed to stem-match a longer query token.
@@ -242,6 +243,7 @@ export function rankToolMatches(
     if (server && serverName !== server) continue;
     const definition = state.config.mcpServers[serverName];
     if (isServerDisabled(definition)) continue;
+    if (isServerInActiveFailureBackoff(state, serverName)) continue;
     for (const prepared of getPreparedTools(state, serverName, metadata, definition, globalPrefix, includeKeywords)) {
       const score = scorePreparedToolMatch(prepared, normalizedQuery, queryTokens);
       if (score !== null) matches.push({ server: serverName, tool: prepared.tool, score });