@posthog/agent 2.3.172 → 2.3.187

package/dist/server/bin.cjs

@@ -894,7 +894,7 @@ var require_dist2 = __commonJS({
 
 // src/server/bin.ts
 var import_commander = require("commander");
-var import_zod4 = require("zod");
+var import_v42 = require("zod/v4");
 
 // src/server/agent-server.ts
 var import_sdk5 = require("@agentclientprotocol/sdk");
@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.172",
+  version: "2.3.187",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1062,7 +1062,9 @@ var POSTHOG_NOTIFICATIONS = {
   /** Task-level notification (progress, milestones) */
   TASK_NOTIFICATION: "_posthog/task_notification",
   /** Marks a boundary for log compaction */
-  COMPACT_BOUNDARY: "_posthog/compact_boundary"
+  COMPACT_BOUNDARY: "_posthog/compact_boundary",
+  /** Token usage update for a session turn */
+  USAGE_UPDATE: "_posthog/usage_update"
 };
 
 // src/adapters/acp-connection.ts
@@ -3006,7 +3008,6 @@ var CODE_EXECUTION_MODES = [
 function getAvailableModes() {
   return IS_ROOT ? availableModes.filter((m) => m.id !== "bypassPermissions") : availableModes;
 }
-var CODEX_NATIVE_MODES = ["auto", "read-only", "full-access"];
 var codexModes = [
   {
     id: "read-only",
@@ -4392,16 +4393,19 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                 }
               });
             }
-            await this.client.extNotification("_posthog/usage_update", {
-              sessionId: params.sessionId,
-              used: {
-                inputTokens: message.usage.input_tokens,
-                outputTokens: message.usage.output_tokens,
-                cachedReadTokens: message.usage.cache_read_input_tokens,
-                cachedWriteTokens: message.usage.cache_creation_input_tokens
-              },
-              cost: message.total_cost_usd
-            });
+            await this.client.extNotification(
+              POSTHOG_NOTIFICATIONS.USAGE_UPDATE,
+              {
+                sessionId: params.sessionId,
+                used: {
+                  inputTokens: message.usage.input_tokens,
+                  outputTokens: message.usage.output_tokens,
+                  cachedReadTokens: message.usage.cache_read_input_tokens,
+                  cachedWriteTokens: message.usage.cache_creation_input_tokens
+                },
+                cost: message.total_cost_usd
+              }
+            );
             const usage = {
               inputTokens: this.session.accumulatedUsage.inputTokens,
               outputTokens: this.session.accumulatedUsage.outputTokens,
@@ -5026,9 +5030,10 @@ var import_sdk3 = require("@agentclientprotocol/sdk");
 
 // src/adapters/codex/codex-client.ts
 var AUTO_APPROVED_KINDS = {
-  auto: /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]),
-  "read-only": /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]),
-  "full-access": /* @__PURE__ */ new Set([
+  default: /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]),
+  acceptEdits: /* @__PURE__ */ new Set(["read", "edit", "search", "fetch", "think"]),
+  plan: /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]),
+  bypassPermissions: /* @__PURE__ */ new Set([
     "read",
     "edit",
     "delete",
@@ -5042,7 +5047,7 @@ var AUTO_APPROVED_KINDS = {
   ])
 };
 function shouldAutoApprove(mode, kind) {
-  if (mode === "full-access") return true;
+  if (mode === "bypassPermissions") return true;
   if (!kind) return false;
   return AUTO_APPROVED_KINDS[mode]?.has(kind) ?? false;
 }
