@posthog/agent 2.3.735 → 2.3.736

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

@@ -0,0 +1,178 @@
+import type { PlanEntry } from "@agentclientprotocol/sdk";
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  TaskCreateInput,
+  TaskCreateOutput,
+  TaskUpdateInput,
+} from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
+
+export type TaskEntry = {
+  subject: string;
+  status: "pending" | "in_progress" | "completed";
+  activeForm?: string;
+  description?: string;
+};
+
+export type TaskState = Map<string, TaskEntry>;
+
+export function parseTaskCreateOutput(
+  content: unknown,
+): TaskCreateOutput | undefined {
+  const tryParse = (text: string): TaskCreateOutput | undefined => {
+    try {
+      const parsed = JSON.parse(text);
+      if (
+        parsed &&
+        typeof parsed === "object" &&
+        parsed.task &&
+        typeof parsed.task.id === "string"
+      ) {
+        return parsed as TaskCreateOutput;
+      }
+    } catch {
+      // ignore
+    }
+    return undefined;
+  };
+
+  if (typeof content === "string") {
+    return tryParse(content);
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (
+        block &&
+        typeof block === "object" &&
+        "type" in block &&
+        block.type === "text"
+      ) {
+        const text = (block as { text?: unknown }).text;
+        if (typeof text === "string") {
+          const parsed = tryParse(text);
+          if (parsed) return parsed;
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+export function applyTaskCreate(
+  state: TaskState,
+  input: TaskCreateInput | undefined,
+  output: TaskCreateOutput | undefined,
+): void {
+  const taskId = output?.task?.id;
+  if (!taskId || !input) return;
+  state.set(taskId, {
+    subject: input.subject,
+    status: "pending",
+    activeForm: input.activeForm,
+    description: input.description,
+  });
+}
+
+export function applyTaskUpdate(
+  state: TaskState,
+  input: TaskUpdateInput | undefined,
+): void {
+  if (!input?.taskId) return;
+  if (input.status === "deleted") {
+    state.delete(input.taskId);
+    return;
+  }
+  const existing = state.get(input.taskId);
+  const subject = input.subject ?? existing?.subject;
+  if (!subject) return;
+  state.set(input.taskId, {
+    subject,
+    status: input.status ?? existing?.status ?? "pending",
+    activeForm: input.activeForm ?? existing?.activeForm,
+    description: input.description ?? existing?.description,
+  });
+}
+
+export function taskStateToPlanEntries(state: TaskState): PlanEntry[] {
+  return Array.from(state.values()).map((task) => ({
+    content: task.subject,
+    status: task.status,
+    priority: "medium",
+  }));
+}
+
+type ToolUseBlock = {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input?: unknown;
+};
+
+type ToolResultBlock = {
+  type: "tool_result";
+  tool_use_id: string;
+  content?: unknown;
+  is_error?: boolean;
+};
+
+function isToolUseBlock(block: unknown): block is ToolUseBlock {
+  return (
+    !!block &&
+    typeof block === "object" &&
+    (block as { type?: unknown }).type === "tool_use" &&
+    typeof (block as { id?: unknown }).id === "string" &&
+    typeof (block as { name?: unknown }).name === "string"
+  );
+}
+
+function isToolResultBlock(block: unknown): block is ToolResultBlock {
+  return (
+    !!block &&
+    typeof block === "object" &&
+    (block as { type?: unknown }).type === "tool_result" &&
+    typeof (block as { tool_use_id?: unknown }).tool_use_id === "string"
+  );
+}
+
+/**
+ * Rebuild `state` from a JSONL message transcript by replaying Task tool
+ * inputs/outputs. Used by `resumeSession` to recover the plan panel when the
+ * agent restarts mid-conversation; `loadSession` covers the same ground via
+ * the full notification replay in `replaySessionHistory`.
+ */
+export function rehydrateTaskState(
+  messages: ReadonlyArray<SessionMessage>,
+  state: TaskState,
+): void {
+  const pendingInputs = new Map<string, { name: string; input: unknown }>();
+  for (const msg of messages) {
+    const content = (msg.message as { content?: unknown } | null | undefined)
+      ?.content;
+    if (!Array.isArray(content)) continue;
+    if (msg.type === "assistant") {
+      for (const block of content) {
+        if (
+          isToolUseBlock(block) &&
+          (block.name === "TaskCreate" || block.name === "TaskUpdate")
+        ) {
+          pendingInputs.set(block.id, { name: block.name, input: block.input });
+        }
+      }
+    } else if (msg.type === "user") {
+      for (const block of content) {
+        if (!isToolResultBlock(block) || block.is_error) continue;
+        const cached = pendingInputs.get(block.tool_use_id);
+        if (!cached) continue;
+        if (cached.name === "TaskCreate") {
+          applyTaskCreate(
+            state,
+            cached.input as TaskCreateInput | undefined,
+            parseTaskCreateOutput(block.content),
+          );
+        } else if (cached.name === "TaskUpdate") {
+          applyTaskUpdate(state, cached.input as TaskUpdateInput | undefined);
+        }
+        pendingInputs.delete(block.tool_use_id);
+      }
+    }
+  }
+}

package/src/adapters/claude/conversion/tool-use-to-acp.ts

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import type {
-  PlanEntry,
   ToolCall,
   ToolCallContent,
   ToolCallLocation,
@@ -371,11 +370,36 @@ export function toolInfoFromToolUse(
       };
     }
 
-    case "TodoWrite":
+    case "TaskCreate": {
+      const subject =
+        typeof input?.subject === "string" ? input.subject : undefined;
       return {
-        title: Array.isArray(input?.todos)
-          ? `Update TODOs: ${input.todos.map((todo: { content?: string }) => todo.content).join(", ")}`
-          : "Update TODOs",
+        title: subject ? `Create task: ${subject}` : "Create task",
+        kind: "think",
+        content: [],
+      };
+    }
+
+    case "TaskUpdate": {
+      const subject =
+        typeof input?.subject === "string" ? input.subject : undefined;
+      return {
+        title: subject ? `Update task: ${subject}` : "Update task",
+        kind: "think",
+        content: [],
+      };
+    }
+
+    case "TaskList":
+      return {
+        title: "List tasks",
+        kind: "think",
+        content: [],
+      };
+
+    case "TaskGet":
+      return {
+        title: "Get task",
         kind: "think",
         content: [],
       };
@@ -775,20 +799,6 @@ function toAcpContentUpdate(
   return {};
 }
 
-export type ClaudePlanEntry = {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-  activeForm: string;
-};
-
-export function planEntries(input: { todos: ClaudePlanEntry[] }): PlanEntry[] {
-  return input.todos.map((input) => ({
-    content: input.content,
-    status: input.status,
-    priority: "medium",
-  }));
-}
-
 /**
  * attempt to resolve full file contents for diff generation
  *

package/src/adapters/claude/hooks.test.ts

@@ -8,10 +8,12 @@ vi.mock("../../enrichment/file-enricher", () => ({
 }));
 
 import { Logger } from "../../utils/logger";
+import type { TaskState } from "./conversion/task-state";
 import {
   createPreToolUseHook,
   createReadEnrichmentHook,
   createSignedCommitGuardHook,
+  createTaskHook,
   type EnrichedReadCache,
 } from "./hooks";
 import type {
@@ -365,3 +367,163 @@ describe("createSignedCommitGuardHook", () => {
     expect(result).toEqual({ continue: true });
   });
 });
+
+describe("createTaskHook", () => {
+  const baseInput = {
+    session_id: "s",
+    transcript_path: "/tmp/t",
+    cwd: "/tmp",
+  };
+
+  test("ignores hook events without a task_id", async () => {
+    const state: TaskState = new Map();
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    const result = await hook(
+      { ...baseInput, hook_event_name: "PostToolUse" } as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(result).toEqual({ continue: true });
+    expect(state.size).toBe(0);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("TaskCreated inserts a pending entry and fires onChange", async () => {
+    const state: TaskState = new Map();
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    const result = await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCreated",
+        task_id: "t1",
+        task_subject: "Fix bug",
+        task_description: "details",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(result).toEqual({ continue: true });
+    expect(state.get("t1")).toEqual({
+      subject: "Fix bug",
+      status: "pending",
+      description: "details",
+    });
+    expect(onChange).toHaveBeenCalledOnce();
+  });
+
+  test("TaskCreated is idempotent for an existing task_id", async () => {
+    const state: TaskState = new Map([
+      [
+        "t1",
+        {
+          subject: "Original",
+          status: "in_progress" as const,
+        },
+      ],
+    ]);
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCreated",
+        task_id: "t1",
+        task_subject: "Overwrite attempt",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(state.get("t1")?.subject).toBe("Original");
+    expect(state.get("t1")?.status).toBe("in_progress");
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("TaskCreated without task_subject is a no-op", async () => {
+    const state: TaskState = new Map();
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCreated",
+        task_id: "t1",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(state.size).toBe(0);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("TaskCompleted flips status and fires onChange", async () => {
+    const state: TaskState = new Map([
+      ["t1", { subject: "Existing", status: "in_progress" as const }],
+    ]);
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCompleted",
+        task_id: "t1",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(state.get("t1")?.status).toBe("completed");
+    expect(onChange).toHaveBeenCalledOnce();
+  });
+
+  test("TaskCompleted is a no-op for unknown task_id", async () => {
+    const state: TaskState = new Map();
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCompleted",
+        task_id: "unknown",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(state.size).toBe(0);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("TaskCompleted is a no-op for already-completed task", async () => {
+    const state: TaskState = new Map([
+      ["t1", { subject: "Existing", status: "completed" as const }],
+    ]);
+    const onChange = vi.fn(async () => {});
+    const hook = createTaskHook(state, onChange);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCompleted",
+        task_id: "t1",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("works without an onChange callback", async () => {
+    const state: TaskState = new Map();
+    const hook = createTaskHook(state);
+    await hook(
+      {
+        ...baseInput,
+        hook_event_name: "TaskCreated",
+        task_id: "t1",
+        task_subject: "Fix bug",
+      } as unknown as HookInput,
+      undefined,
+      { signal: new AbortController().signal },
+    );
+    expect(state.get("t1")?.subject).toBe("Fix bug");
+  });
+});

package/src/adapters/claude/hooks.ts

@@ -6,6 +6,7 @@ import {
 import type { Logger } from "../../utils/logger";
 import { SIGNED_COMMIT_QUALIFIED_TOOL_NAME } from "../signed-commit-shared";
 import { stripCatLineNumbers } from "./conversion/sdk-to-acp";
+import type { TaskState } from "./conversion/task-state";
 import {
   extractPostHogSubTool,
   isPostHogDestructiveSubTool,
@@ -129,6 +130,48 @@ export const registerHookCallback = (
   };
 };
 
+/**
+ * Pre-populate the per-session task list from SDK TaskCreated/TaskCompleted
+ * hook events. These fire before the matching tool_result chunk arrives, so
+ * by the time TaskUpdate runs (which only carries taskId + status) the entry
+ * already exists with a real subject — no placeholder with empty content.
+ *
+ * Plan-update emission happens in the tool_result handler, which mirrors the
+ * old TodoWrite suppress-tool-call + emit-plan flow.
+ */
+export const createTaskHook =
+  (taskState: TaskState, onChange?: () => Promise<void>): HookCallback =>
+  async (input: HookInput): Promise<{ continue: boolean }> => {
+    const taskId =
+      "task_id" in input && typeof input.task_id === "string"
+        ? input.task_id
+        : undefined;
+    if (!taskId) return { continue: true };
+
+    let mutated = false;
+    if (input.hook_event_name === "TaskCreated") {
+      if (!input.task_subject) return { continue: true };
+      // Guard against the SDK firing TaskCreated twice for the same id —
+      // re-entry would clobber any TaskUpdate that landed in between.
+      if (taskState.has(taskId)) return { continue: true };
+      taskState.set(taskId, {
+        subject: input.task_subject,
+        status: "pending",
+        description: input.task_description,
+      });
+      mutated = true;
+    } else if (input.hook_event_name === "TaskCompleted") {
+      const existing = taskState.get(taskId);
+      if (!existing || existing.status === "completed") {
+        return { continue: true };
+      }
+      taskState.set(taskId, { ...existing, status: "completed" });
+      mutated = true;
+    }
+    if (mutated && onChange) await onChange();
+    return { continue: true };
+  };
+
 export type OnModeChange = (mode: CodeExecutionMode) => Promise<void>;
 
 interface CreatePostToolUseHookParams {
@@ -157,10 +200,8 @@ export const createPostToolUseHook =
             input.tool_input,
             input.tool_response,
           );
-          delete toolUseCallbacks[toolUseID];
-        } else {
-          delete toolUseCallbacks[toolUseID];
         }
+        delete toolUseCallbacks[toolUseID];
       }
     }
     return { continue: true };

package/src/adapters/claude/permissions/permission-options.ts

@@ -85,8 +85,13 @@ export function buildPermissionOptions(
     return permissionOptions("Yes, allow all sub-tasks");
   }
 
-  if (toolName === "TodoWrite") {
-    return permissionOptions("Yes, allow all todo updates");
+  if (
+    toolName === "TaskCreate" ||
+    toolName === "TaskUpdate" ||
+    toolName === "TaskGet" ||
+    toolName === "TaskList"
+  ) {
+    return permissionOptions("Yes, allow all task updates");
   }
 
   return permissionOptions("Yes, always allow");

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

@@ -2,6 +2,7 @@ import type { AvailableCommand } from "@agentclientprotocol/sdk";
 import type { SlashCommand } from "@anthropic-ai/claude-agent-sdk";
 
 const UNSUPPORTED_COMMANDS = [
+  "clear",
   "context",
   "cost",
   "keybindings-help",

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

@@ -48,6 +48,7 @@ export function loadUserClaudeJsonMcpServers(
 
 export function parseMcpServers(
   params: Pick<NewSessionRequest, "mcpServers">,
+  logger?: Logger,
 ): Record<string, McpServerConfig> {
   const mcpServers: Record<string, McpServerConfig> = {};
   if (!Array.isArray(params.mcpServers)) {
@@ -56,13 +57,28 @@ export function parseMcpServers(
 
   for (const server of params.mcpServers) {
     if ("type" in server) {
-      mcpServers[server.name] = {
-        type: server.type,
-        url: server.url,
-        headers: server.headers
-          ? Object.fromEntries(server.headers.map((e) => [e.name, e.value]))
-          : undefined,
-      };
+      if (server.type === "http" || server.type === "sse") {
+        mcpServers[server.name] = {
+          type: server.type,
+          url: server.url,
+          headers: server.headers
+            ? Object.fromEntries(
+                server.headers.map((e: { name: string; value: string }) => [
+                  e.name,
+                  e.value,
+                ]),
+              )
+            : undefined,
+        };
+      } else {
+        // ACP 0.22 introduced the `sdk` McpServerConfig variant; the SDK
+        // adapter doesn't construct in-process servers, so surface a warning
+        // rather than silently dropping the entry.
+        logger?.warn("parseMcpServers: dropping unsupported MCP server type", {
+          name: server.name,
+          type: (server as { type: string }).type,
+        });
+      }
     } else {
       mcpServers[server.name] = {
         type: "stdio",

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyAvailableModelsAllowlist,
+  resolveInitialModelId,
+} from "./model-config";
+
+const rawModelOptions = {
+  currentModelId: "claude-opus-4-8",
+  options: [
+    { value: "claude-opus-4-8", name: "Claude Opus 4.8" },
+    { value: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+  ],
+};
+
+describe("applyAvailableModelsAllowlist", () => {
+  it("falls back to the unfiltered gateway list when every allowlisted model is unknown", () => {
+    expect(
+      applyAvailableModelsAllowlist(rawModelOptions, ["claude-opus-4-5"]),
+    ).toEqual(rawModelOptions);
+  });
+
+  it("switches the current model when the previous one is filtered out", () => {
+    expect(
+      applyAvailableModelsAllowlist(rawModelOptions, ["claude-sonnet-4-6"]),
+    ).toEqual({
+      currentModelId: "claude-sonnet-4-6",
+      options: [{ value: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" }],
+    });
+  });
+});
+
+describe("resolveInitialModelId", () => {
+  it("keeps a preferred model when it survives filtering", () => {
+    const filteredModelOptions = applyAvailableModelsAllowlist(
+      rawModelOptions,
+      ["claude-opus-4-8", "claude-sonnet-4-6"],
+    );
+
+    expect(
+      resolveInitialModelId(filteredModelOptions, [
+        "claude-opus-4-8",
+        "claude-sonnet-4-6",
+      ]),
+    ).toBe("claude-opus-4-8");
+  });
+
+  it("falls back to the filtered current model when the preferred one is disallowed", () => {
+    const filteredModelOptions = applyAvailableModelsAllowlist(
+      rawModelOptions,
+      ["claude-sonnet-4-6"],
+    );
+
+    expect(
+      resolveInitialModelId(filteredModelOptions, [
+        "claude-opus-4-8",
+        "claude-sonnet-4-6",
+      ]),
+    ).toBe("claude-sonnet-4-6");
+  });
+});

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

@@ -0,0 +1,56 @@
+import type { SessionConfigSelectOption } from "@agentclientprotocol/sdk";
+
+export interface ModelConfigOptions {
+  currentModelId: string;
+  options: SessionConfigSelectOption[];
+}
+
+/**
+ * Restrict gateway model options to the user's `availableModels` allowlist
+ * from settings.json. Unknown allowlist entries are dropped; if every entry
+ * is unknown we fall back to the gateway list as a safety net.
+ */
+export function applyAvailableModelsAllowlist(
+  modelOptions: ModelConfigOptions,
+  allowlist: string[],
+): ModelConfigOptions {
+  const filtered: SessionConfigSelectOption[] = [];
+  const seen = new Set<string>();
+
+  for (const entry of allowlist) {
+    const trimmed = entry.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+
+    const match = modelOptions.options.find((o) => o.value === trimmed);
+    if (match) {
+      filtered.push(match);
+      seen.add(trimmed);
+    }
+  }
+
+  if (filtered.length === 0) return modelOptions;
+
+  const currentModelId = filtered.some(
+    (o) => o.value === modelOptions.currentModelId,
+  )
+    ? modelOptions.currentModelId
+    : filtered[0].value;
+
+  return { currentModelId, options: filtered };
+}
+
+export function resolveInitialModelId(
+  modelOptions: ModelConfigOptions,
+  preferredModelIds: Array<string | undefined>,
+): string {
+  const allowedModelIds = new Set(modelOptions.options.map((opt) => opt.value));
+
+  for (const candidate of preferredModelIds) {
+    const trimmed = candidate?.trim();
+    if (trimmed && allowedModelIds.has(trimmed)) {
+      return trimmed;
+    }
+  }
+
+  return modelOptions.currentModelId;
+}