@posthog/agent 2.3.53 → 2.3.67

package/dist/types.d.ts

@@ -74,6 +74,7 @@ interface ProcessSpawnedCallback {
         sessionId?: string;
     }) => void;
     onProcessExited?: (pid: number) => void;
+    onMcpServersReady?: (serverNames: string[]) => void;
 }
 interface TaskExecutionOptions {
     repositoryPath?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.53",
+  "version": "2.3.67",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -107,11 +107,11 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && tsup",
+    "build": "node ../../scripts/rimraf.mjs dist && tsup",
     "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "pnpm exec tsc --noEmit",
-    "clean": "rm -rf dist .turbo"
+    "clean": "node ../../scripts/rimraf.mjs dist .turbo"
   }
 }

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

@@ -55,7 +55,10 @@ import {
   handleSystemMessage,
   handleUserAssistantMessage,
 } from "./conversion/sdk-to-acp";
-import { fetchMcpToolMetadata } from "./mcp/tool-metadata";
+import {
+  fetchMcpToolMetadata,
+  getConnectedMcpServerNames,
+} from "./mcp/tool-metadata";
 import { canUseTool } from "./permissions/permission-handlers";
 import { getAvailableSlashCommands } from "./session/commands";
 import { parseMcpServers } from "./session/mcp-config";
@@ -101,6 +104,7 @@ function sanitizeTitle(text: string): string {
 export interface ClaudeAcpAgentOptions {
   onProcessSpawned?: (info: ProcessSpawnedInfo) => void;
   onProcessExited?: (pid: number) => void;
+  onMcpServersReady?: (serverNames: string[]) => void;
 }
 
 export class ClaudeAcpAgent extends BaseAcpAgent {
@@ -1020,11 +1024,17 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
    * Both populate caches used later — neither is needed to return configOptions.
    */
   private deferBackgroundFetches(q: Query): void {
+    this.logger.info("Starting background fetches (commands + MCP metadata)");
     Promise.all([
       new Promise<void>((resolve) => setTimeout(resolve, 10)).then(() =>
         this.sendAvailableCommandsUpdate(),
       ),
-      fetchMcpToolMetadata(q, this.logger),
+      fetchMcpToolMetadata(q, this.logger).then(() => {
+        const serverNames = getConnectedMcpServerNames();
+        if (serverNames.length > 0) {
+          this.options?.onMcpServersReady?.(serverNames);
+        }
+      }),
     ]).catch((err) =>
       this.logger.error("Background fetch failed", { error: err }),
     );

package/src/adapters/claude/conversion/acp-to-sdk.ts

@@ -1,3 +1,4 @@
+import * as path from "node:path";
 import type { PromptRequest } from "@agentclientprotocol/sdk";
 import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
@@ -12,12 +13,11 @@ function formatUriAsLink(uri: string): string {
   try {
     if (uri.startsWith("file://")) {
       const filePath = uri.slice(7);
-      const name = filePath.split("/").pop() || filePath;
+      const name = path.basename(filePath) || filePath;
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("zed://")) {
-      const parts = uri.split("/");
-      const name = parts[parts.length - 1] || uri;
+      const name = path.basename(uri) || uri;
       return `[@${name}](${uri})`;
     }
     return uri;

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -56,6 +56,8 @@ type ChunkHandlerContext = {
   registerHooks?: boolean;
   supportsTerminalOutput?: boolean;
   cwd?: string;
+  /** Raw MCP tool result from SDKUserMessage.tool_use_result (contains content, structuredContent, _meta) */
+  mcpToolUseResult?: Record<string, unknown>;
 };
 
 export interface MessageHandlerContext {
@@ -348,7 +350,16 @@ function handleToolResultChunk(
     toolCallId: chunk.tool_use_id,
     sessionUpdate: "tool_call_update",
     status: chunk.is_error ? "failed" : "completed",
-    rawOutput: chunk.content,
+    rawOutput: ctx.mcpToolUseResult
+      ? { ...ctx.mcpToolUseResult, isError: chunk.is_error ?? false }
+      : {
+          content: Array.isArray(chunk.content)
+            ? chunk.content
+            : typeof chunk.content === "string"
+              ? [{ type: "text" as const, text: chunk.content }]
+              : [],
+          isError: chunk.is_error ?? false,
+        },
     ...toolUpdate,
   });
 
@@ -435,6 +446,7 @@ function toAcpNotifications(
   registerHooks?: boolean,
   supportsTerminalOutput?: boolean,
   cwd?: string,
+  mcpToolUseResult?: Record<string, unknown>,
 ): SessionNotification[] {
   if (typeof content === "string") {
     const update: SessionUpdate = {
@@ -461,6 +473,7 @@ function toAcpNotifications(
     registerHooks,
     supportsTerminalOutput,
     cwd,
+    mcpToolUseResult,
   };
   const output: SessionNotification[] = [];
 
@@ -829,6 +842,13 @@ export async function handleUserAssistantMessage(
       ? (message.parent_tool_use_id ?? undefined)
       : undefined;
 
+  // Pass the raw MCP tool result (contains content, structuredContent, _meta)
+  // so it can be forwarded as-is to the renderer for MCP Apps
+  const mcpToolUseResult =
+    message.type === "user" && message.tool_use_result != null
+      ? (message.tool_use_result as Record<string, unknown>)
+      : undefined;
+
   for (const notification of toAcpNotifications(
     contentToProcess as typeof content,
     message.message.role,
@@ -841,6 +861,7 @@ export async function handleUserAssistantMessage(
     context.registerHooks,
     context.supportsTerminalOutput,
     session.cwd,
+    mcpToolUseResult,
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);

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

@@ -48,6 +48,7 @@ export async function fetchMcpToolMetadata(
       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,
@@ -94,6 +95,15 @@ export function isMcpToolReadOnly(toolName: string): boolean {
   return metadata?.readOnly === true;
 }
 
+export function getConnectedMcpServerNames(): string[] {
+  const names = new Set<string>();
+  for (const key of mcpToolMetadataCache.keys()) {
+    const parts = key.split("__");
+    if (parts.length >= 3) names.add(parts[1]);
+  }
+  return [...names];
+}
+
 export function clearMcpToolMetadataCache(): void {
   mcpToolMetadataCache.clear();
 }

package/src/index.ts

@@ -1 +1,5 @@
-export { isMcpToolReadOnly } from "./adapters/claude/mcp/tool-metadata";
+export {
+  getMcpToolMetadata,
+  isMcpToolReadOnly,
+  type McpToolMetadata,
+} from "./adapters/claude/mcp/tool-metadata";

package/src/types.ts

@@ -103,6 +103,7 @@ export interface ProcessSpawnedCallback {
     sessionId?: string;
   }) => void;
   onProcessExited?: (pid: number) => void;
+  onMcpServersReady?: (serverNames: string[]) => void;
 }
 
 export interface TaskExecutionOptions {