@posthog/agent 2.3.735 → 2.3.736

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

@@ -12,6 +12,10 @@ import type {
   SDKResultMessage,
   SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  TaskCreateInput,
+  TaskUpdateInput,
+} from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
 import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
 import type {
   BetaContentBlock,
@@ -31,8 +35,13 @@ import type {
   ToolUseStreamCache,
 } from "../types";
 import {
-  type ClaudePlanEntry,
-  planEntries,
+  applyTaskCreate,
+  applyTaskUpdate,
+  parseTaskCreateOutput,
+  type TaskState,
+  taskStateToPlanEntries,
+} from "./task-state";
+import {
   toolInfoFromToolUse,
   toolUpdateFromEditToolResponse,
   toolUpdateFromToolResult,
@@ -49,7 +58,6 @@ interface AnthropicMessageWithContent {
   type: Role;
   message: {
     content: AnthropicMessageContent;
-    role?: Role;
     model?: string;
   };
 }
@@ -67,6 +75,8 @@ type ChunkHandlerContext = {
   cwd?: string;
   /** Raw MCP tool result from SDKUserMessage.tool_use_result (contains content, structuredContent, _meta) */
   mcpToolUseResult?: Record<string, unknown>;
+  /** Per-session task list (populated by createTaskHook + tool_result handler) */
+  taskState?: TaskState;
 };
 
 export interface MessageHandlerContext {
@@ -168,14 +178,14 @@ function handleToolUseChunk(
   const alreadyCached = chunk.id in ctx.toolUseCache;
   ctx.toolUseCache[chunk.id] = chunk;
 
-  if (chunk.name === "TodoWrite") {
-    const input = chunk.input as { todos?: unknown[] };
-    if (Array.isArray(input.todos)) {
-      return {
-        sessionUpdate: "plan",
-        entries: planEntries(chunk.input as { todos: ClaudePlanEntry[] }),
-      };
-    }
+  // Suppress Task* tool_calls — plan updates are emitted from the matching
+  // tool_result handler instead, after taskState has been mutated.
+  if (
+    chunk.name === "TaskCreate" ||
+    chunk.name === "TaskUpdate" ||
+    chunk.name === "TaskList" ||
+    chunk.name === "TaskGet"
+  ) {
     return null;
   }
 
@@ -185,7 +195,7 @@ function handleToolUseChunk(
         const toolUse = ctx.toolUseCache[toolUseId];
         if (toolUse) {
           const editUpdate =
-            toolUse.name === "Edit"
+            toolUse.name === "Edit" || toolUse.name === "Write"
               ? toolUpdateFromEditToolResponse(toolResponse)
               : null;
 
@@ -334,7 +344,33 @@ function handleToolResultChunk(
     return [];
   }
 
-  if (toolUse.name === "TodoWrite") {
+  if (
+    toolUse.name === "TaskCreate" ||
+    toolUse.name === "TaskUpdate" ||
+    toolUse.name === "TaskList" ||
+    toolUse.name === "TaskGet"
+  ) {
+    if (chunk.is_error || !ctx.taskState) return [];
+    if (toolUse.name === "TaskCreate") {
+      applyTaskCreate(
+        ctx.taskState,
+        toolUse.input as TaskCreateInput | undefined,
+        parseTaskCreateOutput(chunk.content),
+      );
+    } else if (toolUse.name === "TaskUpdate") {
+      applyTaskUpdate(
+        ctx.taskState,
+        toolUse.input as TaskUpdateInput | undefined,
+      );
+    }
+    if (toolUse.name === "TaskCreate" || toolUse.name === "TaskUpdate") {
+      return [
+        {
+          sessionUpdate: "plan",
+          entries: taskStateToPlanEntries(ctx.taskState),
+        },
+      ];
+    }
     return [];
   }
 
@@ -460,6 +496,8 @@ function processContentChunk(
     case "container_upload":
     case "compaction":
     case "compaction_delta":
+    case "advisor_tool_result":
+    case "mid_conv_system":
       return [];
 
     default:
@@ -486,6 +524,7 @@ function toAcpNotifications(
   cwd?: string,
   mcpToolUseResult?: Record<string, unknown>,
   enrichedReadCache?: EnrichedReadCache,
+  taskState?: TaskState,
 ): SessionNotification[] {
   if (typeof content === "string") {
     const update: SessionUpdate = {
@@ -514,6 +553,7 @@ function toAcpNotifications(
     supportsTerminalOutput,
     cwd,
     mcpToolUseResult,
+    taskState,
   };
   const output: SessionNotification[] = [];
 
@@ -539,6 +579,7 @@ function streamEventToAcpNotifications(
   supportsTerminalOutput?: boolean,
   cwd?: string,
   enrichedReadCache?: EnrichedReadCache,
+  taskState?: TaskState,
 ): SessionNotification[] {
   const event = message.event;
   switch (event.type) {
@@ -564,6 +605,7 @@ function streamEventToAcpNotifications(
         cwd,
         undefined,
         enrichedReadCache,
+        taskState,
       );
     }
     case "content_block_delta": {
@@ -589,11 +631,17 @@ function streamEventToAcpNotifications(
         cwd,
         undefined,
         enrichedReadCache,
+        taskState,
       );
     }
     case "content_block_stop":
       toolUseStreamCache.delete(event.index);
       return [];
+    // `ping` is a Messages-API keep-alive event that the SDK's
+    // `BetaRawMessageStreamEvent` union doesn't include even though the
+    // wire format emits it; the `as never` cast lets us no-op it here
+    // instead of falling through to `unreachable`.
+    case "ping" as never:
     case "message_start":
     case "message_delta":
     case "message_stop":
@@ -678,6 +726,52 @@ export async function handleSystemMessage(
       });
       break;
     }
+    case "memory_recall": {
+      const isSynthesis = message.mode === "synthesize";
+      // Skip empty recalls — they're the dominant source of UI clutter on
+      // memory-heavy turns and carry no signal (no paths, no content).
+      if (!isSynthesis && message.memories.length === 0) break;
+      const locations = isSynthesis
+        ? []
+        : message.memories.map((m) => ({ path: m.path }));
+      const content = isSynthesis
+        ? message.memories
+            .filter(
+              (
+                m,
+              ): m is (typeof message.memories)[number] & {
+                content: string;
+              } => typeof m.content === "string",
+            )
+            .map((m) => ({
+              type: "content" as const,
+              content: { type: "text" as const, text: m.content },
+            }))
+        : [];
+      const count = message.memories.length;
+      const title = isSynthesis
+        ? "Recalled synthesized memory"
+        : `Recalled ${count} ${count === 1 ? "memory" : "memories"}`;
+      await client.sessionUpdate({
+        sessionId: message.session_id,
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId: message.uuid,
+          title,
+          kind: "read",
+          status: "completed",
+          ...(locations.length > 0 && { locations }),
+          ...(content.length > 0 && { content }),
+          _meta: {
+            claudeCode: {
+              toolName: "memory_recall",
+              toolResponse: { mode: message.mode },
+            },
+          } satisfies ToolUpdateMeta,
+        },
+      });
+      break;
+    }
     default:
       break;
   }
@@ -819,6 +913,7 @@ export async function handleStreamEvent(
     context.supportsTerminalOutput,
     context.session.cwd,
     context.enrichedReadCache,
+    context.session.taskState,
   )) {
     await client.sessionUpdate(notification);
     context.session.notificationHistory.push(notification);
@@ -837,6 +932,41 @@ function hasLocalCommandStderr(content: AnthropicMessageContent): boolean {
   );
 }
 
+// SDK-persisted slash command invocations always lead with `<command-name>`.
+// Requiring that anchor keeps user-typed prompts that happen to contain a
+// literal `<local-command-stdout>` tag from being scrubbed on session reload.
+function isSdkLocalCommandMessage(content: AnthropicMessageContent): boolean {
+  return (
+    typeof content === "string" &&
+    content.includes("<command-name>") &&
+    (content.includes("<local-command-stdout>") ||
+      content.includes("<local-command-stderr>"))
+  );
+}
+
+// The Claude SDK persists local slash command invocations (e.g. `/model`) and
+// their output as user messages wrapping the payload in these XML-like markers
+// that the CLI uses for its own display. The live prompt loop must strip them
+// so they don't leak into the UI, while preserving any real prose mixed in
+// alongside.
+const LOCAL_COMMAND_TAG_PATTERN =
+  /<(command-name|command-message|command-args|local-command-stdout|local-command-stderr)>[\s\S]*?<\/\1>/g;
+
+function stripMarkerTags(text: string): string {
+  return text.replace(LOCAL_COMMAND_TAG_PATTERN, "");
+}
+
+/**
+ * Returns the string with local-command marker tags removed, or `null` if
+ * nothing renderable remains. Used to surface custom slash commands and
+ * skill expansions whose bodies arrive wrapped in marker tags, while
+ * still no-op'ing for pure-marker payloads like /compact.
+ */
+function stripLocalCommandMetadata(content: string): string | null {
+  const stripped = stripMarkerTags(content);
+  return stripped.trim() === "" ? null : stripped;
+}
+
 function isLoginRequiredMessage(message: AnthropicMessageWithContent): boolean {
   return (
     message.type === "assistant" &&
@@ -863,8 +993,7 @@ function shouldSkipUserAssistantMessage(
   message: AnthropicMessageWithContent,
 ): boolean {
   return (
-    hasLocalCommandStdout(message.message.content) ||
-    hasLocalCommandStderr(message.message.content) ||
+    isSdkLocalCommandMessage(message.message.content) ||
     isLoginRequiredMessage(message)
   );
 }
@@ -900,12 +1029,48 @@ export async function handleUserAssistantMessage(
   const { session, sessionId, client, toolUseCache, fileContentCache, logger } =
     context;
 
+  // System-role payloads (e.g. SDK-injected reminders) reach the user/assistant
+  // switch but are never user-visible content; skip rendering them entirely.
+  if (message.message.role === "system") {
+    return {};
+  }
+
   if (shouldSkipUserAssistantMessage(message)) {
     logSpecialMessages(message, logger);
 
     if (isLoginRequiredMessage(message)) {
       return { shouldStop: true, error: RequestError.authRequired() };
     }
+
+    // Strip local-command marker tags and render whatever real prose remains
+    // so that custom slash commands and skill expansions (whose bodies arrive
+    // wrapped in <command-*> / <local-command-stdout> markers) reach the UI.
+    // Pure-marker payloads (e.g. /compact) still no-op via the `null` branch.
+    const rawContent = message.message.content;
+    if (typeof rawContent === "string") {
+      const stripped = stripLocalCommandMetadata(rawContent);
+      if (stripped !== null) {
+        for (const notification of toAcpNotifications(
+          stripped,
+          message.message.role as Role,
+          sessionId,
+          toolUseCache,
+          fileContentCache,
+          client,
+          logger,
+          undefined,
+          context.registerHooks,
+          context.supportsTerminalOutput,
+          session.cwd,
+          undefined,
+          context.enrichedReadCache,
+          session.taskState,
+        )) {
+          await client.sessionUpdate(notification);
+          session.notificationHistory.push(notification);
+        }
+      }
+    }
     return {};
   }
 
@@ -931,7 +1096,7 @@ export async function handleUserAssistantMessage(
 
   for (const notification of toAcpNotifications(
     contentToProcess as typeof content,
-    message.message.role,
+    message.message.role as Role,
     sessionId,
     toolUseCache,
     fileContentCache,
@@ -943,6 +1108,7 @@ export async function handleUserAssistantMessage(
     session.cwd,
     mcpToolUseResult,
     context.enrichedReadCache,
+    session.taskState,
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);

package/src/adapters/claude/conversion/task-state.test.ts

@@ -0,0 +1,338 @@
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import { describe, expect, it } from "vitest";
+import {
+  applyTaskCreate,
+  applyTaskUpdate,
+  parseTaskCreateOutput,
+  rehydrateTaskState,
+  type TaskState,
+  taskStateToPlanEntries,
+} from "./task-state";
+
+function assistantMsg(blocks: unknown[]): SessionMessage {
+  return {
+    type: "assistant",
+    uuid: "u",
+    session_id: "s",
+    parent_tool_use_id: null,
+    message: { role: "assistant", content: blocks },
+  } as SessionMessage;
+}
+
+function userMsg(blocks: unknown[]): SessionMessage {
+  return {
+    type: "user",
+    uuid: "u",
+    session_id: "s",
+    parent_tool_use_id: null,
+    message: { role: "user", content: blocks },
+  } as SessionMessage;
+}
+
+describe("parseTaskCreateOutput", () => {
+  it("parses a JSON string with task.id", () => {
+    const out = parseTaskCreateOutput('{"task":{"id":"t1"}}');
+    expect(out?.task?.id).toBe("t1");
+  });
+
+  it("returns undefined for invalid JSON", () => {
+    expect(parseTaskCreateOutput("not json")).toBeUndefined();
+  });
+
+  it("returns undefined when task.id is missing", () => {
+    expect(parseTaskCreateOutput("{}")).toBeUndefined();
+    expect(parseTaskCreateOutput('{"task":{}}')).toBeUndefined();
+  });
+
+  it("walks array of text blocks and returns the first parseable one", () => {
+    const out = parseTaskCreateOutput([
+      { type: "text", text: "garbage" },
+      { type: "text", text: '{"task":{"id":"t2"}}' },
+    ]);
+    expect(out?.task?.id).toBe("t2");
+  });
+
+  it("ignores non-text blocks", () => {
+    const out = parseTaskCreateOutput([
+      { type: "image", text: '{"task":{"id":"t3"}}' },
+    ]);
+    expect(out).toBeUndefined();
+  });
+
+  it("returns undefined for null/undefined/non-string content", () => {
+    expect(parseTaskCreateOutput(null)).toBeUndefined();
+    expect(parseTaskCreateOutput(undefined)).toBeUndefined();
+    expect(parseTaskCreateOutput(42)).toBeUndefined();
+  });
+});
+
+describe("applyTaskCreate", () => {
+  it("inserts a new entry keyed by output task id", () => {
+    const state: TaskState = new Map();
+    applyTaskCreate(
+      state,
+      {
+        subject: "Fix bug",
+        description: "details",
+        activeForm: "Fixing bug",
+      },
+      { task: { id: "t1", subject: "Fix bug" } },
+    );
+    expect(state.get("t1")).toEqual({
+      subject: "Fix bug",
+      status: "pending",
+      activeForm: "Fixing bug",
+      description: "details",
+    });
+  });
+
+  it("is a no-op when output has no task id", () => {
+    const state: TaskState = new Map();
+    applyTaskCreate(state, { subject: "x", description: "y" }, undefined);
+    expect(state.size).toBe(0);
+  });
+
+  it("is a no-op when input is undefined", () => {
+    const state: TaskState = new Map();
+    applyTaskCreate(state, undefined, { task: { id: "t1", subject: "x" } });
+    expect(state.size).toBe(0);
+  });
+});
+
+describe("applyTaskUpdate", () => {
+  it("removes the entry when status is deleted", () => {
+    const state: TaskState = new Map([
+      ["t1", { subject: "x", status: "pending" as const }],
+    ]);
+    applyTaskUpdate(state, { taskId: "t1", status: "deleted" });
+    expect(state.has("t1")).toBe(false);
+  });
+
+  it("merges partial fields, preserving existing values", () => {
+    const state: TaskState = new Map([
+      [
+        "t1",
+        {
+          subject: "Existing subject",
+          status: "pending" as const,
+          activeForm: "Doing",
+          description: "Existing description",
+        },
+      ],
+    ]);
+    applyTaskUpdate(state, { taskId: "t1", status: "in_progress" });
+    expect(state.get("t1")).toEqual({
+      subject: "Existing subject",
+      status: "in_progress",
+      activeForm: "Doing",
+      description: "Existing description",
+    });
+  });
+
+  it("is a no-op when no existing entry and no subject in input", () => {
+    const state: TaskState = new Map();
+    applyTaskUpdate(state, { taskId: "t1", status: "completed" });
+    expect(state.size).toBe(0);
+  });
+
+  it("creates a new entry when input provides a subject", () => {
+    const state: TaskState = new Map();
+    applyTaskUpdate(state, {
+      taskId: "t1",
+      subject: "Brand new",
+      status: "in_progress",
+    });
+    expect(state.get("t1")?.subject).toBe("Brand new");
+    expect(state.get("t1")?.status).toBe("in_progress");
+  });
+
+  it("is a no-op when input has no taskId", () => {
+    const state: TaskState = new Map();
+    applyTaskUpdate(state, undefined);
+    expect(state.size).toBe(0);
+  });
+});
+
+describe("rehydrateTaskState", () => {
+  it("rebuilds the map from TaskCreate + TaskUpdate transcripts", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        assistantMsg([
+          {
+            type: "tool_use",
+            id: "u1",
+            name: "TaskCreate",
+            input: { subject: "First", activeForm: "Doing first" },
+          },
+        ]),
+        userMsg([
+          {
+            type: "tool_result",
+            tool_use_id: "u1",
+            content: '{"task":{"id":"t1","subject":"First"}}',
+          },
+        ]),
+        assistantMsg([
+          {
+            type: "tool_use",
+            id: "u2",
+            name: "TaskUpdate",
+            input: { taskId: "t1", status: "in_progress" },
+          },
+        ]),
+        userMsg([
+          {
+            type: "tool_result",
+            tool_use_id: "u2",
+            content: "ok",
+          },
+        ]),
+      ],
+      state,
+    );
+    expect(state.get("t1")).toEqual({
+      subject: "First",
+      status: "in_progress",
+      activeForm: "Doing first",
+      description: undefined,
+    });
+  });
+
+  it("ignores tool_result blocks for non-Task tools", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        assistantMsg([
+          { type: "tool_use", id: "r1", name: "Read", input: { file: "a" } },
+        ]),
+        userMsg([
+          { type: "tool_result", tool_use_id: "r1", content: "file contents" },
+        ]),
+      ],
+      state,
+    );
+    expect(state.size).toBe(0);
+  });
+
+  it("skips errored Task tool results", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        assistantMsg([
+          {
+            type: "tool_use",
+            id: "u1",
+            name: "TaskCreate",
+            input: { subject: "x" },
+          },
+        ]),
+        userMsg([
+          {
+            type: "tool_result",
+            tool_use_id: "u1",
+            content: '{"task":{"id":"t1","subject":"x"}}',
+            is_error: true,
+          },
+        ]),
+      ],
+      state,
+    );
+    expect(state.size).toBe(0);
+  });
+
+  it("honors deletes from TaskUpdate", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        assistantMsg([
+          {
+            type: "tool_use",
+            id: "u1",
+            name: "TaskCreate",
+            input: { subject: "x" },
+          },
+        ]),
+        userMsg([
+          {
+            type: "tool_result",
+            tool_use_id: "u1",
+            content: '{"task":{"id":"t1","subject":"x"}}',
+          },
+        ]),
+        assistantMsg([
+          {
+            type: "tool_use",
+            id: "u2",
+            name: "TaskUpdate",
+            input: { taskId: "t1", status: "deleted" },
+          },
+        ]),
+        userMsg([{ type: "tool_result", tool_use_id: "u2", content: "ok" }]),
+      ],
+      state,
+    );
+    expect(state.has("t1")).toBe(false);
+  });
+
+  it("ignores tool_result without a matching tool_use", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        userMsg([
+          {
+            type: "tool_result",
+            tool_use_id: "orphan",
+            content: '{"task":{"id":"t9","subject":"x"}}',
+          },
+        ]),
+      ],
+      state,
+    );
+    expect(state.size).toBe(0);
+  });
+
+  it("ignores messages with non-array content", () => {
+    const state: TaskState = new Map();
+    rehydrateTaskState(
+      [
+        {
+          type: "user",
+          uuid: "u",
+          session_id: "s",
+          parent_tool_use_id: null,
+          message: { role: "user", content: "plain string" },
+        } as SessionMessage,
+      ],
+      state,
+    );
+    expect(state.size).toBe(0);
+  });
+});
+
+describe("taskStateToPlanEntries", () => {
+  it("returns an empty array for an empty state", () => {
+    expect(taskStateToPlanEntries(new Map())).toEqual([]);
+  });
+
+  it("preserves Map insertion order", () => {
+    const state: TaskState = new Map();
+    state.set("c", { subject: "third", status: "pending" });
+    state.set("a", { subject: "first", status: "in_progress" });
+    state.set("b", { subject: "second", status: "completed" });
+    const entries = taskStateToPlanEntries(state);
+    expect(entries.map((e) => e.content)).toEqual(["third", "first", "second"]);
+    expect(entries.map((e) => e.status)).toEqual([
+      "pending",
+      "in_progress",
+      "completed",
+    ]);
+  });
+
+  it("hardcodes priority to medium", () => {
+    const state: TaskState = new Map([
+      ["t1", { subject: "x", status: "pending" }],
+    ]);
+    expect(taskStateToPlanEntries(state)[0].priority).toBe("medium");
+  });
+});