@posthog/agent 2.1.112 → 2.1.114

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.112",
+  version: "2.1.114",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1602,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 = `
 
@@ -1932,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":
@@ -2030,31 +2112,49 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
     }
   }
 }
+function itemToText(item) {
+  if (!item || typeof item !== "object") return null;
+  const obj = item;
+  if (obj.type === "text" && typeof obj.text === "string") {
+    return obj.text;
+  }
+  try {
+    return JSON.stringify(obj, null, 2);
+  } catch {
+    return null;
+  }
+}
 function toAcpContentUpdate(content, isError = false) {
   if (Array.isArray(content) && content.length > 0) {
-    return {
-      content: content.map((item) => {
-        const itemObj = item;
-        if (isError && itemObj.type === "text") {
-          return {
-            type: "content",
-            content: text(`\`\`\`
-${itemObj.text ?? ""}
-\`\`\``)
-          };
-        }
-        return {
-          type: "content",
-          content: item
-        };
-      })
-    };
+    const texts = [];
+    for (const item of content) {
+      const t = itemToText(item);
+      if (t) texts.push(t);
+    }
+    if (texts.length > 0) {
+      const combined = texts.join("\n");
+      return {
+        content: toolContent().text(isError ? `\`\`\`
+${combined}
+\`\`\`` : combined).build()
+      };
+    }
   } else if (typeof content === "string" && content.length > 0) {
     return {
       content: toolContent().text(isError ? `\`\`\`
 ${content}
 \`\`\`` : content).build()
     };
+  } else if (content && typeof content === "object") {
+    try {
+      const json = JSON.stringify(content, null, 2);
+      if (json && json !== "{}") {
+        return {
+          content: toolContent().text(json).build()
+        };
+      }
+    } catch {
+    }
   }
   return {};
 }
@@ -2475,68 +2575,6 @@ async function handleUserAssistantMessage(message, context) {
   return {};
 }
 
-// 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 });
-        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 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);