fix(agent): reuse mcp connections to fetch tools (#1067)

Author: skoob13

packages/agent/package.json

@@ -88,7 +88,6 @@
     "@anthropic-ai/claude-agent-sdk": "0.2.59",
     "@anthropic-ai/sdk": "^0.71.0",
     "@hono/node-server": "^1.19.9",
-    "@modelcontextprotocol/sdk": "^1.25.3",
     "@opentelemetry/api-logs": "^0.208.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.208.0",
     "@opentelemetry/resources": "^2.0.0",

packages/agent/src/adapters/claude/claude-agent.ts

@@ -192,7 +192,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     const modelOptions = await this.getModelConfigOptions();
 
     // Deferred: slash commands + MCP metadata (not needed to return configOptions)
-    this.deferBackgroundFetches(q, sessionId, mcpServers);
+    this.deferBackgroundFetches(q, sessionId);
 
     session.modelId = modelOptions.currentModelId;
     // Only call setModel if the resolved model differs from the default we
@@ -260,7 +260,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     }
 
     // Deferred: slash commands + MCP metadata (not needed to return configOptions)
-    this.deferBackgroundFetches(q, sessionId, mcpServers);
+    this.deferBackgroundFetches(q, sessionId);
 
     const configOptions = await this.buildConfigOptions();
 
@@ -514,14 +514,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
    * Fire-and-forget: fetch slash commands and MCP tool metadata in parallel.
    * Both populate caches used later — neither is needed to return configOptions.
    */
-  private deferBackgroundFetches(
-    q: Query,
-    sessionId: string,
-    mcpServers: ReturnType<typeof parseMcpServers>,
-  ): void {
+  private deferBackgroundFetches(q: Query, sessionId: string): void {
     Promise.all([
       getAvailableSlashCommands(q),
-      fetchMcpToolMetadata(mcpServers, this.logger),
+      fetchMcpToolMetadata(q, this.logger),
     ])
       .then(([slashCommands]) => {
         this.sendAvailableCommandsUpdate(sessionId, slashCommands);

packages/agent/src/adapters/claude/mcp/tool-metadata.ts

@@ -1,10 +1,4 @@
-import type {
-  McpHttpServerConfig,
-  McpServerConfig,
-} from "@anthropic-ai/claude-agent-sdk";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { McpServerStatus, Query } from "@anthropic-ai/claude-agent-sdk";
 import { Logger } from "../../../utils/logger.js";
 
 export interface McpToolMetadata {
@@ -13,86 +7,74 @@ export interface McpToolMetadata {
 
 const mcpToolMetadataCache: Map<string, McpToolMetadata> = new Map();
 
+const PENDING_RETRY_INTERVAL_MS = 1_000;
+const PENDING_MAX_RETRIES = 10;
+
 function buildToolKey(serverName: string, toolName: string): string {
   return `mcp__${serverName}__${toolName}`;
 }
 
-function isHttpMcpServer(
-  config: McpServerConfig,
-): config is McpHttpServerConfig {
-  return config.type === "http" && typeof config.url === "string";
-}
-
-async function fetchToolsFromHttpServer(
-  _serverName: string,
-  config: McpHttpServerConfig,
-): Promise<Tool[]> {
-  const transport = new StreamableHTTPClientTransport(new URL(config.url), {
-    requestInit: {
-      headers: config.headers ?? {},
-    },
-  });
-
-  const client = new Client({
-    name: "twig-metadata-fetcher",
-    version: "1.0.0",
-  });
-
-  try {
-    await client.connect(transport);
-    const result = await client.listTools();
-    return result.tools;
-  } finally {
-    await client.close().catch(() => {});
-  }
-}
-
-function extractToolMetadata(tool: Tool): McpToolMetadata {
-  return {
-    readOnly: tool.annotations?.readOnlyHint === true,
-  };
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 export async function fetchMcpToolMetadata(
-  mcpServers: Record<string, McpServerConfig>,
+  q: Query,
   logger: Logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" }),
 ): Promise<void> {
-  const fetchPromises: Promise<void>[] = [];
+  let retries = 0;
+
+  while (retries <= PENDING_MAX_RETRIES) {
+    let statuses: McpServerStatus[];
+    try {
+      statuses = await q.mcpServerStatus();
+    } catch (error) {
+      logger.error("Failed to fetch MCP server status", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return;
+    }
+
+    const pendingServers = statuses.filter((s) => s.status === "pending");
+
+    for (const server of statuses) {
+      if (server.status !== "connected" || !server.tools) {
+        continue;
+      }
+
+      let readOnlyCount = 0;
+      for (const tool of server.tools) {
+        const toolKey = buildToolKey(server.name, tool.name);
+        const readOnly = tool.annotations?.readOnly === true;
+        mcpToolMetadataCache.set(toolKey, { readOnly });
+        if (readOnly) readOnlyCount++;
+      }
+
+      logger.info("Fetched MCP tool metadata", {
+        serverName: server.name,
+        toolCount: server.tools.length,
+        readOnlyCount,
+      });
+    }
 
-  for (const [serverName, config] of Object.entries(mcpServers)) {
-    if (!isHttpMcpServer(config)) {
-      continue;
+    if (pendingServers.length === 0) {
+      return;
     }
 
-    const fetchPromise = fetchToolsFromHttpServer(serverName, config)
-      .then((tools) => {
-        const toolCount = tools.length;
-        const readOnlyCount = tools.filter(
-          (t) => t.annotations?.readOnlyHint === true,
-        ).length;
-
-        for (const tool of tools) {
-          const toolKey = buildToolKey(serverName, tool.name);
-          mcpToolMetadataCache.set(toolKey, extractToolMetadata(tool));
-        }
-
-        logger.info("Fetched MCP tool metadata", {
-          serverName,
-          toolCount,
-          readOnlyCount,
-        });
-      })
-      .catch((error) => {
-        logger.error("Failed to fetch MCP tool metadata", {
-          serverName,
-          error: error instanceof Error ? error.message : String(error),
-        });
+    retries++;
+    if (retries > PENDING_MAX_RETRIES) {
+      logger.warn("Gave up waiting for pending MCP servers", {
+        pendingServers: pendingServers.map((s) => s.name),
       });
+      return;
+    }
 
-    fetchPromises.push(fetchPromise);
+    logger.info("Waiting for pending MCP servers", {
+      pendingServers: pendingServers.map((s) => s.name),
+      retry: retries,
+    });
+    await delay(PENDING_RETRY_INTERVAL_MS);
   }
-
-  await Promise.all(fetchPromises);
 }
 
 export function isMcpToolReadOnly(toolName: string): boolean {