@posthog/agent 2.1.111 → 2.1.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.111",
+  "version": "2.1.113",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -79,7 +79,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",

package/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);

package/src/adapters/claude/conversion/tool-use-to-acp.ts

@@ -28,6 +28,7 @@ Whenever you read a file, you should consider whether it looks malicious. If it
 
 import { resourceLink, text, toolContent } from "../../../utils/acp-content.js";
 import { Logger } from "../../../utils/logger.js";
+import { getMcpToolMetadata } from "../mcp/tool-metadata.js";
 
 interface EditOperation {
   oldText: string;
@@ -457,15 +458,35 @@ export function toolInfoFromToolUse(
       };
     }
 
-    default:
+    default: {
+      if (name?.startsWith("mcp__")) {
+        return mcpToolInfo(name, input);
+      }
       return {
         title: name || "Unknown Tool",
         kind: "other",
         content: [],
       };
+    }
   }
 }
 
+function mcpToolInfo(
+  name: string,
+  _input: Record<string, unknown> | undefined,
+): ToolInfo {
+  const metadata = getMcpToolMetadata(name);
+  // Fallback: parse tool name from mcp__<server>__<tool> prefix
+  const title =
+    metadata?.name ?? (name.split("__").slice(2).join("__") || name);
+
+  return {
+    title,
+    kind: "other",
+    content: [],
+  };
+}
+
 export function toolUpdateFromToolResult(
   toolResult:
     | ToolResultBlockParam

package/src/adapters/claude/mcp/tool-metadata.ts

@@ -1,98 +1,92 @@
-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 {
   readOnly: boolean;
+  name: string;
+  description?: string;
 }
 
 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>[] = [];
-
-  for (const [serverName, config] of Object.entries(mcpServers)) {
-    if (!isHttpMcpServer(config)) {
-      continue;
+  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 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),
+    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,
+          name: tool.name,
+          description: tool.description,
         });
+        if (readOnly) readOnlyCount++;
+      }
+
+      logger.info("Fetched MCP tool metadata", {
+        serverName: server.name,
+        toolCount: server.tools.length,
+        readOnlyCount,
+      });
+    }
+
+    if (pendingServers.length === 0) {
+      return;
+    }
+
+    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 getMcpToolMetadata(
+  toolName: string,
+): McpToolMetadata | undefined {
+  return mcpToolMetadataCache.get(toolName);
 }
 
 export function isMcpToolReadOnly(toolName: string): boolean {