@agentclientprotocol/codex-acp 1.11.1-preview.6 → 1.12.1-preview.1

package/dist/index.js

@@ -23921,19 +23921,24 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
   closingChildSessions(notification) {
     if (!this.supported) return [];
     if (notification.method === "turn/completed") {
-      if (terminalStateFromTurn(notification.params.turn.status) === void 0) return [];
-      return this.closingChildSession(notification.params.threadId);
+      const state = terminalStateFromTurn(notification.params.turn.status);
+      if (state === void 0) return [];
+      if (notification.params.threadId === this.rootSessionId && state !== "completed") {
+        return [...this.children.keys()].flatMap((threadId) => this.closingChildSession(threadId, state));
+      }
+      return this.closingChildSession(notification.params.threadId, state);
     }
     if (notification.method !== "item/started" && notification.method !== "item/completed") return [];
     const item = notification.params.item;
     if (item.type === "subAgentActivity") {
-      return item.kind === "interrupted" ? this.closingChildSession(item.agentThreadId) : [];
+      return item.kind === "interrupted" ? this.closingChildSession(item.agentThreadId, "cancelled") : [];
     }
     if (item.type !== "collabAgentToolCall") return [];
     const closing = /* @__PURE__ */ new Map();
     for (const [threadId, state] of Object.entries(item.agentsStates)) {
-      if (!state || terminalStateOf(state.status) === void 0) continue;
-      for (const child of this.closingChildSession(threadId)) closing.set(threadId, child);
+      const terminalState = state && terminalStateOf(state.status);
+      if (!terminalState) continue;
+      for (const child of this.closingChildSession(threadId, terminalState)) closing.set(threadId, child);
     }
     return [...closing.values()];
   }
@@ -23965,15 +23970,15 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
     const sessionUpdate = this.activeLegacyActivities.delete(item.id) ? "tool_call_update" : "tool_call";
     return createSubAgentActivityUpdate(item, "completed", sessionUpdate);
   }
+  /** The caller finalizes pending child updates before closing timed-out sessions. */
   async wait(signal, timeoutMs = _CodexSubagentEventRouter.DEFAULT_WAIT_TIMEOUT_MS) {
     const deadline = Date.now() + timeoutMs;
     while (this.hasOutstanding()) {
-      if (signal.aborted) return;
+      if (signal.aborted) return "aborted";
       const remainingMs = deadline - Date.now();
       if (remainingMs <= 0) {
         logger.log(`Timed out waiting for subagents in session ${this.rootSessionId}; marking them failed`);
-        await this.finishOutstanding("failed");
-        return;
+        return "timed_out";
       }
       const changed = await new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -23996,10 +24001,10 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
       });
       if (!changed) {
         logger.log(`Timed out waiting for subagents in session ${this.rootSessionId}; marking them failed`);
-        await this.finishOutstanding("failed");
-        return;
+        return "timed_out";
       }
     }
