Support turn cancellation

Author: xtmq

src/CodexAcpClient.ts

@@ -9,6 +9,7 @@ import type {
     SetDefaultModelParams,
     SetDefaultModelResponse
 } from "./app-server";
+import type { TurnCompletedNotification } from "./app-server/v2";
 import type {JsonValue} from "./app-server/serde_json/JsonValue";
 import type {Model} from "./app-server/v2";
 import {ModelId} from "./ModelId";
@@ -101,14 +102,18 @@ export class CodexAcpClient {
         };
     }
 
-    async sendPrompt(request: acp.PromptRequest, eventHandler: (result: ServerNotification) => void): Promise<void> {
+    async sendPrompt(
+        request: acp.PromptRequest, 
+        eventHandler: (result: ServerNotification) => void,
+        onTurnStarted?: (turnId: string) => void
+    ): Promise<TurnCompletedNotification> {
         this.codexClient.onServerNotification(request.sessionId, eventHandler);
 
         const input = request.prompt.filter(b => b.type === "text")
             .map(b => b.text)
             .join(" ");
 
-        await this.codexClient.turnStart({
+        const turnStartResponse = await this.codexClient.turnStart({
             threadId: request.sessionId,
             input: [{type: "text", text: input}],
             approvalPolicy: null,
@@ -119,13 +124,27 @@ export class CodexAcpClient {
             model: null,
         });
 
-        await this.codexClient.awaitTurnCompleted();
+        // Save turnId if callback provided
+        if (onTurnStarted) {
+            onTurnStarted(turnStartResponse.turn.id);
+        }
+
+        // Wait for turn completion
+        // If turnInterrupt() was called, Codex will send turn/completed event with status "interrupted"
+        return await this.codexClient.awaitTurnCompleted();
     }
 
     async setModel(params: SetDefaultModelParams): Promise<SetDefaultModelResponse> {
         return this.codexClient.setModelRequest(params);
     }
 
+    async turnInterrupt(params: { threadId: string, turnId: string }): Promise<void> {
+        await this.codexClient.turnInterrupt({
+            threadId: params.threadId,
+            turnId: params.turnId
+        });
+    }
+
     private async fetchAvailableModels(): Promise<Model[]> {
         const models: Model[] = [];
         let cursor: string | null = null;

src/CodexAcpServer.ts

@@ -10,7 +10,7 @@ import {ModelId} from "./ModelId";
 
 export interface SessionState {
     sessionMetadata: SessionMetadata;
-    pendingPrompt: AbortController | null;
+    currentTurnId: string | null;
 }
 
 export class CodexAcpServer implements acp.Agent {
@@ -62,7 +62,7 @@ export class CodexAcpServer implements acp.Agent {
         const {sessionId, currentModelId, models} = sessionMetadata;
         this.sessions.set(sessionId, {
             sessionMetadata: sessionMetadata,
-            pendingPrompt: null
+            currentTurnId: null
         });
 
         const availableModels = this.buildAvailableModels(models);
@@ -153,25 +153,34 @@ export class CodexAcpServer implements acp.Agent {
     async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
         const sessionState = this.getSessionState(params.sessionId);
 
-        sessionState.pendingPrompt?.abort();
-        sessionState.pendingPrompt = new AbortController();
+        sessionState.currentTurnId = null;
 
         try {
             const messageHandler = new CodexEventHandler(this.connection, sessionState);
-            await this.runWithProcessCheck(() => this.codexAcpClient.sendPrompt(params, (event) => messageHandler.handleNotification(event)));
-        } catch (err) {
-            if (sessionState.pendingPrompt.signal.aborted) {
-                return {stopReason: "cancelled"};
+            const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.sendPrompt(
+                params, 
+                (event) => messageHandler.handleNotification(event),
+                (turnId) => {
+                    sessionState.currentTurnId = turnId;
+                }
+            ));
+
+            // Check if turn was interrupted (cancelled)
+            if (turnCompleted.turn.status === "interrupted") {
+                return {
+                    stopReason: "cancelled",
+                };
             }
 
+            return {
+                stopReason: "end_turn",
+            };
+        } catch (err) {
+            console.error(`[CodexAcpServer] prompt() failed:`, err);
             throw err;
+        } finally {
+            sessionState.currentTurnId = null;
         }
-
-        sessionState.pendingPrompt = null;
-
-        return {
-            stopReason: "end_turn",
-        };
     }
 
     private async runWithProcessCheck<T>(operation: () => Promise<T>): Promise<T> {
@@ -191,7 +200,27 @@ export class CodexAcpServer implements acp.Agent {
     }
 
     async cancel(params: acp.CancelNotification): Promise<void> {
-        //TODO not supported yet
-        this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
+        const sessionState = this.sessions.get(params.sessionId);
+        if (!sessionState) {
+            console.info(`Can not cancel: session ${params.sessionId} not found`);
+            return;
+        }
+
+        if (!sessionState.currentTurnId) {
+            console.info(`Can not cancel: session ${params.sessionId} has no current turn`);
+            return;
+        }
+
+        console.info(`Cancel session ${params.sessionId}, currentTurnId: ${sessionState.currentTurnId}...`);
+        try {
+            // After turnInterrupt(), Codex will send turn/completed event, which will naturally complete awaitTurnCompleted()
+            await this.codexAcpClient.turnInterrupt({
+                threadId: params.sessionId,
+                turnId: sessionState.currentTurnId
+            });
+            console.log(`Cancel - turnInterrupt succeeded`);
+        } catch (err) {
+            console.error(`Cancel - turnInterrupt failed:`, err);
+        }
     }
 }

src/CodexAppServerClient.ts

@@ -13,6 +13,8 @@ import type {
     ThreadStartParams,
     ThreadStartResponse,
     TurnCompletedNotification,
+    TurnInterruptParams,
+    TurnInterruptResponse,
     TurnStartParams,
     TurnStartResponse
 } from "./app-server/v2";
@@ -45,6 +47,10 @@ export class CodexAppServerClient {
         return await this.sendRequest({ method: "turn/start", params: params });
     }
 
+    async turnInterrupt(params: TurnInterruptParams): Promise<TurnInterruptResponse> {
+        return await this.sendRequest({ method: "turn/interrupt", params: params });
+    }
+
     async threadStart(params: ThreadStartParams): Promise<ThreadStartResponse> {
         return await this.sendRequest({ method: "thread/start", params: params });
     }

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -80,7 +80,7 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         fixture.getCodexAppServerClient().turnStart = vi.fn().mockResolvedValue(undefined);
         fixture.getCodexAppServerClient().awaitTurnCompleted = vi.fn().mockResolvedValue(undefined);
         const sessionState: SessionState = {
-            pendingPrompt: null,
+            currentTurnId: null,
             sessionMetadata: {
                 sessionId: "id",
                 currentModelId: "model-id",
@@ -103,7 +103,7 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         mockFixture.getCodexAppServerClient().awaitTurnCompleted = vi.fn().mockResolvedValue(undefined);
 
         const sessionState: SessionState = {
-            pendingPrompt: null,
+            currentTurnId: null,
             sessionMetadata: {
                 sessionId: "id",
                 currentModelId: "model-id",
@@ -147,15 +147,15 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         mockFixture.getCodexAppServerClient().awaitTurnCompleted = vi.fn().mockResolvedValue(undefined);
 
         const sessionState1: SessionState = {
-            pendingPrompt: null,
+            currentTurnId: null,
             sessionMetadata: {
                 sessionId: "session-1",
                 currentModelId: "model-id",
                 models: [],
             }
         };
         const sessionState2: SessionState = {
-            pendingPrompt: null,
+            currentTurnId: null,
             sessionMetadata: {
                 sessionId: "session-2",
                 currentModelId: "model-id",