@agentclientprotocol/codex-acp 1.1.8 → 1.1.9

package/dist/index.js

@@ -23582,8 +23582,8 @@ function sameThreadGoalSnapshot(left, right) {
 }
 
 // src/CodexEventHandler.ts
-var CodexEventHandler = class {
-  connection;
+var CodexEventHandler = class _CodexEventHandler {
+  static PLAN_UPDATE_INTERVAL_MS = 150;
   sessionState;
   supportsPlanUpdates;
   failure = null;
@@ -23593,15 +23593,21 @@ var CodexEventHandler = class {
   activeImageGenerationItems = /* @__PURE__ */ new Set();
   emittedImageViewItems = /* @__PURE__ */ new Set();
   planDeltaTextByItemId = /* @__PURE__ */ new Map();
+  pendingPlanItemIds = /* @__PURE__ */ new Set();
+  lastEmittedPlanTextByItemId = /* @__PURE__ */ new Map();
+  session;
+  planUpdateTimer = null;
+  planUpdateChain = Promise.resolve();
+  disposed = false;
   seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   activeSubAgentActivities = /* @__PURE__ */ new Set();
   constructor(connection, sessionState, supportsPlanUpdates = false) {
-    this.connection = connection;
     this.sessionState = sessionState;
     this.supportsPlanUpdates = supportsPlanUpdates;
+    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
   }
   getFailure() {
     return this.failure;
@@ -23612,12 +23618,32 @@ var CodexEventHandler = class {
     return plan;
   }
   async handleNotification(notification) {
-    const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
-      await session.update(updateEvent);
+      await this.session.update(updateEvent);
     }
   }
+  async flushPendingPlanUpdates() {
+    this.cancelPlanUpdateTimer();
+    do {
+      const itemIds = [...this.pendingPlanItemIds];
+      this.pendingPlanItemIds.clear();
+      await Promise.all(itemIds.map((itemId) => {
+        const text = this.planDeltaTextByItemId.get(itemId) ?? "";
+        return text.length > 0 ? this.enqueuePlanSnapshot(itemId, text) : Promise.resolve();
+      }));
+      await this.planUpdateChain;
+    } while (this.pendingPlanItemIds.size > 0);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    await this.flushPendingPlanUpdates();
+    this.disposed = true;
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
+  }
   async createUpdateEvent(notification) {
     switch (notification.method) {
       case "item/agentMessage/delta":
@@ -23636,6 +23662,8 @@ var CodexEventHandler = class {
         this.sessionState.currentTurnId = notification.params.turn.id;
         return null;
       case "turn/completed":
+        await this.flushPendingPlanUpdates();
+        this.clearPlanTurnState();
         this.sessionState.currentTurnId = null;
         return null;
       case "thread/tokenUsage/updated":
@@ -23806,7 +23834,11 @@ ${event.details}` : "";
     const text = this.planDeltaTextByItemId.get(event.itemId) ?? "";
     const updatedText = text + event.delta;
     this.planDeltaTextByItemId.set(event.itemId, updatedText);
-    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(updatedText, event.itemId) : null;
+    if (this.supportsPlanUpdates) {
+      this.pendingPlanItemIds.add(event.itemId);
+      this.schedulePlanUpdate();
+    }
+    return null;
   }
   createReasoningSectionBreakEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
@@ -23903,8 +23935,7 @@ ${event.details}` : "";
         return null;
       case "plan": {
         const deltaText = this.planDeltaTextByItemId.get(event.item.id) ?? "";
-        this.planDeltaTextByItemId.delete(event.item.id);
-        return this.createCompletedPlanEvent(event.item, deltaText);
+        return await this.createCompletedPlanEvent(event.item, deltaText);
       }
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
@@ -23933,13 +23964,53 @@ ${event.details}` : "";
     }
     return this.createAgentThoughtEvent(text, item.id);
   }
-  createCompletedPlanEvent(item, deltaText) {
+  async createCompletedPlanEvent(item, deltaText) {
     const text = item.text.length > 0 ? item.text : deltaText;
+    this.pendingPlanItemIds.delete(item.id);
+    if (this.pendingPlanItemIds.size === 0) {
+      this.cancelPlanUpdateTimer();
+    }
+    this.planDeltaTextByItemId.delete(item.id);
     if (text.length === 0) {
       return null;
     }
     this.completedPlan = { itemId: item.id, text };
-    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(text, item.id) : this.createPlanTextEvent(text, item.id);
+    if (this.supportsPlanUpdates) {
+      await this.enqueuePlanSnapshot(item.id, text);
+      return null;
+    }
+    return this.createPlanTextEvent(text, item.id);
+  }
+  schedulePlanUpdate() {
+    if (this.disposed || this.planUpdateTimer !== null) return;
+    this.planUpdateTimer = setTimeout(() => {
+      this.planUpdateTimer = null;
+      void this.flushPendingPlanUpdates().catch((error51) => {
+        logger.error("Failed to flush throttled plan updates", error51);
+      });
+    }, _CodexEventHandler.PLAN_UPDATE_INTERVAL_MS);
+  }
+  cancelPlanUpdateTimer() {
+    if (this.planUpdateTimer === null) return;
+    clearTimeout(this.planUpdateTimer);
+    this.planUpdateTimer = null;
+  }
+  enqueuePlanSnapshot(itemId, text) {
+    const send = async () => {
+      if (this.lastEmittedPlanTextByItemId.get(itemId) === text) return;
+      await this.session.update(this.createPlanUpdateEvent(text, itemId));
+      this.lastEmittedPlanTextByItemId.set(itemId, text);
+    };
+    const result = this.planUpdateChain.then(send);
+    this.planUpdateChain = result.catch(() => {
+    });
+    return result;
+  }
+  clearPlanTurnState() {
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
   }
   createPlanUpdateEvent(text, planId) {
     return {
@@ -26065,7 +26136,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.8",
+  version: "1.1.9",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -30035,12 +30106,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return pendingTurnStart;
     };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
+    let eventHandler = null;
     try {
-      const eventHandler = new CodexEventHandler(
+      const promptEventHandler = new CodexEventHandler(
         this.connection,
         sessionState,
         clientSupportsPlanUpdates(this.clientCapabilities)
       );
+      eventHandler = promptEventHandler;
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
@@ -30052,7 +30125,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         params.sessionId,
         async (event) => {
           await elicitationHandler.handleNotification(event);
-          return eventHandler.handleNotification(event);
+          return promptEventHandler.handleNotification(event);
         },
         approvalHandler,
         elicitationHandler
@@ -30177,6 +30250,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
+        await eventHandler.flushPendingPlanUpdates();
         await this.notifyConversationInterrupted(params.sessionId);
         return this.cancelledPromptResponse(sessionState);
       }
@@ -30184,6 +30258,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       if (error51) {
         throw error51;
       }
+      await eventHandler.flushPendingPlanUpdates();
       const completedPlan = eventHandler.takeCompletedPlan();
       if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
         const approved = await this.requestPlanImplementationPermission(
@@ -30242,6 +30317,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
           if (turnCompleted.turn.status === "interrupted") {
+            await eventHandler.flushPendingPlanUpdates();
             await this.notifyConversationInterrupted(params.sessionId);
             return this.cancelledPromptResponse(sessionState);
           }
@@ -30265,6 +30341,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       throw err;
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
+      await eventHandler?.dispose();
       disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
       const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "",
   "main": "dist/index.js",
   "bin": {