@posthog/agent 2.1.111 → 2.1.112

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.112",
   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",
@@ -2477,68 +2476,61 @@ async function handleUserAssistantMessage(message, context) {
 }
 
 // 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();
+var PENDING_RETRY_INTERVAL_MS = 1e3;
+var PENDING_MAX_RETRIES = 10;
 function buildToolKey(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
-function isHttpMcpServer(config) {
-  return config.type === "http" && typeof config.url === "string";
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
-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;
+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 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));
+    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,
-        toolCount,
+        serverName: server.name,
+        toolCount: server.tools.length,
         readOnlyCount
       });
-    }).catch((error) => {
-      logger.error("Failed to fetch MCP tool metadata", {
-        serverName,
-        error: error instanceof Error ? error.message : String(error)
+    }
+    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
     });
-    fetchPromises.push(fetchPromise);
+    await delay(PENDING_RETRY_INTERVAL_MS);
   }
-  await Promise.all(fetchPromises);
 }
 function isMcpToolReadOnly(toolName) {
   const metadata = mcpToolMetadataCache.get(toolName);
@@ -3411,7 +3403,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 +3448,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 +3636,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 +4571,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 +4804,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 +5071,7 @@ __export(utils_exports, {
   bufferToString: () => bufferToString,
   callTaskParser: () => callTaskParser,
   createInstanceConfig: () => createInstanceConfig,
-  delay: () => delay,
+  delay: () => delay2,
   filterArray: () => filterArray,
   filterFunction: () => filterFunction,
   filterHasLength: () => filterHasLength,
@@ -8892,7 +8884,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 +8900,7 @@ function completionDetectionPlugin({
       try {
         await events.result;
         if (deferClose) {
-          await delay(50);
+          await delay2(50);
         }
         close(events.exitCode);
       } catch (err) {