@@ -5149,7 +5154,7 @@ function createSessionState(sessionId, cwd, opts) {
   return {
     sessionId,
     cwd,
-    modeId: opts?.modeId ?? "auto",
+    modeId: opts?.modeId ?? "default",
     modelId: opts?.modelId,
     configOptions: [],
     accumulatedUsage: {
@@ -5158,8 +5163,7 @@ function createSessionState(sessionId, cwd, opts) {
       cachedReadTokens: 0,
       cachedWriteTokens: 0
     },
-    permissionMode: opts?.permissionMode ?? "auto",
-    cancelled: false,
+    permissionMode: opts?.permissionMode ?? "default",
     taskRunId: opts?.taskRunId,
     taskId: opts?.taskId
   };
@@ -5273,7 +5277,7 @@ function buildConfigArgs(options) {
     args.push("-c", `model="${options.model}"`);
   }
   if (options.instructions) {
-    const escaped = options.instructions.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const escaped = options.instructions.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/"/g, '\\"');
     args.push("-c", `instructions="${escaped}"`);
   }
   return args;
@@ -5353,12 +5357,18 @@ function spawnCodexProcess(options) {
 }
 
 // src/adapters/codex/codex-agent.ts
-function toPermissionMode(mode) {
-  if (mode && CODEX_NATIVE_MODES.includes(mode)) {
+function toCodeExecutionMode(mode) {
+  if (mode && CODE_EXECUTION_MODES.includes(mode)) {
     return mode;
   }
-  return "auto";
+  return "default";
 }
+var CODEX_NATIVE_MODE = {
+  default: "default",
+  acceptEdits: "default",
+  plan: "plan",
+  bypassPermissions: "default"
+};
 var CodexAcpAgent = class extends BaseAcpAgent {
   adapterName = "codex";
   codexProcess;
@@ -5384,25 +5394,9 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       notificationHistory: [],
       cancelled: false
     };
+    this.sessionState = createSessionState("", cwd);
     this.codexConnection = new import_sdk3.ClientSideConnection(
-      (_agent) => createCodexClient(
-        this.client,
-        this.logger,
-        this.sessionState ?? {
-          sessionId: "",
-          cwd: "",
-          modeId: "auto",
-          configOptions: [],
-          accumulatedUsage: {
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedReadTokens: 0,
-            cachedWriteTokens: 0
-          },
-          permissionMode: "auto",
-          cancelled: false
-        }
-      ),
+      (_agent) => createCodexClient(this.client, this.logger, this.sessionState),
       codexStream
     );
   }
@@ -5439,7 +5433,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       taskId: meta?.taskId ?? meta?.persistence?.taskId,
       modeId: response.modes?.currentModeId ?? "default",
       modelId: response.models?.currentModelId,
-      permissionMode: toPermissionMode(meta?.permissionMode)
+      permissionMode: toCodeExecutionMode(meta?.permissionMode)
     });
     this.sessionId = response.sessionId;
     this.sessionState.configOptions = response.configOptions ?? [];
@@ -5458,7 +5452,10 @@ var CodexAcpAgent = class extends BaseAcpAgent {
   }
   async loadSession(params) {
     const response = await this.codexConnection.loadSession(params);
-    this.sessionState = createSessionState(params.sessionId, params.cwd);
+    const meta = params._meta;
+    this.sessionState = createSessionState(params.sessionId, params.cwd, {
+      permissionMode: toCodeExecutionMode(meta?.permissionMode)
+    });
     this.sessionId = params.sessionId;
     this.sessionState.configOptions = response.configOptions ?? [];
     return response;
@@ -5469,10 +5466,14 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       cwd: params.cwd,
       mcpServers: params.mcpServers ?? []
     });
-    this.sessionState = createSessionState(params.sessionId, params.cwd);
+    const meta = params._meta;
+    this.sessionState = createSessionState(params.sessionId, params.cwd, {
+      taskRunId: meta?.taskRunId,
+      taskId: meta?.taskId ?? meta?.persistence?.taskId,
+      permissionMode: toCodeExecutionMode(meta?.permissionMode)
+    });
     this.sessionId = params.sessionId;
     this.sessionState.configOptions = loadResponse.configOptions ?? [];
-    const meta = params._meta;
     if (meta?.taskRunId) {
       await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
         taskRunId: meta.taskRunId,
@@ -5492,7 +5493,12 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       mcpServers: params.mcpServers ?? [],
       _meta: params._meta
     });
-    this.sessionState = createSessionState(newResponse.sessionId, params.cwd);
+    const meta = params._meta;
+    this.sessionState = createSessionState(newResponse.sessionId, params.cwd, {
+      taskRunId: meta?.taskRunId,
+      taskId: meta?.taskId ?? meta?.persistence?.taskId,
+      permissionMode: toCodeExecutionMode(meta?.permissionMode)
+    });
     this.sessionId = newResponse.sessionId;
     this.sessionState.configOptions = newResponse.configOptions ?? [];
     return newResponse;
