@posthog/agent 2.3.508 → 2.3.513

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.508",
+  "version": "2.3.513",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -102,8 +102,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@posthog/shared": "1.0.0",
     "@posthog/git": "1.0.0",
+    "@posthog/shared": "1.0.0",
     "@posthog/enricher": "1.0.0"
   },
   "dependencies": {

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

@@ -103,6 +103,7 @@ import type {
   SDKMessageFilter,
   Session,
   ToolUseCache,
+  ToolUseStreamCache,
 } from "./types";
 
 const SESSION_VALIDATION_TIMEOUT_MS = 30_000;
@@ -145,6 +146,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   readonly adapterName = "claude";
   declare session: Session;
   toolUseCache: ToolUseCache;
+  toolUseStreamCache: ToolUseStreamCache;
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
   private options?: ClaudeAcpAgentOptions;
@@ -155,6 +157,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     super(client);
     this.options = options;
     this.toolUseCache = {};
+    this.toolUseStreamCache = new Map();
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
     this.enrichment = createEnrichment(options?.posthogApiConfig, this.logger);
   }
@@ -403,6 +406,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       sessionId: params.sessionId,
       client: this.client,
       toolUseCache: this.toolUseCache,
+      toolUseStreamCache: this.toolUseStreamCache,
       fileContentCache: this.fileContentCache,
       enrichedReadCache: this.enrichedReadCache,
       logger: this.logger,
