@agentclientprotocol/codex-acp 1.10.0 → 1.10.1-preview.1

package/README.md

@@ -40,6 +40,16 @@ The npm package includes a compatible `@openai/codex` dependency. Set `CODEX_PAT
 CODEX_PATH=/path/to/codex npx -y @agentclientprotocol/codex-acp
 ```
 
+To try changes that have landed on `main` but are not released yet, install from the
+`preview` channel. Pushes to `main` trigger preview publishing without waiting
+for CI or release-please; release commits are excluded, and newer pushes can
+replace queued previews. See
+[docs/RELEASES.md](docs/RELEASES.md#preview-releases).
+
+```bash
+npx -y @agentclientprotocol/codex-acp@preview
+```
+
 ## Authentication
 
 The adapter advertises ACP auth methods during initialization. Clients can authenticate with:

package/dist/index.js

@@ -25956,8 +25956,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
           toolCallId: nextStandaloneToolCallId(),
           kind: context.isToolApproval ? "execute" : "other",
           status: "pending",
+          title: context.isToolApproval ? "MCP tool call approval" : "Question from MCP server",
           content: [messageContent],
-          rawInput: { serverName: params.serverName, schema: params.requestedSchema }
+          rawInput: { serverName: params.serverName, description: params.message, schema: params.requestedSchema }
         },
         ...context.isToolApproval ? { _meta: { is_mcp_tool_approval: true } } : {},
         options
@@ -25975,8 +25976,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
         toolCallId: `elicitation-${params.elicitationId}`,
         kind: "fetch",
         status: "pending",
+        title: "MCP server requests to open a URL",
         content: [messageContent],
-        rawInput: { serverName: params.serverName, url: params.url }
+        rawInput: { serverName: params.serverName, description: params.message, url: params.url }
       },
       options
     },
@@ -26158,11 +26160,29 @@ var CodexElicitationHandler = class {
         context.isToolApproval,
         context.persistOptions
       );
-      if (correlatedCallId !== void 0 && result.action === "accept") {
-        await this.connection.notify(methods.client.session.update, {
-          sessionId: params.threadId,
-          update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
-        });
+      if (correlatedCallId !== void 0) {
+        if (result.action === "accept") {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
+          });
+        }
+      } else {
+        try {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: {
+              sessionUpdate: "tool_call_update",
+              toolCallId: request.toolCall.toolCallId,
+              status: "completed",
+              title: request.toolCall.title,
+              content: request.toolCall.content,
+              rawOutput: { action: result.action }
+            }
+          });
+        } catch (error51) {
+          logger.error("Failed to finalize standalone MCP elicitation tool call", error51);
+        }
       }
       return result;
     } catch (error51) {
@@ -27319,7 +27339,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.10.0",
+  version: "1.10.1-preview.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27889,6 +27909,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
   await dependencies.refreshSkills(request.cwd, additionalDirectories);
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
   const response = await dependencies.codexClient.threadFork({
+    excludeTurns: true,
     config: await dependencies.createSessionConfig(
       request.cwd,
       additionalDirectories,
@@ -27914,10 +27935,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
 async function resolveForkTurnId(request, codexClient) {
   const forkPoint = readAirForkPoint(request._meta);
   if (!forkPoint) return void 0;
-  const history = await codexClient.threadRead({
-    threadId: request.sessionId,
-    includeTurns: true
-  });
+  const history = await codexClient.threadReadWithHistory(request.sessionId);
   const candidateIds = airForkMessageIdCandidates(forkPoint.messageId);
   const itemTurnId = candidateIds.map((candidateId) => history.thread.turns.find((turn) => turn.items.some((item) => item.id === candidateId))?.id).find((turnId) => turnId !== void 0);
   if (itemTurnId) return itemTurnId;
@@ -28340,6 +28358,7 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
@@ -28374,16 +28393,17 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
     });
     onSubscribed?.();
-    const historyResponse = await this.codexClient.threadRead({
-      threadId: response.thread.id,
-      includeTurns: true
-    });
+    const thread = response.thread.historyMode === "paginated" ? {
+      ...response.thread,
+      turns: response.turnsBackwardsCursor === null ? [] : await this.codexClient.threadReadHistory(response.thread.id, response.turnsBackwardsCursor)
+    } : (await this.codexClient.threadReadWithHistory(response.thread.id)).thread;
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -28393,15 +28413,12 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      thread: historyResponse.thread,
+      thread,
       additionalDirectories
     };
   }
   async readSessionThread(sessionId) {
-    return (await this.codexClient.threadRead({
-      threadId: sessionId,
-      includeTurns: true
-    })).thread;
+    return (await this.codexClient.threadReadWithHistory(sessionId)).thread;
   }
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
@@ -28682,6 +28699,7 @@ var CodexAcpClient = class {
     let lateStopReason = null;
     try {
       const forkPromise = this.codexClient.threadFork({
+        excludeTurns: true,
         threadId: params.sessionId,
         lastTurnId: params.turnId,
         cwd: params.workspace.cwd,
@@ -29516,6 +29534,41 @@ var CodexAppServerClient = class {
   async threadRead(params) {
     return await this.sendRequest({ method: "thread/read", params });
   }
+  async threadTurnsList(params) {
+    return await this.sendRequest({ method: "thread/turns/list", params });
+  }
+  async threadReadWithHistory(threadId) {
+    const response = await this.threadRead({ threadId });
+    if (response.thread.historyMode === "legacy") {
+      return await this.threadRead({ threadId, includeTurns: true });
+    }
+    const turns = await this.threadReadHistory(threadId);
+    return { ...response, thread: { ...response.thread, turns } };
+  }
+  async threadReadHistory(threadId, initialCursor = null) {
+    const turns = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    if (initialCursor !== null) seenCursors.add(initialCursor);
+    let cursor = initialCursor;
+    do {
+      const page = await this.threadTurnsList({
+        threadId,
+        cursor,
+        limit: 50,
+        sortDirection: "desc",
+        itemsView: "full"
+      });
+      turns.push(...page.data);
+      cursor = page.nextCursor;
+      if (cursor !== null) {
+        if (seenCursors.has(cursor)) {
+          throw new Error("Codex returned a repeated thread history cursor");
+        }
+        seenCursors.add(cursor);
+      }
+    } while (cursor !== null);
+    return turns.reverse();
+  }
   async threadArchive(params) {
     return await this.sendRequest({ method: "thread/archive", params });
   }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.10.0",
+  "version": "1.10.1-preview.1",
   "description": "",
   "main": "dist/index.js",
   "bin": {