@@ -5501,22 +5507,14 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     return this.codexConnection.listSessions(params);
   }
   async unstable_listSessions(params) {
-    return this.codexConnection.listSessions(params);
+    return this.listSessions(params);
   }
   async prompt(params) {
-    if (this.sessionState) {
-      this.sessionState.cancelled = false;
-      this.sessionState.interruptReason = void 0;
-      resetUsage(this.sessionState);
-    }
+    this.session.cancelled = false;
+    this.session.interruptReason = void 0;
+    resetUsage(this.sessionState);
     const response = await this.codexConnection.prompt(params);
-    if (this.sessionState && response.usage) {
-      this.sessionState.accumulatedUsage.inputTokens += response.usage.inputTokens ?? 0;
-      this.sessionState.accumulatedUsage.outputTokens += response.usage.outputTokens ?? 0;
-      this.sessionState.accumulatedUsage.cachedReadTokens += response.usage.cachedReadTokens ?? 0;
-      this.sessionState.accumulatedUsage.cachedWriteTokens += response.usage.cachedWriteTokens ?? 0;
-    }
-    if (this.sessionState?.taskRunId) {
+    if (this.sessionState.taskRunId) {
       const { accumulatedUsage } = this.sessionState;
       await this.client.extNotification(POSTHOG_NOTIFICATIONS.TURN_COMPLETE, {
         sessionId: params.sessionId,
@@ -5530,7 +5528,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
         }
       });
       if (response.usage) {
-        await this.client.extNotification("_posthog/usage_update", {
+        await this.client.extNotification(POSTHOG_NOTIFICATIONS.USAGE_UPDATE, {
           sessionId: params.sessionId,
           used: {
             inputTokens: response.usage.inputTokens ?? 0,
@@ -5545,38 +5543,24 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     return response;
   }
   async interrupt() {
-    if (this.sessionState) {
-      this.sessionState.cancelled = true;
-    }
     await this.codexConnection.cancel({
       sessionId: this.sessionId
     });
   }
-  async cancel(params) {
-    if (this.sessionState) {
-      this.sessionState.cancelled = true;
-      const meta = params._meta;
-      if (meta?.interruptReason) {
-        this.sessionState.interruptReason = meta.interruptReason;
-      }
-    }
-    await this.codexConnection.cancel(params);
-  }
   async setSessionMode(params) {
-    const permissionMode = toPermissionMode(params.modeId);
+    const requestedMode = toCodeExecutionMode(params.modeId);
+    const nativeMode = CODEX_NATIVE_MODE[requestedMode];
     const response = await this.codexConnection.setSessionMode({
       ...params,
-      modeId: permissionMode
+      modeId: nativeMode
     });
-    if (this.sessionState) {
-      this.sessionState.modeId = permissionMode;
-      this.sessionState.permissionMode = permissionMode;
-    }
+    this.sessionState.modeId = nativeMode;
+    this.sessionState.permissionMode = requestedMode;
     return response ?? {};
   }
   async setSessionConfigOption(params) {
     const response = await this.codexConnection.setSessionConfigOption(params);
-    if (this.sessionState && response.configOptions) {
+    if (response.configOptions) {
       this.sessionState.configOptions = response.configOptions;
     }
     return response;
@@ -5585,6 +5569,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
   }
   async closeSession() {
     this.logger.info("Closing Codex session", { sessionId: this.sessionId });
+    this.session.abortController.abort();
     this.session.settingsManager.dispose();
     try {
       this.codexProcess.kill();
@@ -12117,45 +12102,45 @@ function validateJwt(token, publicKey) {
 }
 
 // src/server/schemas.ts
-var import_zod3 = require("zod");
-var httpHeaderSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  value: import_zod3.z.string()
+var import_v4 = require("zod/v4");
+var httpHeaderSchema = import_v4.z.object({
+  name: import_v4.z.string(),
+  value: import_v4.z.string()
 });
-var remoteMcpServerSchema = import_zod3.z.object({
-  type: import_zod3.z.enum(["http", "sse"]),
-  name: import_zod3.z.string().min(1, "MCP server name is required"),
-  url: import_zod3.z.url({ error: "MCP server url must be a valid URL" }),
-  headers: import_zod3.z.array(httpHeaderSchema).default([])
+var remoteMcpServerSchema = import_v4.z.object({
+  type: import_v4.z.enum(["http", "sse"]),
+  name: import_v4.z.string().min(1, "MCP server name is required"),
+  url: import_v4.z.url({ error: "MCP server url must be a valid URL" }),
+  headers: import_v4.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()
+var mcpServersSchema = import_v4.z.array(remoteMcpServerSchema);
+var claudeCodeConfigSchema = import_v4.z.object({
+  systemPrompt: import_v4.z.union([
+    import_v4.z.string(),
+    import_v4.z.object({
+      type: import_v4.z.literal("preset"),
+      preset: import_v4.z.literal("claude_code"),
+      append: import_v4.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()
+  plugins: import_v4.z.array(import_v4.z.object({ type: import_v4.z.literal("local"), path: import_v4.z.string() })).optional()
 });
-var jsonRpcRequestSchema = import_zod3.z.object({
-  jsonrpc: import_zod3.z.literal("2.0"),
-  method: import_zod3.z.string(),
-  params: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
-  id: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional()
+var jsonRpcRequestSchema = import_v4.z.object({
+  jsonrpc: import_v4.z.literal("2.0"),
+  method: import_v4.z.string(),
+  params: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional(),
+  id: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).optional()
 });
-var userMessageParamsSchema = import_zod3.z.object({
-  content: import_zod3.z.string().min(1, "Content is required")
+var userMessageParamsSchema = import_v4.z.object({
+  content: import_v4.z.string().min(1, "Content is required")
 });
 var commandParamsSchemas = {
   user_message: userMessageParamsSchema,
   "posthog/user_message": userMessageParamsSchema,
-  cancel: import_zod3.z.object({}).optional(),
-  "posthog/cancel": import_zod3.z.object({}).optional(),
-  close: import_zod3.z.object({}).optional(),
-  "posthog/close": import_zod3.z.object({}).optional()
+  cancel: import_v4.z.object({}).optional(),
+  "posthog/cancel": import_v4.z.object({}).optional(),
+  close: import_v4.z.object({}).optional(),
+  "posthog/close": import_v4.z.object({}).optional()
 };
 function validateCommandParams(method, params) {
   const schema = commandParamsSchemas[method] ?? commandParamsSchemas[method.replace("posthog/", "")];
@@ -13379,17 +13364,17 @@ ${attributionInstructions}
 };
 
 // src/server/bin.ts
-var envSchema = import_zod4.z.object({
-  JWT_PUBLIC_KEY: import_zod4.z.string({
+var envSchema = import_v42.z.object({
+  JWT_PUBLIC_KEY: import_v42.z.string({
     error: "JWT_PUBLIC_KEY is required for authenticating client connections"
   }).min(1, "JWT_PUBLIC_KEY cannot be empty"),
-  POSTHOG_API_URL: import_zod4.z.url({
+  POSTHOG_API_URL: import_v42.z.url({
     error: "POSTHOG_API_URL is required for LLM gateway communication"
   }),
-  POSTHOG_PERSONAL_API_KEY: import_zod4.z.string({
+  POSTHOG_PERSONAL_API_KEY: import_v42.z.string({
     error: "POSTHOG_PERSONAL_API_KEY is required for authenticating with PostHog services"
   }).min(1, "POSTHOG_PERSONAL_API_KEY cannot be empty"),
-  POSTHOG_PROJECT_ID: import_zod4.z.string({
+  POSTHOG_PROJECT_ID: import_v42.z.string({
     error: "POSTHOG_PROJECT_ID is required for routing requests to the correct project"
   }).regex(/^\d+$/, "POSTHOG_PROJECT_ID must be a numeric string").transform((val) => parseInt(val, 10))
 });