@posthog/agent 2.3.735 → 2.3.736

package/src/adapters/claude/session/models.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import {
+  getEffortOptions,
+  resolveModelPreference,
+  supports1MContext,
+  supportsEffort,
+  supportsMcpInjection,
+  supportsXhighEffort,
+  toSdkModelId,
+} from "./models";
+
+describe("toSdkModelId", () => {
+  it("maps known gateway IDs to SDK aliases", () => {
+    expect(toSdkModelId("claude-opus-4-7")).toBe("opus");
+    expect(toSdkModelId("claude-opus-4-8")).toBe("opus");
+    expect(toSdkModelId("claude-sonnet-4-6")).toBe("sonnet");
+    expect(toSdkModelId("claude-haiku-4-5")).toBe("haiku");
+  });
+
+  it("passes unknown IDs through unchanged", () => {
+    expect(toSdkModelId("custom-model")).toBe("custom-model");
+  });
+});
+
+describe("model capability flags", () => {
+  it("flags 1M context support", () => {
+    expect(supports1MContext("claude-opus-4-7")).toBe(true);
+    expect(supports1MContext("claude-sonnet-4-6")).toBe(true);
+    expect(supports1MContext("claude-haiku-4-5")).toBe(false);
+  });
+
+  it("flags effort support and xhigh-effort support", () => {
+    expect(supportsEffort("claude-opus-4-5")).toBe(true);
+    expect(supportsXhighEffort("claude-opus-4-7")).toBe(true);
+    expect(supportsXhighEffort("claude-opus-4-5")).toBe(false);
+    expect(supportsEffort("claude-haiku-4-5")).toBe(false);
+  });
+
+  it("excludes MCP injection only for Haiku", () => {
+    expect(supportsMcpInjection("claude-opus-4-7")).toBe(true);
+    expect(supportsMcpInjection("claude-haiku-4-5")).toBe(false);
+  });
+});
+
+describe("getEffortOptions", () => {
+  it("returns null for models without effort support", () => {
+    expect(getEffortOptions("claude-haiku-4-5")).toBeNull();
+  });
+
+  it("returns low/medium/high for effort-supporting models", () => {
+    const opts = getEffortOptions("claude-opus-4-5");
+    expect(opts?.map((o) => o.value)).toEqual(["low", "medium", "high"]);
+  });
+
+  it("appends xhigh and max for xhigh-supporting models", () => {
+    const opts = getEffortOptions("claude-opus-4-7");
+    expect(opts?.map((o) => o.value)).toEqual([
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max",
+    ]);
+  });
+});
+
+describe("resolveModelPreference", () => {
+  const options = [
+    { value: "claude-opus-4-8", name: "Claude Opus 4.8" },
+    { value: "claude-opus-4-7", name: "Claude Opus 4.7" },
+    { value: "claude-opus-4-6", name: "Claude Opus 4.6" },
+    { value: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+    { value: "claude-haiku-4-5", name: "Claude Haiku 4.5" },
+  ];
+
+  it("returns null for empty preference", () => {
+    expect(resolveModelPreference("", options)).toBeNull();
+    expect(resolveModelPreference("   ", options)).toBeNull();
+  });
+
+  it("matches an exact value", () => {
+    expect(resolveModelPreference("claude-opus-4-7", options)).toBe(
+      "claude-opus-4-7",
+    );
+  });
+
+  it("matches case-insensitively on display name", () => {
+    expect(resolveModelPreference("claude haiku 4.5", options)).toBe(
+      "claude-haiku-4-5",
+    );
+  });
+
+  it("matches by substring", () => {
+    expect(resolveModelPreference("sonnet", options)).toBe("claude-sonnet-4-6");
+  });
+
+  it("matches by token alias", () => {
+    expect(resolveModelPreference("opus[1m]", options)).toBe("claude-opus-4-8");
+  });
+
+  it("refuses cross-version alias matches", () => {
+    const optionsWithAlias = [
+      { value: "opus", name: "Claude Opus 4.7" },
+      { value: "claude-opus-4-6", name: "Claude Opus 4.6" },
+    ];
+    expect(resolveModelPreference("claude-opus-4-6", optionsWithAlias)).toBe(
+      "claude-opus-4-6",
+    );
+  });
+
+  it("returns null when nothing matches", () => {
+    expect(resolveModelPreference("gpt-5", options)).toBeNull();
+  });
+
+  it("treats `best` and `default` as wildcards (no tokens contribute)", () => {
+    expect(resolveModelPreference("best", options)).toBeNull();
+    expect(resolveModelPreference("default", options)).toBeNull();
+  });
+});

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

@@ -4,6 +4,7 @@ const GATEWAY_TO_SDK_MODEL: Record<string, string> = {
   "claude-opus-4-5": "opus",
   "claude-opus-4-6": "opus",
   "claude-opus-4-7": "opus",
+  "claude-opus-4-8": "opus",
   "claude-sonnet-4-5": "sonnet",
   "claude-sonnet-4-6": "sonnet",
   "claude-haiku-4-5": "haiku",
@@ -16,6 +17,7 @@ export function toSdkModelId(modelId: string): string {
 const MODELS_WITH_1M_CONTEXT = new Set([
   "claude-opus-4-6",
   "claude-opus-4-7",
+  "claude-opus-4-8",
   "claude-sonnet-4-6",
 ]);
 
@@ -27,12 +29,14 @@ const MODELS_WITH_EFFORT = new Set([
   "claude-opus-4-5",
   "claude-opus-4-6",
   "claude-opus-4-7",
+  "claude-opus-4-8",
   "claude-sonnet-4-6",
 ]);
 
 const MODELS_WITH_XHIGH_EFFORT = new Set([
   "claude-opus-4-6",
   "claude-opus-4-7",
+  "claude-opus-4-8",
 ]);
 
 export function supportsEffort(modelId: string): boolean {
@@ -107,6 +111,31 @@ interface ModelOption {
   description?: string;
 }
 
+// Captures a model family version such as `4-6` or `4.7` so we can keep
+// `claude-opus-4-6` from being copied onto the SDK's `opus` alias when that
+// alias currently resolves to a different family version (e.g. Opus 4.7).
+const MODEL_FAMILY_VERSION_PATTERN = /\b(\d+)[-.](\d+)\b/;
+
+function extractModelFamilyVersion(s: string | undefined): string | null {
+  if (!s) return null;
+  const match = s.match(MODEL_FAMILY_VERSION_PATTERN);
+  return match ? `${match[1]}.${match[2]}` : null;
+}
+
+function modelVersionsCompatible(
+  preference: string,
+  candidate: ModelOption,
+): boolean {
+  const preferred = extractModelFamilyVersion(preference);
+  if (!preferred) return true;
+  const candidateVersion =
+    extractModelFamilyVersion(candidate.value) ??
+    extractModelFamilyVersion(candidate.name) ??
+    extractModelFamilyVersion(candidate.description);
+  if (!candidateVersion) return true;
+  return preferred === candidateVersion;
+}
+
 function scoreModelMatch(
   model: ModelOption,
   tokens: string[],
@@ -142,6 +171,7 @@ export function resolveModelPreference(
 
   // Substring match
   const includesMatch = options.find((o) => {
+    if (!modelVersionsCompatible(trimmed, o)) return false;
     const value = o.value.toLowerCase();
     const display = (o.name ?? "").toLowerCase();
     return (
@@ -157,6 +187,7 @@ export function resolveModelPreference(
   let bestMatch: ModelOption | null = null;
   let bestScore = 0;
   for (const model of options) {
+    if (!modelVersionsCompatible(trimmed, model)) continue;
     const score = scoreModelMatch(model, tokens, contextHint);
     if (0 < score && (!bestMatch || bestScore < score)) {
       bestMatch = model;

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

@@ -17,6 +17,7 @@ function makeParams() {
     sessionId: "test-session",
     isResume: false,
     settingsManager: new SettingsManager(cwd),
+    taskState: new Map(),
   };
 }
 

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

@@ -13,12 +13,14 @@ import type {
 import type { FileEnrichmentDeps } from "../../../enrichment/file-enricher";
 import { IS_ROOT } from "../../../utils/common";
 import type { Logger } from "../../../utils/logger";
+import type { TaskState } from "../conversion/task-state";
 import {
   createPostToolUseHook,
   createPreToolUseHook,
   createReadEnrichmentHook,
   createSignedCommitGuardHook,
   createSubagentRewriteHook,
+  createTaskHook,
   type EnrichedReadCache,
   type OnModeChange,
 } from "../hooks";
@@ -58,6 +60,11 @@ export interface BuildOptionsParams {
   enrichedReadCache?: EnrichedReadCache;
   /** Cloud task session — enables the signed-commit guard. */
   cloudMode?: boolean;
+  /** Per-session task state populated by createTaskHook from SDK Task* events. */
+  taskState: TaskState;
+  /** Called after createTaskHook mutates taskState so callers can emit a plan
+   * sessionUpdate to the client. */
+  onTaskStateChange?: () => Promise<void>;
 }
 
 export function buildSystemPrompt(
@@ -111,6 +118,13 @@ function buildEnvironment(): Record<string, string> {
     ? `${existingCustomHeaders}\n${bedrockFallbackHeader}`
     : bedrockFallbackHeader;
 
+  // SDK 0.3.142 made MCP servers connect in the background by default. That
+  // default is what we want: a slow or unreachable user MCP server (PostHog
+  // MCP, custom stdio servers) would otherwise stall turn 1 by up to ~5s per
+  // server. We honor an explicit override from the caller's environment for
+  // sessions that genuinely need MCP tools available on turn 1.
+  const mcpNonblocking = process.env.MCP_CONNECTION_NONBLOCKING;
+
   return {
     ...process.env,
     ELECTRON_RUN_AS_NODE: "1",
@@ -119,6 +133,9 @@ function buildEnvironment(): Record<string, string> {
     ENABLE_TOOL_SEARCH: "auto:0",
     // Enable idle state as end-of-turn signal (required for SDK 0.2.114+)
     CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: "1",
+    ...(mcpNonblocking !== undefined && {
+      MCP_CONNECTION_NONBLOCKING: mcpNonblocking,
+    }),
     // Route to AWS Bedrock as a fallback when Anthropic returns 5xx
     ANTHROPIC_CUSTOM_HEADERS: customHeaders,
   };
@@ -133,6 +150,8 @@ function buildHooks(
   enrichedReadCache: EnrichedReadCache | undefined,
   registeredAgents: ReadonlySet<string>,
   cloudMode: boolean,
+  taskState: TaskState,
+  onTaskStateChange: (() => Promise<void>) | undefined,
 ): Options["hooks"] {
   const postToolUseHooks = [createPostToolUseHook({ onModeChange })];
   if (enrichmentDeps && enrichedReadCache) {
@@ -149,6 +168,8 @@ function buildHooks(
     preToolUseHooks.push(createSignedCommitGuardHook(logger));
   }
 
+  const taskHook = createTaskHook(taskState, onTaskStateChange);
+
   return {
     ...userHooks,
     PostToolUse: [
@@ -156,6 +177,8 @@ function buildHooks(
       { hooks: postToolUseHooks },
     ],
     PreToolUse: [...(userHooks?.PreToolUse || []), { hooks: preToolUseHooks }],
+    TaskCreated: [...(userHooks?.TaskCreated || []), { hooks: [taskHook] }],
+    TaskCompleted: [...(userHooks?.TaskCompleted || []), { hooks: [taskHook] }],
   };
 }
 
@@ -195,7 +218,10 @@ Rules:
     "WebFetch",
     "WebSearch",
     "NotebookRead",
-    "TodoWrite",
+    "TaskCreate",
+    "TaskUpdate",
+    "TaskGet",
+    "TaskList",
   ],
 };
 
@@ -357,6 +383,8 @@ export function buildSessionOptions(params: BuildOptionsParams): Options {
       params.enrichedReadCache,
       registeredAgentNames,
       params.cloudMode ?? false,
+      params.taskState,
+      params.onTaskStateChange,
     ),
     outputFormat: params.outputFormat,
     abortController: getAbortController(

package/src/adapters/claude/session/settings.test.ts

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { resolveMainRepoPath } from "./repo-path";
-import { SettingsManager } from "./settings";
+import { mergeAvailableModels, SettingsManager } from "./settings";
 
 function runGit(cwd: string, args: string[]): void {
   execFileSync("git", args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
@@ -207,3 +207,104 @@ describe("resolveMainRepoPath", () => {
     }
   });
 });
+
+describe("availableModels merge", () => {
+  let tmpRoot: string;
+  let cwd: string;
+  let configDir: string;
+  let originalConfigDir: string | undefined;
+
+  beforeEach(async () => {
+    tmpRoot = await fs.promises.realpath(
+      await fs.promises.mkdtemp(path.join(os.tmpdir(), "available-models-")),
+    );
+    cwd = path.join(tmpRoot, "repo");
+    configDir = path.join(tmpRoot, "user");
+    await fs.promises.mkdir(cwd, { recursive: true });
+    await fs.promises.mkdir(configDir, { recursive: true });
+    runGit(cwd, ["init", "-b", "main"]);
+    runGit(cwd, ["config", "user.email", "test@example.com"]);
+    runGit(cwd, ["config", "user.name", "test"]);
+    runGit(cwd, ["commit", "--allow-empty", "-m", "init"]);
+
+    originalConfigDir = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = configDir;
+  });
+
+  afterEach(async () => {
+    if (originalConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR;
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalConfigDir;
+    }
+    await fs.promises.rm(tmpRoot, { recursive: true, force: true });
+  });
+
+  async function writeUserSettings(settings: object): Promise<void> {
+    await fs.promises.writeFile(
+      path.join(configDir, "settings.json"),
+      JSON.stringify(settings),
+    );
+  }
+
+  async function writeProjectSettings(settings: object): Promise<void> {
+    const projectDir = path.join(cwd, ".claude");
+    await fs.promises.mkdir(projectDir, { recursive: true });
+    await fs.promises.writeFile(
+      path.join(projectDir, "settings.json"),
+      JSON.stringify(settings),
+    );
+  }
+
+  it("merges and dedupes availableModels across user and project layers", async () => {
+    await writeUserSettings({ availableModels: ["model-a", "model-b"] });
+    await writeProjectSettings({ availableModels: ["model-b", "model-c"] });
+
+    const manager = new SettingsManager(cwd);
+    await manager.initialize();
+
+    expect(manager.getSettings().availableModels).toEqual([
+      "model-a",
+      "model-b",
+      "model-c",
+    ]);
+  });
+
+  it("passes through a single layer unchanged", async () => {
+    await writeProjectSettings({ availableModels: ["only-one"] });
+
+    const manager = new SettingsManager(cwd);
+    await manager.initialize();
+
+    expect(manager.getSettings().availableModels).toEqual(["only-one"]);
+  });
+
+  it("leaves availableModels undefined when no layer defines it", async () => {
+    const manager = new SettingsManager(cwd);
+    await manager.initialize();
+
+    expect(manager.getSettings().availableModels).toBeUndefined();
+  });
+});
+
+describe("mergeAvailableModels", () => {
+  it("merges and dedupes non-enterprise layers", () => {
+    expect(
+      mergeAvailableModels(
+        ["model-a", "model-b"],
+        ["model-b", "model-c"],
+        "project",
+      ),
+    ).toEqual(["model-a", "model-b", "model-c"]);
+  });
+
+  it("lets enterprise settings replace lower-precedence allowlists", () => {
+    expect(
+      mergeAvailableModels(
+        ["model-a", "model-b"],
+        ["managed-a", "managed-a"],
+        "enterprise",
+      ),
+    ).toEqual(["managed-a"]);
+  });
+});

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

@@ -196,9 +196,12 @@ export interface ClaudeCodeSettings {
   permissions?: PermissionSettings;
   env?: Record<string, string>;
   model?: string;
+  availableModels?: string[];
   posthogApprovedExecTools?: string[];
 }
 
+type SettingsLayer = "user" | "project" | "local" | "enterprise";
+
 export type PermissionDecision = "allow" | "deny" | "ask";
 
 export interface PermissionCheckResult {
@@ -220,6 +223,22 @@ export function getManagedSettingsPath(): string {
   }
 }
 
+export function mergeAvailableModels(
+  existing: string[] | undefined,
+  incoming: string[] | undefined,
+  layer: SettingsLayer,
+): string[] | undefined {
+  if (incoming === undefined) {
+    return existing;
+  }
+
+  if (layer === "enterprise") {
+    return Array.from(new Set(incoming));
+  }
+
+  return Array.from(new Set([...(existing ?? []), ...incoming]));
+}
+
 export class SettingsManager {
   private cwd: string;
   private repoRoot: string;
@@ -283,11 +302,14 @@ export class SettingsManager {
   }
 
   private mergeAllSettings(): void {
-    const allSettings = [
-      this.userSettings,
-      this.projectSettings,
-      this.localSettings,
-      this.enterpriseSettings,
+    const allSettings: Array<{
+      layer: SettingsLayer;
+      settings: ClaudeCodeSettings;
+    }> = [
+      { layer: "user", settings: this.userSettings },
+      { layer: "project", settings: this.projectSettings },
+      { layer: "local", settings: this.localSettings },
+      { layer: "enterprise", settings: this.enterpriseSettings },
     ];
 
     const permissions: PermissionSettings = {
@@ -298,7 +320,7 @@ export class SettingsManager {
     const merged: ClaudeCodeSettings = { permissions };
     const posthogApprovedExecTools = new Set<string>();
 
-    for (const settings of allSettings) {
+    for (const { layer, settings } of allSettings) {
       if (settings.permissions) {
         if (settings.permissions.allow) {
           permissions.allow?.push(...settings.permissions.allow);
@@ -325,6 +347,11 @@ export class SettingsManager {
       if (settings.model) {
         merged.model = settings.model;
       }
+      merged.availableModels = mergeAvailableModels(
+        merged.availableModels,
+        settings.availableModels,
+        layer,
+      );
       if (settings.posthogApprovedExecTools) {
         for (const tool of settings.posthogApprovedExecTools) {
           posthogApprovedExecTools.add(tool);

package/src/adapters/claude/tools.ts

@@ -29,8 +29,10 @@ export const WEB_TOOLS: Set<string> = new Set(["WebSearch", "WebFetch"]);
 export const AGENT_TOOLS: Set<string> = new Set([
   "Task",
   "Agent",
-  "TodoWrite",
-  "Skill",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskGet",
+  "TaskList",
 ]);
 
 const BASE_ALLOWED_TOOLS = [

package/src/adapters/claude/types.ts

@@ -11,6 +11,7 @@ import type {
 import type { Pushable } from "../../utils/streams";
 import type { BaseSession } from "../base-acp-agent";
 import type { ContextBreakdownBaseline } from "./context-breakdown";
+import type { TaskState } from "./conversion/task-state";
 import type { McpToolApprovals } from "./mcp/tool-metadata";
 import type { SettingsManager } from "./session/settings";
 import type { CodeExecutionMode } from "./tools";
@@ -75,6 +76,13 @@ export type Session = BaseSession & {
    * "command is genuinely unknown" when the session goes idle without an echo.
    */
   knownSlashCommands?: Set<string>;
+  /**
+   * Per-session task list accumulated from Task* tool calls.
+   * SDK >=0.3.142 replaced TodoWrite (snapshot) with TaskCreate/TaskUpdate
+   * (incremental, keyed by task id). Map iteration preserves insertion order
+   * which we use for plan entry ordering.
+   */
+  taskState: TaskState;
 };
 
 export type ToolUseCache = {

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

@@ -466,7 +466,7 @@ export class CodexAcpAgent extends BaseAcpAgent {
 
     // Carry taskRunId/taskId across load so prompt() still emits cloud
     // notifications (TURN_COMPLETE, USAGE_UPDATE) after a reload. newSession
-    // and unstable_resumeSession both do this; loadSession historically did
+    // and resumeSession both do this; loadSession historically did
     // not, which silently broke task-completion tracking on re-attach.
     resetSessionState(this.sessionState, params.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
@@ -489,7 +489,7 @@ export class CodexAcpAgent extends BaseAcpAgent {
     return response;
   }
 
-  async unstable_resumeSession(
+  async resumeSession(
     params: ResumeSessionRequest,
   ): Promise<ResumeSessionResponse> {
     const meta = params._meta as NewSessionMeta | undefined;