@posthog/agent 2.3.263 → 2.3.278

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.263",
+  "version": "2.3.278",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -48,6 +48,10 @@
       "types": "./dist/adapters/claude/session/models.d.ts",
       "import": "./dist/adapters/claude/session/models.js"
     },
+    "./adapters/reasoning-effort": {
+      "types": "./dist/adapters/reasoning-effort.d.ts",
+      "import": "./dist/adapters/reasoning-effort.js"
+    },
     "./execution-mode": {
       "types": "./dist/execution-mode.d.ts",
       "import": "./dist/execution-mode.js"

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

@@ -100,7 +100,7 @@ export function buildExitPlanModePermissionOptions(): PermissionOption[] {
   if (ALLOW_BYPASS) {
     options.push({
       kind: "allow_always",
-      name: "Yes, auto-accept all permissions",
+      name: "Yes, bypass all permissions",
       optionId: "bypassPermissions",
     });
   }

package/src/adapters/codex/models.ts

@@ -0,0 +1,16 @@
+interface ReasoningEffortOption {
+  value: string;
+  name: string;
+}
+
+const CODEX_REASONING_EFFORT_OPTIONS: ReasoningEffortOption[] = [
+  { value: "low", name: "Low" },
+  { value: "medium", name: "Medium" },
+  { value: "high", name: "High" },
+];
+
+export function getReasoningEffortOptions(
+  _modelId: string,
+): ReasoningEffortOption[] {
+  return CODEX_REASONING_EFFORT_OPTIONS;
+}

package/src/adapters/codex/spawn.ts

@@ -11,6 +11,7 @@ export interface CodexProcessOptions {
   apiBaseUrl?: string;
   apiKey?: string;
   model?: string;
+  reasoningEffort?: string;
   instructions?: string;
   binaryPath?: string;
   logger?: Logger;
@@ -52,6 +53,10 @@ function buildConfigArgs(options: CodexProcessOptions): string[] {
     args.push("-c", `model="${options.model}"`);
   }
 
+  if (options.reasoningEffort) {
+    args.push("-c", `model_reasoning_effort="${options.reasoningEffort}"`);
+  }
+
   if (options.instructions) {
     const escaped = options.instructions
       .replace(/\\/g, "\\\\")

package/src/adapters/reasoning-effort.ts

@@ -0,0 +1,35 @@
+import { getEffortOptions as getClaudeEffortOptions } from "./claude/session/models";
+import { getReasoningEffortOptions as getCodexReasoningEffortOptions } from "./codex/models";
+
+export type RuntimeAdapter = "claude" | "codex";
+
+export type SupportedReasoningEffort = "low" | "medium" | "high" | "max";
+
+export interface ReasoningEffortOption {
+  value: SupportedReasoningEffort;
+  name: string;
+}
+
+export function getReasoningEffortOptions(
+  adapter: RuntimeAdapter,
+  modelId: string,
+): ReasoningEffortOption[] | null {
+  const options =
+    adapter === "codex"
+      ? getCodexReasoningEffortOptions(modelId)
+      : getClaudeEffortOptions(modelId);
+
+  return options as ReasoningEffortOption[] | null;
+}
+
+export function isSupportedReasoningEffort(
+  adapter: RuntimeAdapter,
+  modelId: string,
+  value: string,
+): value is SupportedReasoningEffort {
+  return (
+    getReasoningEffortOptions(adapter, modelId)?.some(
+      (option) => option.value === value,
+    ) ?? false
+  );
+}

package/src/execution-mode.ts

@@ -35,8 +35,8 @@ const availableModes: ModeInfo[] = [
 if (ALLOW_BYPASS) {
   availableModes.push({
     id: "bypassPermissions",
-    name: "Auto-accept Permissions",
-    description: "Auto-accept all permission requests",
+    name: "Bypass Permissions",
+    description: "Bypass all permission prompts",
   });
 }
 
@@ -84,7 +84,7 @@ if (ALLOW_BYPASS) {
   codexModes.push({
     id: "full-access",
     name: "Full Access",
-    description: "Auto-accept all permission requests",
+    description: "Bypass all permission prompts",
   });
 }
 

package/src/server/agent-server.test.ts

@@ -21,6 +21,17 @@ interface TestableServer {
   detectedPrUrl: string | null;
   buildCloudSystemPrompt(prUrl?: string | null): string;
   buildDetectedPrContext(prUrl: string): string;
+  buildSessionSystemPrompt(prUrl?: string | null): string | { append: string };
+  buildCodexInstructions(systemPrompt: string | { append: string }): string;
+  getRuntimeAdapter(): "claude" | "codex";
+}
+
+let nextTestPort = 20000;
+
+function getNextTestPort(): number {
+  const port = nextTestPort;
+  nextTestPort += 1;
+  return port;
 }
 
 // The Claude Agent SDK has an internal readMessages() loop that rejects with
@@ -112,14 +123,16 @@ JwIDAQAB
 
 describe("AgentServer HTTP Mode", () => {
   let repo: TestRepo;
-  let server: AgentServer;
+  let server: AgentServer | undefined;
   let mswServer: SetupServerApi;
   let appendLogCalls: unknown[][];
-  const port = 3099;
+  let port: number;
 
   beforeEach(async () => {
     repo = await createTestRepo("agent-server-http");
     appendLogCalls = [];
+    // Use a unique high port per test to avoid reuse and browser-blocked ports.
+    port = getNextTestPort();
     mswServer = setupServer(
       ...createPostHogHandlers({
         baseUrl: "http://localhost:8000",
@@ -132,12 +145,15 @@ describe("AgentServer HTTP Mode", () => {
   afterEach(async () => {
     if (server) {
       await server.stop();
+      server = undefined;
     }
     mswServer.close();
     await repo.cleanup();
   });
 
-  const createServer = () => {
+  const createServer = (
+    overrides: Partial<ConstructorParameters<typeof AgentServer>[0]> = {},
+  ) => {
     server = new AgentServer({
       port,
       jwtPublicKey: TEST_PUBLIC_KEY,
@@ -148,6 +164,7 @@ describe("AgentServer HTTP Mode", () => {
       mode: "interactive",
       taskId: "test-task-id",
       runId: "test-run-id",
+      ...overrides,
     });
     return server;
   };
@@ -176,7 +193,7 @@ describe("AgentServer HTTP Mode", () => {
 
       expect(response.status).toBe(200);
       expect(body).toEqual({ status: "ok", hasSession: true });
-    });
+    }, 30000);
   });
 
   describe("GET /events", () => {
@@ -188,7 +205,7 @@ describe("AgentServer HTTP Mode", () => {
 
       expect(response.status).toBe(401);
       expect(body.error).toBe("Missing authorization header");
-    });
+    }, 20000);
 
     it("returns 401 with invalid token", async () => {
       await createServer().start();
@@ -200,7 +217,7 @@ describe("AgentServer HTTP Mode", () => {
 
       expect(response.status).toBe(401);
       expect(body.code).toBe("invalid_signature");
-    });
+    }, 20000);
 
     it("accepts valid JWT and returns SSE stream", async () => {
       await createServer().start();
@@ -212,7 +229,7 @@ describe("AgentServer HTTP Mode", () => {
 
       expect(response.status).toBe(200);
       expect(response.headers.get("content-type")).toBe("text/event-stream");
-    });
+    }, 20000);
   });
 
   describe("POST /command", () => {
@@ -230,7 +247,7 @@ describe("AgentServer HTTP Mode", () => {
       });
 
       expect(response.status).toBe(401);
-    });
+    }, 20000);
 
     it("returns 400 when run_id does not match active session", async () => {
       await createServer().start();
@@ -252,7 +269,7 @@ describe("AgentServer HTTP Mode", () => {
       expect(response.status).toBe(400);
       const body = await response.json();
       expect(body.error).toBe("No active session for this run");
-    });
+    }, 20000);
 
     it("accepts structured user_message content", async () => {
       await createServer().start();
@@ -276,7 +293,7 @@ describe("AgentServer HTTP Mode", () => {
       expect(response.status).toBe(400);
       const body = await response.json();
       expect(body.error).toBe("No active session for this run");
-    });
+    }, 20000);
   });
 
   describe("404 handling", () => {
@@ -288,7 +305,7 @@ describe("AgentServer HTTP Mode", () => {
 
       expect(response.status).toBe(404);
       expect(body.error).toBe("Not found");
-    });
+    }, 20000);
   });
 
   describe("getInitialPromptOverride", () => {
@@ -335,6 +352,48 @@ describe("AgentServer HTTP Mode", () => {
     });
   });
 
+  describe("runtime adapter selection", () => {
+    it("defaults to claude when no runtime adapter is configured", () => {
+      const s = createServer();
+
+      expect((s as unknown as TestableServer).getRuntimeAdapter()).toBe(
+        "claude",
+      );
+    });
+
+    it("uses codex when the runtime adapter is configured", () => {
+      const s = createServer({ runtimeAdapter: "codex" });
+
+      expect((s as unknown as TestableServer).getRuntimeAdapter()).toBe(
+        "codex",
+      );
+    });
+
+    it("flattens append-style prompts into plain codex instructions", () => {
+      const s = createServer({
+        claudeCode: {
+          systemPrompt: {
+            type: "preset",
+            preset: "claude_code",
+            append: "User codex instructions",
+          },
+        },
+      });
+
+      const sessionPrompt = (
+        s as unknown as TestableServer
+      ).buildSessionSystemPrompt("https://github.com/PostHog/code/pull/1");
+
+      expect(typeof sessionPrompt).toBe("object");
+      expect(
+        (s as unknown as TestableServer).buildCodexInstructions(sessionPrompt),
+      ).toContain("User codex instructions");
+      expect(
+        (s as unknown as TestableServer).buildCodexInstructions(sessionPrompt),
+      ).toContain("Cloud Task Execution");
+    });
+  });
+
   describe("detectedPrUrl tracking", () => {
     it("stores PR URL when detectAndAttachPrUrl finds a match", () => {
       const s = createServer();

package/src/server/agent-server.ts

@@ -19,6 +19,7 @@ import {
 } from "../adapters/acp-connection";
 import { selectRecentTurns } from "../adapters/claude/session/jsonl-hydration";
 import type { CodeExecutionMode } from "../execution-mode";
+import { DEFAULT_CODEX_MODEL } from "../gateway-models";
 import { PostHogAPIClient } from "../posthog-api";
 import {
   type ConversationTurn,
@@ -168,6 +169,20 @@ interface ActiveSession {
   hasDesktopConnected: boolean;
 }
 
+function getTaskRunStateString(
+  taskRun: TaskRun | null,
+  key: string,
+): string | null {
+  const state = taskRun?.state;
+
+  if (!state || typeof state !== "object") {
+    return null;
+  }
+
+  const value = (state as Record<string, unknown>)[key];
+  return typeof value === "string" ? value : null;
+}
+
 export class AgentServer {
   private config: AgentServerConfig;
   private logger: Logger;
@@ -242,6 +257,10 @@ export class AgentServer {
     this.app = this.createApp();
   }
 
+  private getRuntimeAdapter(): "claude" | "codex" {
+    return this.config.runtimeAdapter ?? "claude";
+  }
+
   private getEffectiveMode(payload: JwtPayload): AgentMode {
     return payload.mode ?? this.config.mode;
   }
@@ -702,6 +721,39 @@ export class AgentServer {
 
     this.configureEnvironment();
 
+    const [preTaskRun, preTask] = await Promise.all([
+      this.posthogAPI
+        .getTaskRun(payload.task_id, payload.run_id)
+        .catch((err) => {
+          this.logger.warn("Failed to fetch task run for session context", {
+            taskId: payload.task_id,
+            runId: payload.run_id,
+            error: err,
+          });
+          return null;
+        }),
+      this.posthogAPI.getTask(payload.task_id).catch((err) => {
+        this.logger.warn("Failed to fetch task for session context", {
+          taskId: payload.task_id,
+          error: err,
+        });
+        return null;
+      }),
+    ]);
+
+    const prUrl = getTaskRunStateString(preTaskRun, "slack_notified_pr_url");
+
+    if (prUrl) {
+      this.detectedPrUrl = prUrl;
+    }
+
+    const runtimeAdapter = this.getRuntimeAdapter();
+    const sessionSystemPrompt = this.buildSessionSystemPrompt(prUrl);
+    const codexInstructions =
+      runtimeAdapter === "codex"
+        ? this.buildCodexInstructions(sessionSystemPrompt)
+        : undefined;
+
     const posthogAPI = new PostHogAPIClient({
       apiUrl: this.config.apiUrl,
       projectId: this.config.projectId,
@@ -725,10 +777,23 @@ export class AgentServer {
     });
 
     const acpConnection = createAcpConnection({
+      adapter: runtimeAdapter,
       taskRunId: payload.run_id,
       taskId: payload.task_id,
       deviceType: deviceInfo.type,
       logWriter,
+      logger: this.logger,
+      codexOptions:
+        runtimeAdapter === "codex"
+          ? {
+              cwd: this.config.repositoryPath ?? "/tmp/workspace",
+              apiBaseUrl: process.env.OPENAI_BASE_URL,
+              apiKey: this.config.apiKey,
+              model: this.config.model ?? DEFAULT_CODEX_MODEL,
+              reasoningEffort: this.config.reasoningEffort,
+              instructions: codexInstructions,
+            }
+          : undefined,
       onStructuredOutput: async (output) => {
         await this.posthogAPI.setTaskRunOutput(
           payload.task_id,
@@ -773,37 +838,6 @@ export class AgentServer {
       clientCapabilities: {},
     });
 
-    const [preTaskRun, preTask] = await Promise.all([
-      this.posthogAPI
-        .getTaskRun(payload.task_id, payload.run_id)
-        .catch((err) => {
-          this.logger.warn("Failed to fetch task run for session context", {
-            taskId: payload.task_id,
-            runId: payload.run_id,
-            error: err,
-          });
-          return null;
-        }),
-      this.posthogAPI.getTask(payload.task_id).catch((err) => {
-        this.logger.warn("Failed to fetch task for session context", {
-          taskId: payload.task_id,
-          error: err,
-        });
-        return null;
-      }),
-    ]);
-
-    const prUrl =
-      typeof (preTaskRun?.state as Record<string, unknown>)
-        ?.slack_notified_pr_url === "string"
-        ? ((preTaskRun?.state as Record<string, unknown>)
-            .slack_notified_pr_url as string)
-        : null;
-
-    if (prUrl) {
-      this.detectedPrUrl = prUrl;
-    }
-
     const runState = preTaskRun?.state as Record<string, unknown> | undefined;
     // Cloud runs default to bypassPermissions (auto-approve everything).
     // Only PostHog Code sets initial_permission_mode explicitly (e.g., "plan").
@@ -811,21 +845,27 @@ export class AgentServer {
       typeof runState?.initial_permission_mode === "string"
         ? (runState.initial_permission_mode as CodeExecutionMode)
         : "bypassPermissions";
-
     const sessionResponse = await clientConnection.newSession({
       cwd: this.config.repositoryPath ?? "/tmp/workspace",
       mcpServers: this.config.mcpServers ?? [],
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
-        systemPrompt: this.buildSessionSystemPrompt(prUrl),
+        systemPrompt: sessionSystemPrompt,
+        ...(this.config.model && { model: this.config.model }),
         allowedDomains: this.config.allowedDomains,
         jsonSchema: preTask?.json_schema ?? null,
         permissionMode: initialPermissionMode,
         ...(this.config.claudeCode?.plugins?.length && {
           claudeCode: {
             options: {
-              plugins: this.config.claudeCode.plugins,
+              ...(this.config.claudeCode?.plugins?.length && {
+                plugins: this.config.claudeCode.plugins,
+              }),
+              ...(runtimeAdapter === "claude" &&
+                this.config.reasoningEffort && {
+                  effort: this.config.reasoningEffort,
+                }),
             },
           },
         }),
@@ -1197,6 +1237,14 @@ export class AgentServer {
     return { append: cloudAppend };
   }
 
+  private buildCodexInstructions(
+    systemPrompt: string | { append: string },
+  ): string {
+    return typeof systemPrompt === "string"
+      ? systemPrompt
+      : systemPrompt.append;
+  }
+
   private getCloudInteractionOrigin(): string | undefined {
     return (
       process.env.POSTHOG_CODE_INTERACTION_ORIGIN ??

package/src/server/bin.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { z } from "zod/v4";
+import { isSupportedReasoningEffort } from "../adapters/reasoning-effort";
 import { AgentServer } from "./agent-server";
 import { claudeCodeConfigSchema, mcpServersSchema } from "./schemas";
 
@@ -26,6 +27,11 @@ const envSchema = z.object({
     })
     .regex(/^\d+$/, "POSTHOG_PROJECT_ID must be a numeric string")
     .transform((val) => parseInt(val, 10)),
+  POSTHOG_CODE_RUNTIME_ADAPTER: z.enum(["claude", "codex"]).optional(),
+  POSTHOG_CODE_MODEL: z.string().optional(),
+  POSTHOG_CODE_REASONING_EFFORT: z
+    .enum(["low", "medium", "high", "max"])
+    .optional(),
 });
 
 const program = new Command();
@@ -124,6 +130,21 @@ program
           .filter(Boolean)
       : undefined;
 
+    if (
+      env.POSTHOG_CODE_RUNTIME_ADAPTER &&
+      env.POSTHOG_CODE_MODEL &&
+      env.POSTHOG_CODE_REASONING_EFFORT &&
+      !isSupportedReasoningEffort(
+        env.POSTHOG_CODE_RUNTIME_ADAPTER,
+        env.POSTHOG_CODE_MODEL,
+        env.POSTHOG_CODE_REASONING_EFFORT,
+      )
+    ) {
+      program.error(
+        `POSTHOG_CODE_REASONING_EFFORT '${env.POSTHOG_CODE_REASONING_EFFORT}' is not supported for ${env.POSTHOG_CODE_RUNTIME_ADAPTER} model '${env.POSTHOG_CODE_MODEL}'.`,
+      );
+    }
+
     const server = new AgentServer({
       port: parseInt(options.port, 10),
       jwtPublicKey: env.JWT_PUBLIC_KEY,
@@ -139,6 +160,9 @@ program
       baseBranch: options.baseBranch,
       claudeCode,
       allowedDomains,
+      runtimeAdapter: env.POSTHOG_CODE_RUNTIME_ADAPTER,
+      model: env.POSTHOG_CODE_MODEL,
+      reasoningEffort: env.POSTHOG_CODE_REASONING_EFFORT,
     });
 
     process.on("SIGINT", async () => {

package/src/server/types.ts

@@ -24,4 +24,7 @@ export interface AgentServerConfig {
   baseBranch?: string;
   claudeCode?: ClaudeCodeConfig;
   allowedDomains?: string[];
+  runtimeAdapter?: "claude" | "codex";
+  model?: string;
+  reasoningEffort?: "low" | "medium" | "high" | "max";
 }

package/src/test/mocks/msw-handlers.ts

@@ -20,6 +20,30 @@ export function createPostHogHandlers(options: PostHogHandlersOptions = {}) {
   } = options;
 
   return [
+    // GET local LLM gateway models - session initialization fetches these in the
+    // background for command/model metadata.
+    http.get("http://localhost:3308/:product/v1/models", () => {
+      return HttpResponse.json({
+        object: "list",
+        data: [
+          {
+            id: "claude-opus-4-6",
+            owned_by: "anthropic",
+            context_window: 200000,
+            supports_streaming: true,
+            supports_vision: true,
+          },
+          {
+            id: "gpt-5.4",
+            owned_by: "openai",
+            context_window: 200000,
+            supports_streaming: true,
+            supports_vision: true,
+          },
+        ],
+      });
+    }),
+
     // POST /append_log/ - Agent log entries
     http.post(
       `${baseUrl}/api/projects/:projectId/tasks/:taskId/runs/:runId/append_log/`,