@posthog/agent 2.3.22 → 2.3.31

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   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: {
@@ -3455,6 +3455,40 @@ var GATEWAY_TO_SDK_MODEL = {
 function toSdkModelId(modelId) {
   return GATEWAY_TO_SDK_MODEL[modelId] ?? modelId;
 }
+var MODELS_WITH_1M_CONTEXT = /* @__PURE__ */ new Set([
+  "claude-opus-4-6",
+  "claude-sonnet-4-6"
+]);
+function supports1MContext(modelId) {
+  return MODELS_WITH_1M_CONTEXT.has(modelId);
+}
+function getDefaultContextWindow(modelId) {
+  return supports1MContext(modelId) ? 1e6 : 2e5;
+}
+var MODELS_WITH_EFFORT = /* @__PURE__ */ new Set([
+  "claude-opus-4-5",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6"
+]);
+var MODELS_WITH_MAX_EFFORT = /* @__PURE__ */ new Set(["claude-opus-4-6"]);
+function supportsEffort(modelId) {
+  return MODELS_WITH_EFFORT.has(modelId);
+}
+function supportsMaxEffort(modelId) {
+  return MODELS_WITH_MAX_EFFORT.has(modelId);
+}
+function getEffortOptions(modelId) {
+  if (!supportsEffort(modelId)) return null;
+  const options = [
+    { value: "low", name: "Low" },
+    { value: "medium", name: "Medium" },
+    { value: "high", name: "High" }
+  ];
+  if (supportsMaxEffort(modelId)) {
+    options.push({ value: "max", name: "Max" });
+  }
+  return options;
+}
 
 // src/adapters/claude/session/options.ts
 var import_node_child_process = require("child_process");
@@ -4124,7 +4158,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             const contextWindows = Object.values(message.modelUsage).map(
               (m) => m.contextWindow
             );
-            const contextWindowSize = contextWindows.length > 0 ? Math.min(...contextWindows) : 2e5;
+            const contextWindowSize = contextWindows.length > 0 ? Math.min(...contextWindows) : getDefaultContextWindow(this.session.modelId ?? "");
             if (lastAssistantTotalUsage !== null) {
               await this.client.sessionUpdate({
                 sessionId: params.sessionId,
@@ -4244,6 +4278,7 @@ var ClaudeAcpAgent = class 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 {};
   }
@@ -4281,6 +4316,7 @@ var ClaudeAcpAgent = class 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;
       this.session.effort = newEffort;
@@ -4510,7 +4546,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       name: mode.name,
       description: mode.description ?? void 0
     }));
-    return [
+    const configOptions = [
       {
         id: "mode",
         name: "Approval Preset",
@@ -4528,22 +4564,60 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         options: modelOptions.options,
         category: "model",
         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",
         description: "Controls how much effort Claude puts into its response"
+      });
+    }
+    return configOptions;
+  }
+  rebuildEffortConfigOption(modelId) {
+    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 = void 0;
+        this.session.queryOptions.effort = void 0;
       }
-    ];
+      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;
+      this.session.queryOptions.effort = resolvedValue;
+    }
+    const effortConfig = {
+      id: "effort",
+      name: "Effort",
+      type: "select",
+      currentValue: resolvedValue,
+      options: effortOptions,
+      category: "thought_level",
+      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);
+    }
   }
   async sendAvailableCommandsUpdate() {
     const commands = await this.session.query.supportedCommands();
@@ -11377,6 +11451,17 @@ var remoteMcpServerSchema = import_zod3.z.object({
   headers: import_zod3.z.array(httpHeaderSchema).default([])
 });
 var mcpServersSchema = import_zod3.z.array(remoteMcpServerSchema);
+var claudeCodeConfigSchema = import_zod3.z.object({
+  systemPrompt: import_zod3.z.union([
+    import_zod3.z.string(),
+    import_zod3.z.object({
+      type: import_zod3.z.literal("preset"),
+      preset: import_zod3.z.literal("claude_code"),
+      append: import_zod3.z.string().optional()
+    })
+  ]).optional(),
+  plugins: import_zod3.z.array(import_zod3.z.object({ type: import_zod3.z.literal("local"), path: import_zod3.z.string() })).optional()
+});
 var jsonRpcRequestSchema = import_zod3.z.object({
   jsonrpc: import_zod3.z.literal("2.0"),
   method: import_zod3.z.string(),
@@ -11881,7 +11966,14 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       _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
+            }
+          }
+        }
       }
     });
     const acpSessionId = sessionResponse.sessionId;
@@ -12111,6 +12203,19 @@ ${toolSummary}`);
     const stateRunId = state?.resume_from_run_id;
     return typeof stateRunId === "string" && stateRunId.trim().length > 0 ? stateRunId.trim() : null;
   }
+  buildSessionSystemPrompt(prUrl) {
+    const cloudAppend = this.buildCloudSystemPrompt(prUrl);
+    const userPrompt = this.config.claudeCode?.systemPrompt;
+    if (typeof userPrompt === "string") {
+      return [userPrompt, cloudAppend].join("\n\n");
+    }
+    if (typeof userPrompt === "object") {
+      return {
+        append: [userPrompt.append, cloudAppend].filter(Boolean).join("\n\n")
+      };
+    }
+    return { append: cloudAppend };
+  }
   buildCloudSystemPrompt(prUrl) {
     if (prUrl) {
       return `
@@ -12485,6 +12590,22 @@ var envSchema = import_zod4.z.object({
   }).regex(/^\d+$/, "POSTHOG_PROJECT_ID must be a numeric string").transform((val) => parseInt(val, 10))
 });
 var program = new import_commander.Command();
+function parseJsonOption(raw, schema, flag) {
+  if (!raw) return void 0;
+  let parsed;
+  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:
+${errors}`);
+  }
+  return result.data;
+}
 program.name("agent-server").description("PostHog cloud agent server - runs in sandbox environments").option("--port <port>", "HTTP server port", "3001").option(
   "--mode <mode>",
   "Execution mode: interactive or background",
@@ -12492,7 +12613,10 @@ program.name("agent-server").description("PostHog cloud agent server - runs in s
 ).option("--repositoryPath <path>", "Path to the repository").requiredOption("--taskId <id>", "Task ID").requiredOption("--runId <id>", "Task run ID").option(
   "--mcpServers <json>",
   "MCP servers config as JSON array (ACP McpServer[] format)"
-).option("--baseBranch <branch>", "Base branch for PR creation").action(async (options) => {
+).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);
   if (!envResult.success) {
     const errors = envResult.error.issues.map((issue) => `  - ${issue.message}`).join("\n");
@@ -12502,26 +12626,16 @@ ${errors}`);
   }
   const env = envResult.data;
   const mode = options.mode === "background" ? "background" : "interactive";
-  let mcpServers;
-  if (options.mcpServers) {
-    let parsed;
-    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):
-${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),
     jwtPublicKey: env.JWT_PUBLIC_KEY,
@@ -12533,7 +12647,8 @@ ${errors}`
     taskId: options.taskId,
     runId: options.runId,
     mcpServers,
-    baseBranch: options.baseBranch
+    baseBranch: options.baseBranch,
+    claudeCode
   });
   process.on("SIGINT", async () => {
     await server.stop();