@posthog/agent 2.1.111 → 2.1.113

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   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: {
@@ -992,7 +992,6 @@ var package_default = {
     "@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",
@@ -1603,6 +1602,75 @@ var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
   return { continue: true };
 };
 
+// src/adapters/claude/mcp/tool-metadata.ts
+var mcpToolMetadataCache = /* @__PURE__ */ new Map();
+var PENDING_RETRY_INTERVAL_MS = 1e3;
+var PENDING_MAX_RETRIES = 10;
+function buildToolKey(serverName, toolName) {
+  return `mcp__${serverName}__${toolName}`;
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function fetchMcpToolMetadata(q, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
+  let retries = 0;
+  while (retries <= PENDING_MAX_RETRIES) {
+    let statuses;
+    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,
+          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;
+    }
+    logger.info("Waiting for pending MCP servers", {
+      pendingServers: pendingServers.map((s) => s.name),
+      retry: retries
+    });
+    await delay(PENDING_RETRY_INTERVAL_MS);
+  }
+}
+function getMcpToolMetadata(toolName) {
+  return mcpToolMetadataCache.get(toolName);
+}
+function isMcpToolReadOnly(toolName) {
+  const metadata = mcpToolMetadataCache.get(toolName);
+  return metadata?.readOnly === true;
+}
+
 // src/adapters/claude/conversion/tool-use-to-acp.ts
 var SYSTEM_REMINDER = `
 
@@ -1933,14 +2001,27 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
 ${output}\`\`\``).build()
       };
     }
-    default:
+    default: {
+      if (name?.startsWith("mcp__")) {
+        return mcpToolInfo(name, input);
+      }
       return {
         title: name || "Unknown Tool",
         kind: "other",
         content: []
       };
+    }
   }
 }
+function mcpToolInfo(name, _input) {
+  const metadata = getMcpToolMetadata(name);
+  const title = metadata?.name ?? (name.split("__").slice(2).join("__") || name);
+  return {
+    title,
+    kind: "other",
+    content: []
+  };
+}
 function toolUpdateFromToolResult(toolResult, toolUse) {
   switch (toolUse?.name) {
     case "Read":
@@ -2476,75 +2557,6 @@ async function handleUserAssistantMessage(message, context) {
   return {};
 }
 
-// src/adapters/claude/mcp/tool-metadata.ts
-var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-var mcpToolMetadataCache = /* @__PURE__ */ new Map();
-function buildToolKey(serverName, toolName) {
-  return `mcp__${serverName}__${toolName}`;
-}
-function isHttpMcpServer(config) {
-  return config.type === "http" && typeof config.url === "string";
-}
-async function fetchToolsFromHttpServer(_serverName, config) {
-  const transport = new import_streamableHttp.StreamableHTTPClientTransport(new URL(config.url), {
-    requestInit: {
-      headers: config.headers ?? {}
-    }
-  });
-  const client = new import_client.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) {
-  return {
-    readOnly: tool.annotations?.readOnlyHint === true
-  };
-}
-async function fetchMcpToolMetadata(mcpServers, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
-  const fetchPromises = [];
-  for (const [serverName, config] of Object.entries(mcpServers)) {
-    if (!isHttpMcpServer(config)) {
-      continue;
-    }
-    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)
-      });
-    });
-    fetchPromises.push(fetchPromise);
-  }
-  await Promise.all(fetchPromises);
-}
-function isMcpToolReadOnly(toolName) {
-  const metadata = mcpToolMetadataCache.get(toolName);
-  return metadata?.readOnly === true;
-}
-
 // src/adapters/claude/plan/utils.ts
 var os = __toESM(require("os"), 1);
 var path = __toESM(require("path"), 1);
@@ -3411,7 +3423,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       });
     }
     const modelOptions = await this.getModelConfigOptions();
-    this.deferBackgroundFetches(q, sessionId, mcpServers);
+    this.deferBackgroundFetches(q, sessionId);
     session.modelId = modelOptions.currentModelId;
     const resolvedSdkModel = toSdkModelId(modelOptions.currentModelId);
     if (resolvedSdkModel !== DEFAULT_MODEL) {
@@ -3456,7 +3468,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (validation.result === "timeout") {
       throw new Error("Session validation timed out");
     }
-    this.deferBackgroundFetches(q, sessionId, mcpServers);
+    this.deferBackgroundFetches(q, sessionId);
     const configOptions = await this.buildConfigOptions();
     return { configOptions };
   }
@@ -3644,10 +3656,10 @@ var ClaudeAcpAgent = class 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.
    */
-  deferBackgroundFetches(q, sessionId, mcpServers) {
+  deferBackgroundFetches(q, sessionId) {
     Promise.all([
       getAvailableSlashCommands(q),
-      fetchMcpToolMetadata(mcpServers, this.logger)
+      fetchMcpToolMetadata(q, this.logger)
     ]).then(([slashCommands]) => {
       this.sendAvailableCommandsUpdate(sessionId, slashCommands);
     }).catch((err) => {
@@ -4579,18 +4591,18 @@ var SessionLogWriter = class _SessionLogWriter {
     const retryCount = this.retryCounts.get(sessionId) ?? 0;
     const lastAttempt = this.lastFlushAttemptTime.get(sessionId) ?? 0;
     const elapsed = Date.now() - lastAttempt;
-    let delay2;
+    let delay3;
     if (retryCount > 0) {
-      delay2 = Math.min(
+      delay3 = Math.min(
         _SessionLogWriter.FLUSH_DEBOUNCE_MS * 2 ** retryCount,
         _SessionLogWriter.MAX_RETRY_DELAY_MS
       );
     } else if (elapsed >= _SessionLogWriter.FLUSH_MAX_INTERVAL_MS) {
-      delay2 = 0;
+      delay3 = 0;
     } else {
-      delay2 = _SessionLogWriter.FLUSH_DEBOUNCE_MS;
+      delay3 = _SessionLogWriter.FLUSH_DEBOUNCE_MS;
     }
-    const timeout = setTimeout(() => this.flush(sessionId), delay2);
+    const timeout = setTimeout(() => this.flush(sessionId), delay3);
     this.flushTimeouts.set(sessionId, timeout);
   }
   writeToLocalCache(sessionId, entry) {
@@ -4812,7 +4824,7 @@ function pick(source, properties) {
   });
   return out;
 }
-function delay(duration = 0) {
+function delay2(duration = 0) {
   return new Promise((done) => setTimeout(done, duration));
 }
 function orVoid(input) {
@@ -5079,7 +5091,7 @@ __export(utils_exports, {
   bufferToString: () => bufferToString,
   callTaskParser: () => callTaskParser,
   createInstanceConfig: () => createInstanceConfig,
-  delay: () => delay,
+  delay: () => delay2,
   filterArray: () => filterArray,
   filterFunction: () => filterFunction,
   filterHasLength: () => filterHasLength,
@@ -8892,7 +8904,7 @@ function completionDetectionPlugin({
     if (flag === false) {
       return;
     }
-    (flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done);
+    (flag === true ? event.promise : event.promise.then(() => delay2(flag))).then(timeout.done);
   }
   return {
     type: "spawn.after",
@@ -8908,7 +8920,7 @@ function completionDetectionPlugin({
       try {
         await events.result;
         if (deferClose) {
-          await delay(50);
+          await delay2(50);
         }
         close(events.exitCode);
       } catch (err) {