fix(codex): bound streamed plan snapshots

Generated-By: PostHog Code
Task-Id: 7305b2f0-aa76-413e-b0ea-a2078250be66

Author: MattPua

packages/agent/src/adapters/codex-app-server/codex-app-server-agent.test.ts

@@ -2992,6 +2992,64 @@ describe("CodexAppServerAgent", () => {
     });
   });
 
+  it("coalesces streamed plan snapshots in notification history", async () => {
+    const { agent, stub } = makePlanAgent({
+      outcome: { outcome: "selected", optionId: "reject_with_feedback" },
+    });
+    const { done } = await startPlanTurn(agent, stub);
+
+    stub.emit("item/plan/delta", { itemId: "p1", delta: "first" });
+    stub.emit("item/plan/delta", { itemId: "p1", delta: " second" });
+    stub.emit("item/plan/delta", { itemId: "p1", delta: " third" });
+    stub.emit("turn/completed", {
+      turn: { id: "turn_1", status: "completed" },
+    });
+    await done;
+
+    const session = (
+      agent as unknown as {
+        session: {
+          notificationHistory: Array<{ update?: Record<string, unknown> }>;
+        };
+      }
+    ).session;
+    const streamedUpdates = session.notificationHistory.filter(
+      (notification) =>
+        notification.update?.sessionUpdate === "tool_call_update" &&
+        notification.update.status === "in_progress",
+    );
+    expect(streamedUpdates).toHaveLength(1);
+    expect(streamedUpdates[0].update?.rawInput).toEqual({
+      plan: "first second third",
+    });
+  });
+
+  it("caps streamed plans before rendering or storing them", async () => {
+    const { agent, stub, permissionRequests, sessionUpdates } = makePlanAgent({
+      outcome: { outcome: "selected", optionId: "reject_with_feedback" },
+    });
+    const { done } = await startPlanTurn(agent, stub);
+
+    stub.emit("item/plan/delta", { itemId: "p1", delta: "a".repeat(75_000) });
+    stub.emit("item/plan/delta", { itemId: "p1", delta: "b".repeat(75_000) });
+    stub.emit("turn/completed", {
+      turn: { id: "turn_1", status: "completed" },
+    });
+    await done;
+
+    const renderedPlans = sessionUpdates.flatMap((notification) => {
+      const rawInput = notification.update?.rawInput as
+        | { plan?: unknown }
+        | undefined;
+      return typeof rawInput?.plan === "string" ? [rawInput.plan] : [];
+    });
+    const approvalPlan = permissionRequests[0].toolCall.rawInput as {
+      plan: string;
+    };
+    expect(renderedPlans.every((plan) => plan.length <= 100_000)).toBe(true);
+    expect(approvalPlan.plan).toHaveLength(100_000);
+  });
+
   it("stays in plan mode when the handoff is rejected without feedback", async () => {
     const { agent, stub, sessionUpdates, permissionRequests } = makePlanAgent({
       outcome: { outcome: "selected", optionId: "reject_with_feedback" },

packages/agent/src/adapters/codex-app-server/codex-app-server-agent.ts

@@ -115,6 +115,8 @@ type GoalCommand =
   | { kind: "resume" }
   | { kind: "set"; objective: string };
 
+const MAX_PLAN_PROPOSAL_CHARS = 100_000;
+
 type CodexSkill = {
   name?: string;
   description?: string;
@@ -1168,7 +1170,7 @@ export class CodexAppServerAgent extends BaseAcpAgent {
       sessionId: this.sessionId,
       update,
     } as unknown as Parameters<AgentSideConnection["sessionUpdate"]>[0];
-    this.appendNotification(this.sessionId, notification);
+    this.appendPlanApprovalNotification(notification);
     void this.client.sessionUpdate(notification).catch((error) => {
       this.logger.warn("Failed to emit plan approval tool call update", {
         error: String(error),
@@ -1178,6 +1180,36 @@ export class CodexAppServerAgent extends BaseAcpAgent {
     });
   }
 
+  private appendPlanApprovalNotification(
+    notification: Parameters<AgentSideConnection["sessionUpdate"]>[0],
+  ): void {
+    const update = notification.update as Record<string, unknown>;
+    if (
+      update.sessionUpdate === "tool_call_update" &&
+      update.status === "in_progress" &&
+      typeof update.toolCallId === "string"
+    ) {
+      for (
+        let index = this.session.notificationHistory.length - 1;
+        index >= 0;
+        index--
+      ) {
+        const previous = this.session.notificationHistory[index] as unknown as {
+          update?: Record<string, unknown>;
+        };
+        if (
+          previous.update?.sessionUpdate === "tool_call_update" &&
+          previous.update.status === "in_progress" &&
+          previous.update.toolCallId === update.toolCallId
+        ) {
+          this.session.notificationHistory[index] = notification;
+          return;
+        }
+      }
+    }
+    this.appendNotification(this.sessionId, notification);
+  }
+
   /** Emit a plain agent message (user-facing status the model didn't produce). */
   private broadcastAgentText(text: string): void {
     if (!this.sessionId) return;
@@ -1459,7 +1491,10 @@ export class CodexAppServerAgent extends BaseAcpAgent {
       params as { item?: { type?: string; id?: string; text?: string } }
     )?.item;
     if (item?.type === "plan" && typeof item.text === "string" && item.text) {
-      this.planProposal = { itemId: item.id ?? "codex-plan", text: item.text };
+      this.planProposal = {
+        itemId: item.id ?? "codex-plan",
+        text: item.text.slice(0, MAX_PLAN_PROPOSAL_CHARS),
+      };
       if (this.config.mode === "plan" && this.streamedPlanToolCallId) {
         this.emitPlanProposal(
           this.buildPlanApprovalToolCall(this.planProposal),
@@ -1482,7 +1517,12 @@ export class CodexAppServerAgent extends BaseAcpAgent {
         : (this.planProposal?.itemId ?? "codex-plan");
     const previousText =
       this.planProposal?.itemId === proposalId ? this.planProposal.text : "";
-    this.planProposal = { itemId: proposalId, text: previousText + delta };
+    const remainingChars = MAX_PLAN_PROPOSAL_CHARS - previousText.length;
+    if (remainingChars <= 0) return;
+    this.planProposal = {
+      itemId: proposalId,
+      text: previousText + delta.slice(0, remainingChars),
+    };
     if (this.config.mode === "plan") {
       this.emitPlanProposal(
         this.buildPlanApprovalToolCall(this.planProposal),