refactor: extract acp -> app-server mapping into a separate layer

AlexandrSuhinin · AlexandrSuhinin · commit b71a8eff8fb8 · 2025-12-11T16:18:09.000+02:00
diff --git a/src/CodexACPAgent.ts b/src/CodexACPAgent.ts
@@ -1,56 +1,37 @@
 import * as acp from "@agentclientprotocol/sdk";
-import type {MessageConnection} from "vscode-jsonrpc/node";
-import {CodexClient} from "./CodexClient";
 import {CodexEventHandler} from "./CodexEventHandler";
-import type {JsonValue} from "./app-server/serde_json/JsonValue";
-import {CodexAuthMethods, type CodexAuthRequest, isCodexAuthRequest} from "./CodexAuthMethod";
+import {CodexAuthMethods, type CodexAuthRequest} from "./CodexAuthMethod";
 import {RequestError} from "@agentclientprotocol/sdk";
+import {CodexAcpClient} from "./CodexAcpClient";
 
 
 export interface SessionState {
     sessionId: string,
-    seenReasoningDeltas: boolean;
     pendingPrompt: AbortController | null;
 }
 
 export class CodexACPAgent implements acp.Agent {
-    private readonly name: string = "codex-appserver-acp";
-    private readonly version: string = "0.1.0";
-    private readonly title: string = "Codex ACP";
-
-    private readonly codexClient: CodexClient;
+    private readonly codexAcpClient: CodexAcpClient;
     private readonly connection: acp.AgentSideConnection;
-    private readonly config: JsonObject | null;
-    private readonly modelProvider: string | null;
     private readonly defaultAuthRequest: CodexAuthRequest | null;
 
     private readonly sessions: Map<string, SessionState>;
 
     constructor(
         connection: acp.AgentSideConnection,
-        codexConnection: MessageConnection,
-        codexConfig?: JsonObject,
-        modelProvider?: string,
+        codexAcpClient: CodexAcpClient,
         defaultAuthRequest?: CodexAuthRequest,
     ) {
         this.sessions = new Map();
-        this.codexClient = new CodexClient(codexConnection);
         this.connection = connection;
-        this.config = codexConfig ?? null;
-        this.modelProvider = modelProvider ?? null;
         this.defaultAuthRequest = defaultAuthRequest ?? null;
+        this.codexAcpClient = codexAcpClient;
     }
 
     async initialize(
         _params: acp.InitializeRequest,
     ): Promise<acp.InitializeResponse> {
-        await this.codexClient.initialize({
-            clientInfo: {
-                name: _params.clientInfo?.name ?? this.name,
-                version: _params.clientInfo?.version ?? this.version,
-                title: _params.clientInfo?.title ?? this.title,
-            }
-        });
+        await this.codexAcpClient.initialize(_params);
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
@@ -63,53 +44,30 @@ export class CodexACPAgent implements acp.Agent {
     async newSession(
         _params: acp.NewSessionRequest,
     ): Promise<acp.NewSessionResponse> {
-        if (!await this.codexClient.loginStatus()) {
+        if (await this.codexAcpClient.authRequired()) {
             if (this.defaultAuthRequest) {
                 await this.authenticate(this.defaultAuthRequest)
             } else {
                 throw RequestError.authRequired();
             }
         }
 
-        const threadStartResponse = await this.codexClient.threadStart({
-            config: this.config,
-            modelProvider: this.modelProvider,
-            model: null,
-            cwd: _params.cwd,
-            approvalPolicy: "never",
-            sandbox: null,
-            baseInstructions: null,
-            developerInstructions: null,
-        })
-
-        const sessionId = threadStartResponse.thread.id;
+        const sessionId = await this.codexAcpClient.newSession(_params);
         this.sessions.set(sessionId, {
             sessionId: sessionId,
-            seenReasoningDeltas: false,
             pendingPrompt: null,
         });
 
         return {
-            sessionId,
+            sessionId: sessionId,
         };
     }
 
     async authenticate(
         _params: acp.AuthenticateRequest,
     ): Promise<acp.AuthenticateResponse> {
-        if (!isCodexAuthRequest(_params)) {
-            throw RequestError.invalidRequest();
-        }
-        let authResult: Boolean;
-        switch (_params.methodId) {
-            case "api-key":
-                authResult = await this.codexClient.loginWithApiKey(_params._meta.apiKey);
-                break;
-            case "chat-gpt":
-                authResult = await this.codexClient.loginWithChatGpt();
-                break;
-        }
-        if (!authResult) {
+        const isAuthenticated = await this.codexAcpClient.authenticate(_params);
+        if (!isAuthenticated) {
             throw RequestError.invalidParams();
         }
         return { };
@@ -131,12 +89,9 @@ export class CodexACPAgent implements acp.Agent {
         sessionState.pendingPrompt?.abort();
         sessionState.pendingPrompt = new AbortController();
 
-        const prompt = params.prompt.filter(b => b.type === "text")
-            .map(b => b.text)
-            .join(" ");
-
         try {
-            await this.processMessage(sessionState, prompt);
+            const messageHandler = new CodexEventHandler(this.connection, sessionState);
+            await this.codexAcpClient.sendPrompt(params, (event) => messageHandler.handleNotification(event));
         } catch (err) {
             if (sessionState.pendingPrompt.signal.aborted) {
                 return {stopReason: "cancelled"};
@@ -152,35 +107,8 @@ export class CodexACPAgent implements acp.Agent {
         };
     }
 
-    private async processMessage(
-        sessionState: SessionState,
-        prompt: string
-    ): Promise<void> {
-        const messageHandler = new CodexEventHandler(this.connection, sessionState);
-
-        this.codexClient.onServerNotification(notification => {
-            messageHandler.handleNotification(notification);
-        });
-
-        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()
-    }
-
     async cancel(params: acp.CancelNotification): Promise<void> {
         //TODO not supported yet
-        await this.codexClient.close()
         this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
     }
-}
-
-export type JsonObject = { [key in string]?: JsonValue }
+}
diff --git a/src/CodexAcpClient.ts b/src/CodexAcpClient.ts
@@ -0,0 +1,106 @@
+import {isCodexAuthRequest} from "./CodexAuthMethod";
+import * as acp from "@agentclientprotocol/sdk";
+import type {CodexAppServerClient} from "./CodexAppServerClient";
+import {RequestError} from "@agentclientprotocol/sdk";
+import open from "open";
+import type {ClientInfo, ServerNotification} from "./app-server";
+import type {JsonValue} from "./app-server/serde_json/JsonValue";
+
+/**
+ * API for accessing the Codex App Server using ACP requests.
+ * Converts ACP requests into corresponding app-server operations.
+ */
+export class CodexAcpClient {
+
+    private readonly codexClient: CodexAppServerClient;
+    private readonly config: JsonObject | null;
+    private readonly modelProvider: string | null;
+
+    constructor(codexClient: CodexAppServerClient, codexConfig?: JsonObject, modelProvider?: string) {
+        this.codexClient = codexClient;
+        this.config = codexConfig ?? null;
+        this.modelProvider = modelProvider ?? null;
+    }
+
+    private readonly defaultClientInfo: ClientInfo = {
+        name: "codex-acp", title: "Codex ACP", version: "0.0.5"
+    };
+
+    async initialize(request: acp.InitializeRequest): Promise<void> {
+        await this.codexClient.initialize({
+            clientInfo: {
+                name: request.clientInfo?.name ?? this.defaultClientInfo.name,
+                version: request.clientInfo?.version ?? this.defaultClientInfo.version,
+                title: request.clientInfo?.title ?? this.defaultClientInfo.title,
+            }
+        });
+    }
+
+    async authenticate(authRequest: acp.AuthenticateRequest): Promise<Boolean> {
+        if (!isCodexAuthRequest(authRequest)) {
+            throw RequestError.invalidRequest();
+        }
+        switch (authRequest.methodId) {
+            case "api-key":
+                await this.codexClient.accountLogin({
+                    type: "apiKey",
+                    apiKey: authRequest._meta.apiKey
+                });
+                break;
+            case "chat-gpt":
+                const loginResponse = await this.codexClient.accountLogin({ type: "chatgpt" });
+                if (loginResponse.type == "chatgpt") {
+                    await open(loginResponse.authUrl);
+                }
+                break;
+        }
+        const result = await this.codexClient.awaitLoginCompleted()
+        return result.success;
+    }
+
+    async authRequired(): Promise<Boolean> {
+        const response = await this.codexClient.accountRead({refreshToken: false})
+        return response.requiresOpenaiAuth || !response.account;
+    }
+
+    /**
+     * Returns a new session ID.
+     */
+    async newSession(request: acp.NewSessionRequest): Promise<string> {
+        const response = await this.codexClient.threadStart({
+            config: this.config,
+            modelProvider: this.modelProvider,
+            model: null,
+            cwd: request.cwd,
+            approvalPolicy: "never",
+            sandbox: null,
+            baseInstructions: null,
+            developerInstructions: null,
+        });
+        return response.thread.id;
+    }
+
+    async sendPrompt(request: acp.PromptRequest, eventHandler: (result: ServerNotification) => void): Promise<void> {
+        this.codexClient.onServerNotification(eventHandler);
+
+        const input = request.prompt.filter(b => b.type === "text")
+            .map(b => b.text)
+            .join(" ");
+
+        await this.codexClient.turnStart({
+            threadId: request.sessionId,
+            input: [{type: "text", text: input}],
+            approvalPolicy: null,
+            sandboxPolicy: null,
+            summary: null,
+            cwd: null,
+            effort: null,
+            model: null,
+        });
+
+        await this.codexClient.awaitTurnCompleted();
+    }
+
+}
+
+export type JsonObject = { [key in string]?: JsonValue }
diff --git a/src/CodexAppServerClient.ts b/src/CodexAppServerClient.ts
@@ -4,22 +4,24 @@ import type {
     EventMsg,
     InitializeParams,
     InitializeResponse,
-    LoginChatGptResponse,
     ServerNotification
 } from "./app-server";
 import type {
     AccountLoginCompletedNotification,
     GetAccountParams,
-    GetAccountResponse,
+    GetAccountResponse, LoginAccountParams, LoginAccountResponse,
     ThreadStartParams,
     ThreadStartResponse,
     TurnCompletedNotification,
     TurnStartParams,
     TurnStartResponse
 } from "./app-server/v2";
-import open from "open";
 
-export class CodexClient {
+/**
+ * A type-safe client over the Codex App Server's JSON-RPC API.
+ * Maps each request to its expected response and exposes clear, typed methods for supported JSON-RPC operations.
+ */
+export class CodexAppServerClient {
     readonly connection: MessageConnection;
 
     constructor(connection: MessageConnection) {
@@ -38,43 +40,23 @@ export class CodexClient {
         return await this.sendRequest({ method: "thread/start", params: params });
     }
 
-    async loginWithApiKey(apiKey: string): Promise<Boolean> {
-        await this.sendRequest({
-            method: "account/login/start",
-            params: { type: "apiKey", apiKey: apiKey }
-        });
-        const result = await this.awaitLogin();
-        return result.success
+    async accountLogin(params: LoginAccountParams): Promise<LoginAccountResponse> {
+        return await this.sendRequest({ method: "account/login/start", params: params });
     }
 
-    async loginWithChatGpt(): Promise<Boolean> {
-        const response: LoginChatGptResponse = await this.sendRequest({
-            method: "account/login/start",
-            params: { type: "chatgpt" }
-        });
-        await open(response.authUrl);
-        const result = await this.awaitLogin();
-        return result.success
-
-}
-    private async awaitLogin(): Promise<AccountLoginCompletedNotification> {
+    async awaitLoginCompleted(): Promise<AccountLoginCompletedNotification> {
         return await new Promise((resolve) => {
             this.connection.onNotification("account/login/completed", (event: AccountLoginCompletedNotification) => {
                 resolve(event);
             });
         });
     }
 
-    private async accountRead(params: GetAccountParams): Promise<GetAccountResponse> {
+    async accountRead(params: GetAccountParams): Promise<GetAccountResponse> {
         return await this.sendRequest({ method: "account/read", params: params });
     }
 
-    async loginStatus(): Promise<Boolean> {
-        const response = await this.accountRead({refreshToken: false})
-        return !response.requiresOpenaiAuth || response.account !== null;
-    }
-
-    async waitForCompletion(): Promise<TurnCompletedNotification> {
+    async awaitTurnCompleted(): Promise<TurnCompletedNotification> {
         return await new Promise((resolve) => {
             this.connection.onNotification("turn/completed", (event: TurnCompletedNotification) => {
                 resolve(event);
@@ -105,13 +87,13 @@ export class CodexClient {
         return (params as { msg?: EventMsg })?.msg ?? null;
     }
 
-    async close(){
-        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">;
+type CodexRequest = DistributiveOmit<ClientRequest, "id">
+
+type DistributiveOmit<T, K extends keyof any> = T extends any
+    ? Omit<T, K>
+    : never;
diff --git a/src/index.ts b/src/index.ts