@@ -768,6 +772,11 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       }
       throw error;
     } finally {
+      // Drop any leftover streaming-input buffers. Normally cleared per index
+      // on `content_block_stop`, but a cancelled or errored turn may leave
+      // entries behind; without this they'd carry over into the next turn
+      // and collide with new content-block indices.
+      this.toolUseStreamCache.clear();
       if (!handedOff) {
         this.session.promptRunning = false;
         // Resolve all remaining pending prompts so no callers get stuck.
@@ -1528,6 +1537,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         sessionId,
         client: this.client,
         toolUseCache: this.toolUseCache,
+        toolUseStreamCache: this.toolUseStreamCache,
         fileContentCache: this.fileContentCache,
         enrichedReadCache: this.enrichedReadCache,
         logger: this.logger,

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

@@ -21,8 +21,14 @@ import { POSTHOG_NOTIFICATIONS } from "@/acp-extensions";
 import { image, text } from "../../../utils/acp-content";
 import { unreachable } from "../../../utils/common";
 import type { Logger } from "../../../utils/logger";
+import { tryParsePartialJson } from "../../../utils/partial-json";
 import { type EnrichedReadCache, registerHookCallback } from "../hooks";
-import type { Session, ToolUpdateMeta, ToolUseCache } from "../types";
+import type {
+  Session,
+  ToolUpdateMeta,
+  ToolUseCache,
+  ToolUseStreamCache,
+} from "../types";
 import {
   type ClaudePlanEntry,
   planEntries,
@@ -67,6 +73,8 @@ export interface MessageHandlerContext {
   sessionId: string;
   client: AgentSideConnection;
   toolUseCache: ToolUseCache;
+  /** Buffers `input_json_delta` partial JSON per content-block index. */
+  toolUseStreamCache: ToolUseStreamCache;
   fileContentCache: { [key: string]: string };
   enrichedReadCache?: EnrichedReadCache;
   logger: Logger;
@@ -496,6 +504,7 @@ function streamEventToAcpNotifications(
   message: SDKPartialAssistantMessage,
   sessionId: string,
   toolUseCache: ToolUseCache,
+  toolUseStreamCache: ToolUseStreamCache,
   fileContentCache: { [key: string]: string },
   client: AgentSideConnection,
   logger: Logger,
@@ -507,9 +516,16 @@ function streamEventToAcpNotifications(
 ): SessionNotification[] {
   const event = message.event;
   switch (event.type) {
-    case "content_block_start":
+    case "content_block_start": {
+      const block = event.content_block;
+      if (block.type === "tool_use" || block.type === "mcp_tool_use") {
+        toolUseStreamCache.set(event.index, {
+          toolUseId: block.id,
+          partialJson: "",
+        });
+      }
       return toAcpNotifications(
-        [event.content_block],
+        [block],
         "assistant",
         sessionId,
         toolUseCache,
@@ -523,7 +539,16 @@ function streamEventToAcpNotifications(
         undefined,
         enrichedReadCache,
       );
-    case "content_block_delta":
+    }
+    case "content_block_delta": {
+      if (event.delta.type === "input_json_delta") {
+        return inputJsonDeltaToAcpNotifications(
+          event.index,
+          event.delta.partial_json,
+          sessionId,
+          toolUseStreamCache,
+        );
+      }
       return toAcpNotifications(
         [event.delta],
         "assistant",
@@ -539,10 +564,13 @@ function streamEventToAcpNotifications(
         undefined,
         enrichedReadCache,
       );
+    }
+    case "content_block_stop":
+      toolUseStreamCache.delete(event.index);
+      return [];
     case "message_start":
     case "message_delta":
     case "message_stop":
-    case "content_block_stop":
       return [];
 
     default:
@@ -551,6 +579,31 @@ function streamEventToAcpNotifications(
   }
 }
 
+function inputJsonDeltaToAcpNotifications(
+  index: number,
+  partialJson: string,
+  sessionId: string,
+  toolUseStreamCache: ToolUseStreamCache,
+): SessionNotification[] {
+  const entry = toolUseStreamCache.get(index);
+  if (!entry) return [];
+  entry.partialJson += partialJson;
+
+  const parsed = tryParsePartialJson(entry.partialJson);
+  if (!parsed || typeof parsed !== "object") return [];
+
+  return [
+    {
+      sessionId,
+      update: {
+        sessionUpdate: "tool_call_update" as const,
+        toolCallId: entry.toolUseId,
+        rawInput: parsed as Record<string, unknown>,
+      },
+    },
+  ];
+}
+
 export async function handleSystemMessage(
   message: Extract<SDKMessage, { type: "system" }>,
   context: MessageHandlerContext,
@@ -743,13 +796,21 @@ export async function handleStreamEvent(
   message: SDKPartialAssistantMessage,
   context: MessageHandlerContext,
 ): Promise<void> {
-  const { sessionId, client, toolUseCache, fileContentCache, logger } = context;
+  const {
+    sessionId,
+    client,
+    toolUseCache,
+    toolUseStreamCache,
+    fileContentCache,
+    logger,
+  } = context;
   const parentToolCallId = message.parent_tool_use_id ?? undefined;
 
   for (const notification of streamEventToAcpNotifications(
     message,
     sessionId,
     toolUseCache,
+    toolUseStreamCache,
     fileContentCache,
     client,
     logger,

package/src/adapters/claude/session/mcp-config.test.ts

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadUserClaudeJsonMcpServers } from "./mcp-config";
+
+describe("loadUserClaudeJsonMcpServers", () => {
+  let tmpHome: string;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "claude-json-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it.each([
+    { name: "~/.claude.json is missing", setup: () => undefined },
+    {
+      name: "~/.claude.json contains invalid JSON",
+      setup: (home: string) =>
+        fs.writeFileSync(path.join(home, ".claude.json"), "not json"),
+    },
+  ])("returns empty when $name", ({ setup }) => {
+    setup(tmpHome);
+    expect(
+      loadUserClaudeJsonMcpServers("/some/cwd", undefined, tmpHome),
+    ).toEqual({});
+  });
+
+  it("returns top-level mcpServers", () => {
+    const cfg = {
+      mcpServers: {
+        top: { type: "stdio", command: "npx", args: ["pkg"] },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(
+      "/some/cwd",
+      undefined,
+      tmpHome,
+    );
+    expect(servers.top).toBeDefined();
+  });
+
+  it("returns project-scoped mcpServers when cwd matches a project entry", () => {
+    const cwd = "/Users/jane/proj";
+    const cfg = {
+      projects: {
+        [cwd]: {
+          mcpServers: {
+            playwright: {
+              type: "stdio",
+              command: "npx",
+              args: ["@playwright/mcp@latest"],
+            },
+          },
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(cwd, undefined, tmpHome);
+    expect(servers.playwright).toBeDefined();
+  });
+
+  it("project-scoped servers override top-level on key collision", () => {
+    const cwd = "/Users/jane/proj";
+    const cfg = {
+      mcpServers: {
+        shared: { type: "stdio", command: "global", args: [] },
+      },
+      projects: {
+        [cwd]: {
+          mcpServers: {
+            shared: { type: "stdio", command: "scoped", args: [] },
+          },
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(cwd, undefined, tmpHome);
+    expect((servers.shared as { command: string }).command).toBe("scoped");
+  });
+
+  it("ignores CLAUDE_CONFIG_DIR redirect (reads real ~/.claude.json)", () => {
+    const altDir = fs.mkdtempSync(path.join(os.tmpdir(), "alt-claude-"));
+    fs.writeFileSync(
+      path.join(altDir, ".claude.json"),
+      JSON.stringify({
+        mcpServers: { wrong: { type: "stdio", command: "x" } },
+      }),
+    );
+    fs.writeFileSync(
+      path.join(tmpHome, ".claude.json"),
+      JSON.stringify({
+        mcpServers: { right: { type: "stdio", command: "y" } },
+      }),
+    );
+    const original = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = altDir;
+    try {
+      const servers = loadUserClaudeJsonMcpServers("/cwd", undefined, tmpHome);
+      expect(servers.right).toBeDefined();
+      expect(servers.wrong).toBeUndefined();
+    } finally {
+      if (original === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+      else process.env.CLAUDE_CONFIG_DIR = original;
+      fs.rmSync(altDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/adapters/claude/session/mcp-config.ts

@@ -1,5 +1,50 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import type { NewSessionRequest } from "@agentclientprotocol/sdk";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { Logger } from "../../../utils/logger";
+
+export function loadUserClaudeJsonMcpServers(
+  cwd: string,
+  logger?: Logger,
+  homeDir: string = os.homedir(),
+): Record<string, McpServerConfig> {
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+
+  let raw: string;
+  try {
+    raw = fs.readFileSync(claudeJsonPath, "utf8");
+  } catch {
+    return {};
+  }
+
+  let cfg: {
+    mcpServers?: unknown;
+    projects?: Record<string, { mcpServers?: unknown }>;
+  };
+  try {
+    cfg = JSON.parse(raw);
+  } catch (err) {
+    logger?.warn("Failed to parse ~/.claude.json", {
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return {};
+  }
+
+  const topLevel =
+    cfg.mcpServers && typeof cfg.mcpServers === "object"
+      ? (cfg.mcpServers as Record<string, McpServerConfig>)
+      : {};
+
+  const project = cfg.projects?.[cwd];
+  const projectScoped =
+    project?.mcpServers && typeof project.mcpServers === "object"
+      ? (project.mcpServers as Record<string, McpServerConfig>)
+      : {};
+
+  return { ...topLevel, ...projectScoped };
+}
 
 export function parseMcpServers(
   params: Pick<NewSessionRequest, "mcpServers">,

package/src/adapters/claude/session/options.ts

@@ -24,6 +24,7 @@ import {
 import type { CodeExecutionMode } from "../tools";
 import type { EffortLevel } from "../types";
 import { APPENDED_INSTRUCTIONS } from "./instructions";
+import { loadUserClaudeJsonMcpServers } from "./mcp-config";
 import { DEFAULT_MODEL } from "./models";
 import type { SettingsManager } from "./settings";
 
@@ -91,8 +92,10 @@ export function buildSystemPrompt(
 function buildMcpServers(
   userServers: Record<string, McpServerConfig> | undefined,
   acpServers: Record<string, McpServerConfig>,
+  projectScopedServers: Record<string, McpServerConfig>,
 ): Record<string, McpServerConfig> {
   return {
+    ...projectScopedServers,
     ...(userServers || {}),
     ...acpServers,
   };
@@ -330,6 +333,7 @@ export function buildSessionOptions(params: BuildOptionsParams): Options {
     mcpServers: buildMcpServers(
       params.userProvidedOptions?.mcpServers,
       params.mcpServers,
+      loadUserClaudeJsonMcpServers(params.cwd, params.logger),
     ),
     env: buildEnvironment(),
     hooks: buildHooks(

package/src/adapters/claude/types.ts

@@ -76,6 +76,16 @@ export type ToolUseCache = {
   };
 };
 
+/**
+ * Per-content-block-index buffer for tool inputs streamed via
+ * `input_json_delta` events. Keyed by the Anthropic content block index
+ * (which resets per assistant message). Cleared on `content_block_stop`.
+ */
+export type ToolUseStreamCache = Map<
+  number,
+  { toolUseId: string; partialJson: string }
+>;
+
 export type TerminalInfo = {
   terminal_id: string;
 };

package/src/utils/partial-json.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { tryParsePartialJson } from "./partial-json";
+
+describe("tryParsePartialJson", () => {
+  it("returns null for empty / whitespace input", () => {
+    expect(tryParsePartialJson("")).toBeNull();
+    expect(tryParsePartialJson("   ")).toBeNull();
+  });
+
+  it("parses complete JSON unchanged", () => {
+    expect(tryParsePartialJson('{"a":1}')).toEqual({ a: 1 });
+    expect(tryParsePartialJson("[1,2,3]")).toEqual([1, 2, 3]);
+    expect(tryParsePartialJson('"hello"')).toBe("hello");
+  });
+
+  it("closes a single open object", () => {
+    expect(tryParsePartialJson("{")).toEqual({});
+  });
+
+  it("closes a partial string value and the surrounding object", () => {
+    expect(tryParsePartialJson('{"command": "call execute-')).toEqual({
+      command: "call execute-",
+    });
+  });
+
+  it("closes a complete string value with no closing brace", () => {
+    expect(tryParsePartialJson('{"command": "tools"')).toEqual({
+      command: "tools",
+    });
+  });
+
+  it("strips a trailing comma after a complete entry", () => {
+    expect(tryParsePartialJson('{"a": 1,')).toEqual({ a: 1 });
+  });
+
+  it("drops a trailing partial key with no value", () => {
+    expect(tryParsePartialJson('{"a": 1, "b":')).toEqual({ a: 1 });
+    expect(tryParsePartialJson('{"a": 1, "b"')).toEqual({ a: 1 });
+  });
+
+  it("handles nested objects and arrays mid-stream", () => {
+    expect(tryParsePartialJson('{"q": {"sql": "SELECT 1')).toEqual({
+      q: { sql: "SELECT 1" },
+    });
+    expect(tryParsePartialJson('{"items": [1, 2, 3')).toEqual({
+      items: [1, 2, 3],
+    });
+  });
+
+  it("respects escaped quotes inside strings", () => {
+    expect(tryParsePartialJson('{"q": "say \\"hi\\"')).toEqual({
+      q: 'say "hi"',
+    });
+  });
+
+  it("returns null when nothing parseable can be reconstructed", () => {
+    // Garbage that can't be balanced into valid JSON.
+    expect(tryParsePartialJson("not json at all")).toBeNull();
+  });
+
+  it("parses a typical exec command incrementally", () => {
+    // Simulate growth of a streamed { command: "call dashboard-update {...}" }
+    expect(tryParsePartialJson('{"command":')).toEqual({});
+    expect(tryParsePartialJson('{"command": "ca')).toEqual({ command: "ca" });
+    expect(
+      tryParsePartialJson('{"command": "call dashboard-update {\\"id\\":'),
+    ).toEqual({ command: 'call dashboard-update {"id":' });
+    expect(
+      tryParsePartialJson('{"command": "call dashboard-update {\\"id\\": 1}"}'),
+    ).toEqual({ command: 'call dashboard-update {"id": 1}' });
+  });
+});

package/src/utils/partial-json.ts

@@ -0,0 +1,68 @@
+/**
+ * Best-effort parser for incomplete JSON streamed via Anthropic's
+ * `input_json_delta` events. Used to surface tool inputs while they are still
+ * being generated so the UI can show the args during execution instead of
+ * waiting for the finalized assistant message.
+ *
+ * Strategy: walk the input tracking open `{`/`[` and quote/escape state, then
+ * try a few completions in order of likelihood (close any open string, drop
+ * trailing commas/colons or partial keys, then close any open brackets).
+ * Returns `null` when no completion parses — callers should silently skip
+ * that delta and wait for more input.
+ */
+export function tryParsePartialJson(s: string): unknown {
+  const trimmed = s.trim();
+  if (!trimmed) return null;
+
+  // Fast path: complete JSON.
+  try {
+    return JSON.parse(trimmed);
+  } catch {}
+
+  const closers: string[] = [];
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") closers.push("}");
+    else if (ch === "[") closers.push("]");
+    else if (ch === "}" || ch === "]") closers.pop();
+  }
+
+  const closeBrackets = (str: string): string => {
+    let out = str;
+    for (let i = closers.length - 1; i >= 0; i--) out += closers[i];
+    return out;
+  };
+
+  const candidates: string[] = [];
+
+  // 1. Close any open string + brackets.
+  const closedString = inString ? `${trimmed}"` : trimmed;
+  candidates.push(closeBrackets(closedString));
+
+  // 2. Drop trailing partial token (comma, colon, or `"key":`/`"key"`)
+  //    and close brackets.
+  let stripped = closedString.replace(/[,:]\s*$/, "");
+  stripped = stripped.replace(/,?\s*"[^"]*"\s*:?\s*$/, "");
+  candidates.push(closeBrackets(stripped));
+
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {}
+  }
+  return null;
+}