The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(paperclip-runner): emit turn.accepted before any terminal turn event (#12752)
Nicky Leache4afd163bf41
diff --git a/packages/paperclip-runner/src/drivers/codex/codex-app-server-driver.events.test.ts b/packages/paperclip-runner/src/drivers/codex/codex-app-server-driver.events.test.tsindex 9f26c42ed2..ac5d741570 100644--- a/packages/paperclip-runner/src/drivers/codex/codex-app-server-driver.events.test.ts+++ b/packages/paperclip-runner/src/drivers/codex/codex-app-server-driver.events.test.ts@@ -463,4 +463,106 @@ describe("Codex app-server Codex driver", () => {});});+ it("orders turn.accepted before a terminal event even when the provider notifies the terminal turn ahead of the turn/start response", async () => {+ const transport = new FakeCodexTransport();+ let resolveTurnStart: (value: Record<string, unknown>) => void = () => {};+ transport.turnStartResponse = new Promise((resolve) => {+ resolveTurnStart = resolve;+ });+ const session = await makeDriver([transport]).openSession({+ runId: "run-terminal-race",+ normalizedSessionId: "normalized-terminal-race",+ workingDirectory: WORKSPACE,+ });+ const startTurnPromise = session.startTurn({+ message: { role: "user", text: "Race the terminal event." },+ });+ // Give the provider's turn/started and turn/completed notifications every+ // chance to run ahead of the still-pending turn/start response, the way+ // one read chunk can carry all three JSON-RPC lines back to back.+ transport.push("turn/started", {+ threadId: "thread-1",+ turn: { id: "turn-1", status: "inProgress" },+ });+ transport.push("turn/completed", {+ threadId: "thread-1",+ turn: {+ id: "turn-1",+ status: "failed",+ items: [],+ error: { message: "provider rejected the turn" },+ },+ });+ // A macrotask boundary drains every microtask the notification pump can+ // run on its own, so an unguarded terminal handler has already run by+ // the time the turn/start response resolves below.+ await new Promise((resolve) => setImmediate(resolve));+ resolveTurnStart({+ turn: { id: "turn-1", status: "inProgress", items: [] },+ });++ const turn = await startTurnPromise;+ expect(turn.turnId).toBe("turn-1");++ const events = await collectUntilTerminal(session.events());+ const eventTypes = events.map((event) => event.eventType);+ expect(eventTypes).toEqual(+ expect.arrayContaining(["turn.started", "turn.accepted", "turn.failed"]),+ );+ expect(eventTypes.indexOf("turn.started")).toBeLessThan(+ eventTypes.indexOf("turn.accepted"),+ );+ expect(eventTypes.indexOf("turn.accepted")).toBeLessThan(+ eventTypes.indexOf("turn.failed"),+ );+ expect(+ events.some((event) => event.eventType === "session.failed"),+ ).toBe(false);+ });++ it("does not release a terminal event for a turn when turn/start itself rejects", async () => {+ const transport = new FakeCodexTransport();+ let rejectTurnStart: (error: Error) => void = () => {};+ transport.turnStartResponse = new Promise((_resolve, reject) => {+ rejectTurnStart = reject;+ });+ const session = await makeDriver([transport]).openSession({+ runId: "run-terminal-reject-race",+ normalizedSessionId: "normalized-terminal-reject-race",+ workingDirectory: WORKSPACE,+ });+ const startTurnPromise = session.startTurn({+ message: { role: "user", text: "Race the terminal event against a rejection." },+ });+ // The provider notifies turn/started and turn/completed ahead of its own+ // turn/start response, then that response rejects. No turn was ever+ // accepted, so neither notification may release a terminal event.+ transport.push("turn/started", {+ threadId: "thread-1",+ turn: { id: "turn-1", status: "inProgress" },+ });+ transport.push("turn/completed", {+ threadId: "thread-1",+ turn: {+ id: "turn-1",+ status: "failed",+ items: [],+ error: { message: "provider rejected the turn" },+ },+ });+ await new Promise((resolve) => setImmediate(resolve));+ rejectTurnStart(new CodexRpcError("turn/start rejected by provider", -32000));++ await expect(startTurnPromise).rejects.toThrow(+ "turn/start rejected by provider",+ );++ const events = await collectUntilTerminal(session.events());+ const eventTypes = events.map((event) => event.eventType);+ expect(eventTypes).not.toContain("turn.accepted");+ expect(eventTypes).not.toContain("turn.completed");+ expect(eventTypes).not.toContain("turn.failed");+ expect(eventTypes).toContain("session.failed");+ });+});diff --git a/packages/paperclip-runner/src/drivers/codex/codex-harness-session.ts b/packages/paperclip-runner/src/drivers/codex/codex-harness-session.tsindex cebdd76bd0..3092fd8d8a 100644--- a/packages/paperclip-runner/src/drivers/codex/codex-harness-session.ts+++ b/packages/paperclip-runner/src/drivers/codex/codex-harness-session.ts@@ -164,6 +164,10 @@ export class CodexHarnessSession extends CodexSessionState implements HarnessSeseffectiveCollaborationMode,});this.turnStartPending = true;+ let releaseTurnStartSettled: () => void = () => {};+ this.turnStartSettled = new Promise((resolve) => {+ releaseTurnStartSettled = resolve;+ });let response: Record<string, unknown>;const requestedMode = this.opened.context.collaborationMode;try {@@ -184,6 +188,13 @@ export class CodexHarnessSession extends CodexSessionState implements HarnessSes: { outputSchema: CODEX_RESULT_OUTPUT_SCHEMA }),});} catch (error) {+ // A turn/started notification can arrive and mark a turn active while+ // turn/start is still pending. The turn/start request just rejected,+ // so no turn was accepted. Roll that optimistic state back so a+ // terminal notification for it cannot pass the active-turn check below+ // and release a terminal event for a turn that was never accepted.+ this.activeTurnId = null;+ this.turnStarted = false;if (dispositionOnlyRecovery) {if (error instanceof CodexRpcError) {// A JSON-RPC error is a definite provider rejection: no turn was@@ -200,6 +211,11 @@ export class CodexHarnessSession extends CodexSessionState implements HarnessSesthrow error;} finally {this.turnStartPending = false;+ // Release a terminal notification that arrived and parked itself+ // while this turn/start was in flight. This runs before turn.accepted+ // below, in the same synchronous continuation, so a released waiter+ // never observes the terminal turn ahead of turn.accepted.+ releaseTurnStartSettled();}const turn = record(response.turn);const turnId = text(turn.id);diff --git a/packages/paperclip-runner/src/drivers/codex/codex-session-notifications.ts b/packages/paperclip-runner/src/drivers/codex/codex-session-notifications.tsindex 60a342e3ee..68384f9e31 100644--- a/packages/paperclip-runner/src/drivers/codex/codex-session-notifications.ts+++ b/packages/paperclip-runner/src/drivers/codex/codex-session-notifications.ts@@ -37,7 +37,7 @@ import {export async function pumpNotifications(state: CodexSessionState): Promise<void> {try {for await (const notification of state.transport.notifications()) {- mapNotification(state, notification);+ await mapNotification(state, notification);}} catch (error) {state.emit("harness.diagnostic", {@@ -52,11 +52,11 @@ export async function pumpNotifications(state: CodexSessionState): Promise<void>}}-function mapNotification(state: CodexSessionState, notification: CodexRpcNotification): void {+async function mapNotification(state: CodexSessionState, notification: CodexRpcNotification): Promise<void> {const sourceSequenceBefore = state.sourceSequence;let rejected = false;try {- mapNotificationBody(state, notification);+ await mapNotificationBody(state, notification);} catch (error) {rejected = true;throw error;@@ -98,7 +98,7 @@ function mapNotification(state: CodexSessionState, notification: CodexRpcNotific}}-function mapNotificationBody(state: CodexSessionState, notification: CodexRpcNotification): void {+async function mapNotificationBody(state: CodexSessionState, notification: CodexRpcNotification): Promise<void> {if (!isSupportedCodexNotificationMethod(notification.method)) return;if (!isBoundCodexNotification(notification, {runId: state.runId,@@ -365,6 +365,11 @@ function mapNotificationBody(state: CodexSessionState, notification: CodexRpcNotreturn;}if (notification.method === "turn/completed") {+ // A terminal notification can arrive on the provider's notification+ // channel before turn/start's own response settles on the request+ // channel. Wait for the pending turn/start to settle first, so+ // turn.accepted always precedes the terminal event for the same turn.+ await state.turnStartSettled;if (state.terminalTurns.has(turnId)) {mapTerminalTurn(state, turn, turnId);return;diff --git a/packages/paperclip-runner/src/drivers/codex/codex-session-state.ts b/packages/paperclip-runner/src/drivers/codex/codex-session-state.tsindex 0ff9a479b2..c623ca1c07 100644--- a/packages/paperclip-runner/src/drivers/codex/codex-session-state.ts+++ b/packages/paperclip-runner/src/drivers/codex/codex-session-state.ts@@ -82,6 +82,14 @@ export class CodexSessionState {resultCallId: string | null = null;resultTurnId: string | null = null;turnStartPending = false;+ /**+ * Resolves once a pending turn/start settles, on the accepted path or on a+ * provider rejection. A terminal notification for that turn must wait on+ * this promise, so turn.accepted always precedes any terminal event for+ * the same turn even when the provider notifies the terminal turn before+ * the turn/start response arrives.+ */+ turnStartSettled: Promise<void> = Promise.resolve();protocolFailed = false;protocolFailureCode: string | null = null;protocolFailureMessage: string | null = null;