@posthog/agent 2.3.22 → 2.3.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.22",
+  "version": "2.3.31",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

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

@@ -59,7 +59,12 @@ import { fetchMcpToolMetadata } from "./mcp/tool-metadata";
 import { canUseTool } from "./permissions/permission-handlers";
 import { getAvailableSlashCommands } from "./session/commands";
 import { parseMcpServers } from "./session/mcp-config";
-import { DEFAULT_MODEL, toSdkModelId } from "./session/models";
+import {
+  DEFAULT_MODEL,
+  getDefaultContextWindow,
+  getEffortOptions,
+  toSdkModelId,
+} from "./session/models";
 import {
   buildSessionOptions,
   buildSystemPrompt,
@@ -337,7 +342,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               (m) => m.contextWindow,
             );
             const contextWindowSize =
-              contextWindows.length > 0 ? Math.min(...contextWindows) : 200000;
+              contextWindows.length > 0
+                ? Math.min(...contextWindows)
+                : getDefaultContextWindow(this.session.modelId ?? "");
 
             // Send usage_update notification
             if (lastAssistantTotalUsage !== null) {
@@ -509,6 +516,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     const sdkModelId = toSdkModelId(params.modelId);
     await this.session.query.setModel(sdkModelId);
     this.session.modelId = params.modelId;
+    this.rebuildEffortConfigOption(params.modelId);
     await this.updateConfigOption("model", params.modelId);
     return {};
   }
@@ -559,6 +567,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       const sdkModelId = toSdkModelId(params.value);
       await this.session.query.setModel(sdkModelId);
       this.session.modelId = params.value;
+      this.rebuildEffortConfigOption(params.value);
     } else if (params.configId === "effort") {
       const newEffort = params.value as EffortLevel;
       this.session.effort = newEffort;
@@ -865,7 +874,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       description: mode.description ?? undefined,
     }));
 
