@posthog/agent 2.3.298 → 2.3.304

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.298",
+  "version": "2.3.304",
   "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/codex/codex-agent.test.ts

@@ -60,20 +60,32 @@ describe("CodexAcpAgent", () => {
     vi.clearAllMocks();
   });
 
-  function createAgent(): CodexAcpAgent {
+  function createAgent(overrides: Partial<AgentSideConnection> = {}): {
+    agent: CodexAcpAgent;
+    client: AgentSideConnection & {
+      extNotification: ReturnType<typeof vi.fn>;
+      sessionUpdate: ReturnType<typeof vi.fn>;
+    };
+  } {
     const client = {
       extNotification: vi.fn(),
-    } as unknown as AgentSideConnection;
-
-    return new CodexAcpAgent(client, {
+      sessionUpdate: vi.fn(),
+      ...overrides,
+    } as unknown as AgentSideConnection & {
+      extNotification: ReturnType<typeof vi.fn>;
+      sessionUpdate: ReturnType<typeof vi.fn>;
+    };
+
+    const agent = new CodexAcpAgent(client, {
       codexProcessOptions: {
         cwd: process.cwd(),
       },
     });
+    return { agent, client };
   }
 
   it("applies the requested initial mode for a new session", async () => {
-    const agent = createAgent();
+    const { agent } = createAgent();
     mockCodexConnection.newSession.mockResolvedValue({
       sessionId: "session-1",
       modes: { currentModeId: "auto", availableModes: [] },
@@ -96,7 +108,7 @@ describe("CodexAcpAgent", () => {
   });
 
   it("preserves the live session mode when loading an existing session", async () => {
-    const agent = createAgent();
+    const { agent } = createAgent();
     mockCodexConnection.loadSession.mockResolvedValue({
       modes: { currentModeId: "read-only", availableModes: [] },
       configOptions: [],
@@ -114,4 +126,93 @@ describe("CodexAcpAgent", () => {
         .sessionState.permissionMode,
     ).toBe("read-only");
   });
+
+  it("prepends _meta.prContext to the forwarded prompt but not to the broadcast", async () => {
+    const { agent, client } = createAgent();
+    mockCodexConnection.newSession.mockResolvedValue({
+      sessionId: "session-1",
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<NewSessionResponse>);
+    await agent.newSession({
+      cwd: process.cwd(),
+    } as never);
+
+    mockCodexConnection.prompt.mockResolvedValue({ stopReason: "end_turn" });
+
+    await agent.prompt({
+      sessionId: "session-1",
+      prompt: [{ type: "text", text: "ship the fix" }],
+      _meta: { prContext: "PR #123 is open; review before editing." },
+    } as never);
+
+    // codex-acp receives the PR context prepended as a text block.
+    expect(mockCodexConnection.prompt).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: [
+          { type: "text", text: "PR #123 is open; review before editing." },
+          { type: "text", text: "ship the fix" },
+        ],
+      }),
+    );
+    // The broadcast shows only the real user turn — the prContext prefix
+    // is internal routing and should not render as a user message.
+    expect(client.sessionUpdate).toHaveBeenCalledTimes(1);
+    expect(client.sessionUpdate).toHaveBeenCalledWith({
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "ship the fix" },
+      },
+    });
+  });
+
+  it("broadcasts user prompt as user_message_chunk before delegating to codex-acp", async () => {
+    const { agent, client } = createAgent();
+    // Seed an active session so prompt() has the state it expects.
+    mockCodexConnection.newSession.mockResolvedValue({
+      sessionId: "session-1",
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<NewSessionResponse>);
+    await agent.newSession({
+      cwd: process.cwd(),
+    } as never);
+
+    const callOrder: string[] = [];
+    client.sessionUpdate.mockImplementation(async () => {
+      callOrder.push("sessionUpdate");
+    });
+    mockCodexConnection.prompt.mockImplementation(async () => {
+      callOrder.push("prompt");
+      return { stopReason: "end_turn" };
+    });
+
+    await agent.prompt({
+      sessionId: "session-1",
+      prompt: [
+        { type: "text", text: "first chunk" },
+        { type: "text", text: "second chunk" },
+      ],
+    } as never);
+
+    expect(client.sessionUpdate).toHaveBeenCalledTimes(2);
+    expect(client.sessionUpdate).toHaveBeenNthCalledWith(1, {
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "first chunk" },
+      },
+    });
+    expect(client.sessionUpdate).toHaveBeenNthCalledWith(2, {
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "second chunk" },
+      },
+    });
+    // Broadcast must land before the prompt reaches codex-acp so the user
+    // turn is persisted even if the underlying prompt fails.
+    expect(callOrder).toEqual(["sessionUpdate", "sessionUpdate", "prompt"]);
+  });
 });

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

@@ -93,6 +93,24 @@ function toCodexPermissionMode(mode?: string): PermissionMode {
   return "auto";
 }
 
+/**
+ * Prepend `_meta.prContext` (set by the agent-server on Slack-originated
+ * follow-up runs) to the prompt as a text block, mirroring Claude's
+ * `promptToClaude` behavior. Without this, codex cloud runs lose the
+ * PR-review context that follow-up flows rely on.
+ */
+function prependPrContext(params: PromptRequest): PromptRequest {
+  const prContext = (params._meta as Record<string, unknown> | undefined)
+    ?.prContext;
+  if (typeof prContext !== "string" || prContext.length === 0) {
+    return params;
+  }
+  return {
+    ...params,
+    prompt: [{ type: "text", text: prContext }, ...params.prompt],
+  };
+}
+
 const CODEX_NATIVE_MODE: Record<CodeExecutionMode, CodexNativeMode> = {
   default: "auto",
   acceptEdits: "auto",
@@ -369,7 +387,17 @@ export class CodexAcpAgent extends BaseAcpAgent {
     this.session.interruptReason = undefined;
     resetUsage(this.sessionState);
 
-    const response = await this.codexConnection.prompt(params);
+    // codex-acp does not echo the user prompt back on the agent→client
+    // channel, so without this broadcast the tapped stream (persisted to S3
+    // and rendered by the PostHog web UI) never sees a user turn and only
+    // the assistant reply shows up. Mirrors ClaudeAcpAgent.broadcastUserMessage.
+    // The original params (no _meta.prContext prefix) is broadcast so the
+    // injected PR context is not rendered as a user message.
+    await this.broadcastUserMessage(params);
+
+    const response = await this.codexConnection.prompt(
+      prependPrContext(params),
+    );
 
     // Usage is already accumulated via sessionUpdate notifications in
     // codex-client.ts. Do NOT also add response.usage here or tokens
@@ -417,6 +445,20 @@ export class CodexAcpAgent extends BaseAcpAgent {
     });
   }
 
+  private async broadcastUserMessage(params: PromptRequest): Promise<void> {
+    for (const chunk of params.prompt) {
+      const notification = {
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "user_message_chunk" as const,
+          content: chunk,
+        },
+      };
+      await this.client.sessionUpdate(notification);
+      this.appendNotification(params.sessionId, notification);
+    }
+  }
+
   async setSessionMode(
     params: SetSessionModeRequest,
   ): Promise<SetSessionModeResponse> {