+    return "settled";
   }
   async finishOutstanding(state) {
     for (const childSessionId of [...this.pendingSpawns.keys()]) {
@@ -24012,9 +24017,9 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
   isKnownChild(threadId) {
     return threadId !== this.rootSessionId && (this.children.has(threadId) || this.pendingSpawns.has(threadId) || this.terminalPendingSpawns.has(threadId));
   }
-  closingChildSession(threadId) {
+  closingChildSession(threadId, state) {
     const child = this.children.get(threadId);
-    return child && child.terminalState === void 0 ? [{ threadId, sessionId: child.sessionId }] : [];
+    return child && child.terminalState === void 0 ? [{ threadId, sessionId: child.sessionId, state }] : [];
   }
   async materialize(childSessionId, path9) {
     if (this.children.has(childSessionId)) return;
@@ -24577,6 +24582,25 @@ var STRUCTURED_CODEX_ERROR_CATEGORIES = {
   activeTurnNotSteerable: "provider_error"
 };
 var CodexEventHandler = class _CodexEventHandler {
+  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
+    sessionState.sessionId,
+    false,
+    new ACPSessionConnection(connection, sessionState.sessionId)
+  ), onAccountUpdated, collectTurnDiffs = false, supportsCompaction = false) {
+    this.supportsCompaction = supportsCompaction;
+    this.onAccountUpdated = onAccountUpdated;
+    this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
+    this.supportsTypedSessionFailures = supportsTypedSessionFailures;
+    this.sessionFailureEpoch = sessionFailureEpoch;
+    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
+    this.subagents = subagents;
+    this.collectTurnDiffs = collectTurnDiffs;
+    if (sessionState.sessionFailure !== void 0) {
+      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
+    }
+  }
+  supportsCompaction;
   static PLAN_UPDATE_INTERVAL_MS = 150;
   sessionState;
   supportsPlanUpdates;
@@ -24612,23 +24636,6 @@ var CodexEventHandler = class _CodexEventHandler {
   subagents;
   /** Connection-level `authStatus` sink; the app-server account push feeds it. */
   onAccountUpdated;
-  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
-    sessionState.sessionId,
-    false,
-    new ACPSessionConnection(connection, sessionState.sessionId)
-  ), onAccountUpdated, collectTurnDiffs = false) {
-    this.onAccountUpdated = onAccountUpdated;
-    this.sessionState = sessionState;
-    this.supportsPlanUpdates = supportsPlanUpdates;
-    this.supportsTypedSessionFailures = supportsTypedSessionFailures;
-    this.sessionFailureEpoch = sessionFailureEpoch;
-    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
-    this.subagents = subagents;
-    this.collectTurnDiffs = collectTurnDiffs;
-    if (sessionState.sessionFailure !== void 0) {
-      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
-    }
-  }
   getFailure() {
     return this.failure;
   }
@@ -24662,6 +24669,7 @@ var CodexEventHandler = class _CodexEventHandler {
       await this.handleNotification(notification);
       return;
     }
+    await this.finishCompactionsForNotification(notification);
     if (notification.params.willRetry) {
       await this.session.update(this.createSessionFailureUpdate(this.recordRetryWarning(notification.params, false)));
       return;
@@ -24733,8 +24741,13 @@ var CodexEventHandler = class _CodexEventHandler {
   }
   async handleNotification(notification) {
     await this.flushPendingErrors();
+    await this.finishCompactionsForNotification(notification);
     const closingChildren = this.subagents.closingChildSessions(notification);
     for (const child of closingChildren) {
+      await this.finishOutstandingCompactions(
+        child.state === "cancelled" ? "cancelled" : "failed",
+        child.sessionId
+      );
       await this.sessionState.asyncTasks.reconcile(child.threadId, child.sessionId);
     }
     const handledBySubagents = await this.subagents.handle(notification);
@@ -24764,11 +24777,45 @@ var CodexEventHandler = class _CodexEventHandler {
     return await this.subagents.waitForMaterializedSession(childThreadId);
   }
   async waitForNativeSubagents(signal) {
-    await this.subagents.wait(signal);
+    if (await this.subagents.wait(signal) === "timed_out") {
+      await this.finishOutstandingNativeSubagents("failed");
+    }
   }
   async finishOutstandingNativeSubagents(state) {
+    await this.finishOutstandingCompactions(state === "cancelled" ? "cancelled" : "failed");
     await this.subagents.finishOutstanding(state);
   }
+  async finishOutstandingCompactions(status, sessionId) {
+    if (!this.supportsCompaction) return;
+    for (const { sessionId: targetSessionId, update } of this.sessionState.compactions.finishOutstanding(status, sessionId)) {
+      await this.session.update(update, targetSessionId);
+    }
+  }
+  async finishCompactionsForNotification(notification) {
+    if (!this.supportsCompaction) return;
+    let updates;
+    const sessionId = this.subagents.notificationSessionId(notification);
+    if (notification.method === "turn/completed") {
+      const turn = notification.params.turn;
+      if (turn.status === "inProgress") return;
+      updates = this.sessionState.compactions.finishTurn(
+        sessionId,
+        turn.id,
+        turn.status === "interrupted" ? "cancelled" : "failed",
+        turn.error?.message ?? "Codex ended the turn before compaction completed."
+      );
+    } else if (notification.method === "error" && !notification.params.willRetry) {
+      updates = this.sessionState.compactions.finishTurn(
+        sessionId,
+        notification.params.turnId,
+        "failed",
+        notification.params.error.message
+      );
+    } else {
+      return;
+    }
+    for (const update of updates) await this.session.update(update, sessionId);
+  }
   async flushPendingPlanUpdates() {
     this.cancelPlanUpdateTimer();
     do {
@@ -24892,7 +24939,10 @@ var CodexEventHandler = class _CodexEventHandler {
       case "item/autoApprovalReview/completed":
         return this.handleGuardianApprovalReviewCompleted(notification.params);
       case "thread/compacted":
-        return this.createContextCompactedEvent();
+        return this.supportsCompaction ? this.sessionState.compactions.completeLegacy(
+          this.subagents.notificationSessionId(notification),
+          notification.params.turnId
+        ) : this.createContextCompactedEvent();
       case "item/reasoning/summaryTextDelta":
         this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningDeltaEvent(notification.params);
@@ -25091,7 +25141,11 @@ ${event.details}` : event.summary;
         this.rememberAgentMessagePhase(event.item);
         return null;
       case "contextCompaction":
-        return createContextCompactionStartUpdate(event.item);
+        return this.supportsCompaction ? this.sessionState.compactions.start(
+          this.subagents.notificationSessionId({ method: "item/started", params: event }),
+          event.turnId,
+          event.item.id
+        ) : createContextCompactionStartUpdate(event.item);
       case "subAgentActivity":
         return this.subagents.legacyActivityStarted(event.item);
       case "sleep":
@@ -25159,7 +25213,11 @@ ${event.details}` : event.summary;
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
-        return createContextCompactionCompleteUpdate(event.item);
+        return this.supportsCompaction ? this.sessionState.compactions.complete(
+          this.subagents.notificationSessionId({ method: "item/completed", params: event }),
+          event.turnId,
+          event.item.id
+        ) : createContextCompactionCompleteUpdate(event.item);
       //ignored types
       case "subAgentActivity":
         return this.subagents.legacyActivityCompleted(event.item);
@@ -27808,7 +27866,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.11.1-preview.6",
+  version: "1.12.1-preview.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -28637,8 +28695,9 @@ var CodexAcpClient = class {
       delivery: "inline"
     }, onTurnStarted);
   }
-  async runCompact(sessionId) {
-    await this.codexClient.runCompact({ threadId: sessionId });
+  async runCompact(sessionId, onTurnStarted) {
+    const completed = await this.codexClient.runCompact({ threadId: sessionId }, onTurnStarted);
+    return completed.method === "turn/completed" ? completed.params : void 0;
   }
   async getGoal(sessionId) {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
@@ -29242,7 +29301,7 @@ var CodexAppServerClient = class {
       if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
       }
-      this.recordTurnRouting(routing);
+      this.recordTurnRouting(routing, serverNotification);
       if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
       }
@@ -29524,10 +29583,45 @@ var CodexAppServerClient = class {
       threadStatusChanged: handleThreadStatusChanged
     };
   }
-  async runCompact(params) {
-    const compactionCompleted = this.awaitCompactionCompleted(params.threadId);
-    await this.threadCompactStart(params);
-    return await compactionCompleted;
+  async runCompact(params, onTurnStarted) {
+    let compactTurnId = null;
+    let resolveCompleted = () => {
+    };
+    let rejectCompleted = () => {
+    };
+    const completed = new Promise((resolve, reject) => {
+      resolveCompleted = resolve;
+      rejectCompleted = reject;
+    });
+    void completed.catch(() => {
+    });
+    const closed = this.connection.onClose?.(() => rejectCompleted(new Error("Codex connection closed during compaction.")));
+    const completeCompaction = (event) => {
+      if (compactTurnId !== null && event.params.turnId !== compactTurnId) return;
+      resolveCompleted(event);
+    };
+    const releaseCompactionCapture = this.captureCompactionCompletions(params.threadId, completeCompaction);
+    const releaseTurnCapture = this.captureTurnCompletions(params.threadId, (event) => {
+      if (compactTurnId === null || event.turn.id !== compactTurnId) return;
+      if (event.turn.status !== "inProgress") {
+        resolveCompleted({ method: "turn/completed", params: event });
+      }
+    });
+    const releaseRoutingCapture = this.captureTurnRoutings(params.threadId, (turnId, notification) => {
+      if (compactTurnId !== null) return;
+      if (notification.method !== "turn/started" && !(notification.method === "item/started" && notification.params.item.type === "contextCompaction")) return;
+      compactTurnId = turnId;
+      onTurnStarted?.(turnId);
+    });
+    try {
+      await this.threadCompactStart(params);
+      return await completed;
+    } finally {
+      releaseTurnCapture();
+      releaseRoutingCapture();
+      releaseCompactionCapture();
+      closed?.dispose();
+    }
   }
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
@@ -29697,9 +29791,10 @@ var CodexAppServerClient = class {
   }
   async awaitCompactionCompleted(threadId) {
     return await new Promise((resolve) => {
-      const resolvers = this.pendingCompactionCompletionResolvers.get(threadId) ?? /* @__PURE__ */ new Set();
-      resolvers.add(resolve);
-      this.pendingCompactionCompletionResolvers.set(threadId, resolvers);
+      const releaseCapture = this.captureCompactionCompletions(threadId, (event) => {
+        releaseCapture();
+        resolve(event);
+      });
     });
   }
   resolveTurnInterrupted(threadId, turnId) {
@@ -29779,11 +29874,24 @@ var CodexAppServerClient = class {
     if (!resolvers) {
       return;
     }
-    this.pendingCompactionCompletionResolvers.delete(threadId);
     for (const resolve of resolvers) {
       resolve(event);
     }
   }
+  captureCompactionCompletions(threadId, capture) {
+    const captures = this.pendingCompactionCompletionResolvers.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.pendingCompactionCompletionResolvers.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.pendingCompactionCompletionResolvers.delete(threadId);
+      }
+    };
+  }
   recordThreadStatusChanged(event) {
     const captures = this.threadStatusCaptures.get(event.threadId);
     if (!captures) {
@@ -29811,7 +29919,7 @@ var CodexAppServerClient = class {
       capture();
     }
   }
-  recordTurnRouting(routing) {
+  recordTurnRouting(routing, notification) {
     if (routing.threadId === null || routing.turnId === null) {
       return;
     }
@@ -29820,7 +29928,7 @@ var CodexAppServerClient = class {
       return;
     }
     for (const capture of captures) {
-      capture(routing.turnId);
+      capture(routing.turnId, notification);
     }
   }
   handleStaleTurnNotification(notification, routing) {
@@ -30267,8 +30375,12 @@ var CodexCommands = class {
         return { handled: options.setConfigOption !== void 0 };
       }
       case "compact": {
-        await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
-        return { handled: true };
+        options.onTurnStartPending?.();
+        const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(
+          sessionId,
+          (turnId) => options.onTurnStarted?.(turnId, sessionId)
+        ));
+        return { handled: true, ...turnCompleted === void 0 ? {} : { turnCompleted } };
       }
       case "goal": {
         return await this.runGoalCommand(sessionState, command.rest, options);
@@ -32233,6 +32345,72 @@ function notificationThreadId(notification) {
   return typeof threadId === "string" ? threadId : null;
 }
 
+// src/CodexSessionCompactions.ts
+function clientSupportsCompaction(capabilities) {
+  return capabilities?.session?.compaction != null;
+}
+function createCompactionUpdate(compactionId, status, error51) {
+  return {
+    sessionUpdate: "compaction_update",
+    compactionId,
+    status,
+    ...status === "failed" && error51 !== void 0 ? { error: error51 } : {}
+  };
+}
+var CodexSessionCompactions = class {
+  items = /* @__PURE__ */ new Map();
+  latestByTurn = /* @__PURE__ */ new Map();
+  start(sessionId, turnId, itemId) {
+    const key = JSON.stringify([sessionId, itemId]);
+    if (this.items.has(key)) return null;
+    const compaction = this.remember(sessionId, turnId, itemId);
+    return createCompactionUpdate(compaction.id, "in_progress");
+  }
+  complete(sessionId, turnId, itemId) {
+    const latest = this.latestByTurn.get(JSON.stringify([sessionId, turnId]));
+    if (!this.items.has(JSON.stringify([sessionId, itemId])) && latest?.legacyOnly) {
+      this.items.delete(JSON.stringify([sessionId, latest.id]));
+      this.items.set(JSON.stringify([sessionId, itemId]), latest);
+      latest.legacyOnly = false;
+    }
+    const compaction = this.items.get(JSON.stringify([sessionId, itemId])) ?? this.remember(sessionId, turnId, itemId);
+    return this.finish(compaction, "completed");
+  }
+  completeLegacy(sessionId, turnId) {
+    const compaction = this.latestByTurn.get(JSON.stringify([sessionId, turnId])) ?? this.remember(sessionId, turnId, `compaction:${turnId}`, true);
+    return this.finish(compaction, "completed");
+  }
+  finishTurn(sessionId, turnId, status, error51) {
+    const updates = [];
+    for (const compaction of this.items.values()) {
+      if (compaction.sessionId !== sessionId || compaction.turnId !== turnId) continue;
+      const update = this.finish(compaction, status, error51);
+      if (update) updates.push(update);
+    }
+    return updates;
+  }
+  finishOutstanding(status, sessionId) {
+    const updates = [];
+    for (const compaction of this.items.values()) {
+      if (sessionId !== void 0 && compaction.sessionId !== sessionId) continue;
+      const update = this.finish(compaction, status);
+      if (update) updates.push({ sessionId: compaction.sessionId, update });
+    }
+    return updates;
+  }
+  remember(sessionId, turnId, id, legacyOnly = false) {
+    const compaction = { sessionId, turnId, id, terminal: false, legacyOnly };
+    this.items.set(JSON.stringify([sessionId, id]), compaction);
+    this.latestByTurn.set(JSON.stringify([sessionId, turnId]), compaction);
+    return compaction;
+  }
+  finish(compaction, status, error51) {
+    if (compaction.terminal) return null;
+    compaction.terminal = true;
+    return createCompactionUpdate(compaction.id, status, error51);
+  }
+};
+
 // src/CodexAcpServer.ts
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
 function clientSupportsTypedSessionFailures(capabilities) {
@@ -32646,7 +32824,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
       ),
-      asyncTasks: this.createAsyncTasks(sessionId)
+      asyncTasks: this.createAsyncTasks(sessionId),
+      compactions: new CodexSessionCompactions()
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -33706,7 +33885,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
       ),
-      asyncTasks: this.createAsyncTasks(sessionId)
+      asyncTasks: this.createAsyncTasks(sessionId),
+      compactions: new CodexSessionCompactions()
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -33981,7 +34161,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       case "exitedReviewMode":
         return [this.createReviewModeUpdate(item, false)];
       case "contextCompaction":
-        return [createCompletedContextCompactionUpdate(item)];
+        return [clientSupportsCompaction(this.clientCapabilities) ? createCompactionUpdate(item.id, "completed") : createCompletedContextCompactionUpdate(item)];
       case "plan":
         return item.text.length > 0 ? [this.createPlanHistoryUpdate(item)] : [];
     }
@@ -34417,7 +34597,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.sessionFailureEpoch,
         sessionState.subagents,
         (accountUpdated) => this.handleAccountUpdated(accountUpdated),
-        agentFileChangeReportRequest !== null
+        agentFileChangeReportRequest !== null,
+        clientSupportsCompaction(this.clientCapabilities)
       );
       eventHandler = promptEventHandler;
       const permissionLifecycle = this.permissionLifecycleContext(sessionState);
@@ -34767,7 +34948,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           promptWasCancelled || activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId) ? "cancelled" : "failed"
         );
       } catch (error51) {
-        logger.error("Failed to publish terminal subagent state during prompt cleanup", error51);
+        logger.error("Failed to publish terminal compaction or subagent state during prompt cleanup", error51);
       }
       if (agentFileChangeReportRequest !== null && agentFileChangeWorkspace !== null) {
         if (promptWasCancelled || activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId)) {

package/package.json

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