update from deprecated api to turn/start

Author: AlexandrSuhinin

src/CodexACPAgent.ts

@@ -13,12 +13,12 @@ export interface SessionState {
 export class CodexACPAgent implements acp.Agent {
     private readonly sessions: Map<string, SessionState>;
     private readonly codexClient: CodexClient;
-    private readonly messageHandler: CodexEventHandler;
+    private readonly connection: acp.AgentSideConnection;
 
     constructor(connection: acp.AgentSideConnection, codexConnection: MessageConnection) {
         this.sessions = new Map();
         this.codexClient = new CodexClient(codexConnection);
-        this.messageHandler = new CodexEventHandler(connection);
+        this.connection = connection;
     }
 
     async initialize(
@@ -42,21 +42,18 @@ export class CodexACPAgent implements acp.Agent {
     async newSession(
         _params: acp.NewSessionRequest,
     ): Promise<acp.NewSessionResponse> {
-        const newConversationResponse: NewConversationResponse = await this.codexClient.newConversation({
+         const threadStartResponse = await this.codexClient.threadStart({
             model: null,
             modelProvider: null,
-            profile: null,
             cwd: _params.cwd,
             approvalPolicy: "never",
             sandbox: null,
             config: null,
             baseInstructions: null,
             developerInstructions: null,
-            compactPrompt: null,
-            includeApplyPatchTool: null,
         })
 
-        const sessionId = newConversationResponse.conversationId;
+        const sessionId = threadStartResponse.thread.id;
         this.sessions.set(sessionId, {
             sessionId: sessionId,
             seenReasoningDeltas: false,
@@ -116,23 +113,21 @@ export class CodexACPAgent implements acp.Agent {
         sessionState: SessionState,
         prompt: string
     ): Promise<void> {
-        await this.codexClient.addConversationListener({
-            conversationId: sessionState.sessionId,
-            experimentalRawEvents: false,
-        })
+        const messageHandler = new CodexEventHandler(this.connection, sessionState);
+
+        this.codexClient.onServerNotification(notification => {
+            messageHandler.handleNotification(notification);
+        });
 
-        this.codexClient.onMessageEvent(event => this.messageHandler.handleEvent(sessionState, event));
-
-        await this.codexClient.sendUserMessage({
-            conversationId: sessionState.sessionId,
-            items: [
-                {
-                    type: "text",
-                    data: {
-                        text: prompt
-                    }
-                }
-            ]
+        await this.codexClient.turnStart({
+            threadId: sessionState.sessionId,
+            input: [ {type: "text", text: prompt} ],
+            approvalPolicy: null,
+            sandboxPolicy: null,
+            summary: null,
+            cwd: null,
+            effort: null,
+            model: null,
         })
 
         await this.codexClient.waitForCompletion()

src/CodexClient.ts

@@ -5,8 +5,15 @@ import type {
     InitializeParams,
     InitializeResponse,
     NewConversationParams,
-    NewConversationResponse, SendUserMessageParams, SendUserMessageResponse, TaskCompleteEvent
+    NewConversationResponse, SendUserMessageParams, SendUserMessageResponse, ServerNotification, TaskCompleteEvent
 } from "./app-server";
+import type {
+    ThreadStartParams,
+    ThreadStartResponse,
+    TurnCompletedNotification,
+    TurnStartParams,
+    TurnStartResponse
+} from "./app-server/v2";
 
 export class CodexClient {
     readonly connection: MessageConnection;
@@ -15,39 +22,31 @@ export class CodexClient {
         this.connection = connection;
     }
 
-    async initialize(params: InitializeParams) {
-        const response: InitializeResponse = await this.connection.sendRequest("initialize", params)
-        return response;
-    }
-
-    async newConversation(params: NewConversationParams){
-        const response: NewConversationResponse = await this.connection.sendRequest("newConversation", params)
-        return response;
+    async initialize(params: InitializeParams): Promise<InitializeResponse> {
+        return await this.sendRequest({ method: "initialize", params: params });
     }
 
-    async sendUserMessage(params: SendUserMessageParams) {
-        const response: SendUserMessageResponse = await this.connection.sendRequest("sendUserMessage", params)
-        return response;
+    async turnStart(params: TurnStartParams): Promise<TurnStartResponse> {
+        return await this.sendRequest({ method: "turn/start", params: params });
     }
 
-    async addConversationListener(params: AddConversationListenerParams){
-        const response: AddConversationSubscriptionResponse = await this.connection.sendRequest("addConversationListener", params)
-        return response;
+    async threadStart(params: ThreadStartParams): Promise<ThreadStartResponse> {
+        return await this.sendRequest({ method: "thread/start", params: params });
     }
 
-    async waitForCompletion(){
-        await new Promise((resolve) => {
-            this.connection.onNotification("codex/event/task_complete", (event: TaskCompleteEvent) => {
+    async waitForCompletion(): Promise<TurnCompletedNotification> {
+        return await new Promise((resolve) => {
+            this.connection.onNotification("turn/completed", (event: TurnCompletedNotification) => {
                 resolve(event);
             });
         });
     }
 
-    onMessageEvent(callback: (event: EventMsg) => void){
+    onServerNotification(callback: (event: ServerNotification) => void){
         this.connection.onUnhandledNotification((data) => {
-            const event = this.getEventMessage(data);
-            if (event) {
-                callback(event)
+            const serverNotification = data as ServerNotification ?? null;
+            if (serverNotification) {
+                callback(serverNotification)
             }
         });
     }
@@ -70,4 +69,9 @@ export class CodexClient {
         this.connection.end();
     }
 
-}
+    private async sendRequest<R>(request: CodexRequest): Promise<R> {
+        return await this.connection.sendRequest(request.method, request.params);
+    }
+}
+
+type CodexRequest = Omit<ClientRequest, "id">;