-    return [
+    const configOptions: SessionConfigOption[] = [
       {
         id: "mode",
         name: "Approval Preset",
@@ -885,21 +894,67 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         category: "model" as SessionConfigOptionCategory,
         description: "Choose which model Claude should use",
       },
-      {
+    ];
+
+    const effortOptions = getEffortOptions(modelOptions.currentModelId);
+    if (effortOptions) {
+      configOptions.push({
         id: "effort",
         name: "Effort",
         type: "select",
         currentValue: currentEffort,
-        options: [
-          { value: "low", name: "Low" },
-          { value: "medium", name: "Medium" },
-          { value: "high", name: "High" },
-          { value: "max", name: "Max" },
-        ],
+        options: effortOptions,
         category: "thought_level" as SessionConfigOptionCategory,
         description: "Controls how much effort Claude puts into its response",
-      },
-    ];
+      });
+    }
+
+    return configOptions;
+  }
+
+  private rebuildEffortConfigOption(modelId: string): void {
+    const effortOptions = getEffortOptions(modelId);
+    const existingEffort = this.session.configOptions.find(
+      (o) => o.id === "effort",
+    );
+
+    if (!effortOptions) {
+      this.session.configOptions = this.session.configOptions.filter(
+        (o) => o.id !== "effort",
+      );
+      if (this.session.effort) {
+        this.session.effort = undefined;
+        this.session.queryOptions.effort = undefined;
+      }
+      return;
+    }
+
+    const currentValue = existingEffort?.currentValue ?? "high";
+    const isValidValue = effortOptions.some((o) => o.value === currentValue);
+    const resolvedValue = isValidValue ? currentValue : "high";
+
+    if (resolvedValue !== currentValue && this.session.effort) {
+      this.session.effort = resolvedValue as EffortLevel;
+      this.session.queryOptions.effort = resolvedValue as EffortLevel;
+    }
+
+    const effortConfig: SessionConfigOption = {
+      id: "effort",
+      name: "Effort",
+      type: "select",
+      currentValue: resolvedValue,
+      options: effortOptions,
+      category: "thought_level" as SessionConfigOptionCategory,
+      description: "Controls how much effort Claude puts into its response",
+    };
+
+    if (existingEffort) {
+      this.session.configOptions = this.session.configOptions.map((o) =>
+        o.id === "effort" ? effortConfig : o,
+      );
+    } else {
+      this.session.configOptions.push(effortConfig);
+    }
   }
 
   private async sendAvailableCommandsUpdate(): Promise<void> {

package/src/adapters/claude/session/jsonl-hydration.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { ContentBlock } from "@agentclientprotocol/sdk";
 import type { PostHogAPIClient } from "../../../posthog-api";
 import type { StoredEntry } from "../../../types";
+import { supports1MContext } from "./models";
 
 interface ConversationTurn {
   role: "user" | "assistant";
@@ -188,6 +189,7 @@ export function rebuildConversation(
 
 const CHARS_PER_TOKEN = 4;
 const DEFAULT_MAX_TOKENS = 150_000;
+const LARGE_CONTEXT_MAX_TOKENS = 800_000;
 
 function estimateTurnTokens(turn: ConversationTurn): number {
   let chars = 0;
@@ -546,7 +548,10 @@ export async function hydrateSessionJsonl(params: {
       return;
     }
 
-    const conversation = selectRecentTurns(allTurns);
+    const maxTokens = supports1MContext(params.model ?? "")
+      ? LARGE_CONTEXT_MAX_TOKENS
+      : DEFAULT_MAX_TOKENS;
+    const conversation = selectRecentTurns(allTurns, maxTokens);
     log.info("Selected recent turns for hydration", {
       totalTurns: allTurns.length,
       selectedTurns: conversation.length,

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

@@ -11,3 +11,53 @@ const GATEWAY_TO_SDK_MODEL: Record<string, string> = {
 export function toSdkModelId(modelId: string): string {
   return GATEWAY_TO_SDK_MODEL[modelId] ?? modelId;
 }
+
+const MODELS_WITH_1M_CONTEXT = new Set([
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+]);
+
+export function supports1MContext(modelId: string): boolean {
+  return MODELS_WITH_1M_CONTEXT.has(modelId);
+}
+
+export function getDefaultContextWindow(modelId: string): number {
+  return supports1MContext(modelId) ? 1_000_000 : 200_000;
+}
+
+const MODELS_WITH_EFFORT = new Set([
+  "claude-opus-4-5",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+]);
+
+const MODELS_WITH_MAX_EFFORT = new Set(["claude-opus-4-6"]);
+
+export function supportsEffort(modelId: string): boolean {
+  return MODELS_WITH_EFFORT.has(modelId);
+}
+
+export function supportsMaxEffort(modelId: string): boolean {
+  return MODELS_WITH_MAX_EFFORT.has(modelId);
+}
+
+interface EffortOption {
+  value: string;
+  name: string;
+}
+
+export function getEffortOptions(modelId: string): EffortOption[] | null {
+  if (!supportsEffort(modelId)) return null;
+
+  const options: EffortOption[] = [
+    { value: "low", name: "Low" },
+    { value: "medium", name: "Medium" },
+    { value: "high", name: "High" },
+  ];
+
+  if (supportsMaxEffort(modelId)) {
+    options.push({ value: "max", name: "Max" });
+  }
+
+  return options;
+}

package/src/server/agent-server.ts

@@ -639,7 +639,14 @@ export class AgentServer {
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
-        systemPrompt: { append: this.buildCloudSystemPrompt(prUrl) },
+        systemPrompt: this.buildSessionSystemPrompt(prUrl),
+        ...(this.config.claudeCode?.plugins?.length && {
+          claudeCode: {
+            options: {
+              plugins: this.config.claudeCode.plugins,
+            },
+          },
+        }),
       },
     });
 
@@ -944,6 +951,28 @@ export class AgentServer {
       : null;
   }
 
+  private buildSessionSystemPrompt(
+    prUrl?: string | null,
+  ): string | { append: string } {
+    const cloudAppend = this.buildCloudSystemPrompt(prUrl);
+    const userPrompt = this.config.claudeCode?.systemPrompt;
+
+    // String override: combine user prompt with cloud instructions
+    if (typeof userPrompt === "string") {
+      return [userPrompt, cloudAppend].join("\n\n");
+    }
+
+    // Preset with append: merge user append with cloud instructions
+    if (typeof userPrompt === "object") {
+      return {
+        append: [userPrompt.append, cloudAppend].filter(Boolean).join("\n\n"),
+      };
+    }
+
+    // Default: just cloud instructions
+    return { append: cloudAppend };
+  }
+
   private buildCloudSystemPrompt(prUrl?: string | null): string {
     if (prUrl) {
       return `

package/src/server/bin.ts

@@ -2,7 +2,7 @@
 import { Command } from "commander";
 import { z } from "zod";
 import { AgentServer } from "./agent-server";
-import { mcpServersSchema } from "./schemas";
+import { claudeCodeConfigSchema, mcpServersSchema } from "./schemas";
 
 const envSchema = z.object({
   JWT_PUBLIC_KEY: z
@@ -34,6 +34,30 @@ const envSchema = z.object({
 
 const program = new Command();
 
+function parseJsonOption<S extends z.ZodTypeAny>(
+  raw: string | undefined,
+  schema: S,
+  flag: string,
+): z.output<S> | undefined {
+  if (!raw) return undefined;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    program.error(`${flag} must be valid JSON`);
+  }
+
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    const errors = result.error.issues
+      .map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
+      .join("\n");
+    program.error(`${flag} validation failed:\n${errors}`);
+  }
+  return result.data;
+}
+
 program
   .name("agent-server")
   .description("PostHog cloud agent server - runs in sandbox environments")
@@ -51,6 +75,10 @@ program
     "MCP servers config as JSON array (ACP McpServer[] format)",
   )
   .option("--baseBranch <branch>", "Base branch for PR creation")
+  .option(
+    "--claudeCodeConfig <json>",
+    "Claude Code config as JSON (systemPrompt, systemPromptAppend, plugins)",
+  )
   .action(async (options) => {
     const envResult = envSchema.safeParse(process.env);
 
@@ -66,28 +94,16 @@ program
 
     const mode = options.mode === "background" ? "background" : "interactive";
 
-    let mcpServers: z.infer<typeof mcpServersSchema> | undefined;
-    if (options.mcpServers) {
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(options.mcpServers);
-      } catch {
-        program.error("--mcpServers must be valid JSON");
-        return;
-      }
-
-      const result = mcpServersSchema.safeParse(parsed);
-      if (!result.success) {
-        const errors = result.error.issues
-          .map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
-          .join("\n");
-        program.error(
-          `--mcpServers validation failed (only remote http/sse servers are supported):\n${errors}`,
-        );
-        return;
-      }
-      mcpServers = result.data;
-    }
+    const mcpServers = parseJsonOption(
+      options.mcpServers,
+      mcpServersSchema,
+      "--mcpServers",
+    );
+    const claudeCode = parseJsonOption(
+      options.claudeCodeConfig,
+      claudeCodeConfigSchema,
+      "--claudeCodeConfig",
+    );
 
     const server = new AgentServer({
       port: parseInt(options.port, 10),
@@ -101,6 +117,7 @@ program
       runId: options.runId,
       mcpServers,
       baseBranch: options.baseBranch,
+      claudeCode,
     });
 
     process.on("SIGINT", async () => {

package/src/server/schemas.ts

@@ -16,6 +16,22 @@ export const mcpServersSchema = z.array(remoteMcpServerSchema);
 
 export type RemoteMcpServer = z.infer<typeof remoteMcpServerSchema>;
 
+export const claudeCodeConfigSchema = z.object({
+  systemPrompt: z
+    .union([
+      z.string(),
+      z.object({
+        type: z.literal("preset"),
+        preset: z.literal("claude_code"),
+        append: z.string().optional(),
+      }),
+    ])
+    .optional(),
+  plugins: z
+    .array(z.object({ type: z.literal("local"), path: z.string() }))
+    .optional(),
+});
+
 export const jsonRpcRequestSchema = z.object({
   jsonrpc: z.literal("2.0"),
   method: z.string(),

package/src/server/types.ts

@@ -1,6 +1,13 @@
 import type { AgentMode } from "../types";
 import type { RemoteMcpServer } from "./schemas";
 
+export interface ClaudeCodeConfig {
+  systemPrompt?:
+    | string
+    | { type: "preset"; preset: "claude_code"; append?: string };
+  plugins?: { type: "local"; path: string }[];
+}
+
 export interface AgentServerConfig {
   port: number;
   repositoryPath?: string;
@@ -14,4 +21,5 @@ export interface AgentServerConfig {
   version?: string;
   mcpServers?: RemoteMcpServer[];
   baseBranch?: string;
+  claudeCode?: ClaudeCodeConfig;
 }