@agentclientprotocol/codex-acp 2.5.1-preview.4 → 2.5.1-preview.5

package/dist/index.js

@@ -40475,7 +40475,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "2.5.1-preview.4",
+  version: "2.5.1-preview.5",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -40648,7 +40648,7 @@ var CodexSubagentSubscriptions = class {
       existing.current = subscription;
       return;
     }
-    const session = { current: subscription, children: /* @__PURE__ */ new Set() };
+    const session = { current: subscription, children: /* @__PURE__ */ new Set(), childParents: /* @__PURE__ */ new Map() };
     this.sessions.set(subscription.rootSessionId, session);
     this.client.onServerNotification(subscription.rootSessionId, (event) => {
       this.discover(session, event);
@@ -40670,10 +40670,35 @@ var CodexSubagentSubscriptions = class {
   isChildThread(threadId) {
     return [...this.sessions.values()].some((session) => session.children.has(threadId));
   }
+  async readChildThread(threadId) {
+    const session = [...this.sessions.values()].find((session2) => session2.children.has(threadId));
+    const { thread } = await this.client.threadRead({ threadId });
+    if (!thread || thread.id !== threadId) return null;
+    if (session && this.sessions.get(session.current.rootSessionId) === session) this.rememberParent(session, thread);
+    return thread;
+  }
+  /** Use observed ownership, without waiting on unrelated metadata reads during close. */
+  verifiedChildThreadIds(rootSessionId) {
+    const parents = this.sessions.get(rootSessionId)?.childParents ?? /* @__PURE__ */ new Map();
+    const owned = /* @__PURE__ */ new Set([rootSessionId]);
+    let changed;
+    do {
+      changed = false;
+      for (const [threadId, parentId] of parents) {
+        if (!owned.has(threadId) && owned.has(parentId)) {
+          owned.add(threadId);
+          changed = true;
+        }
+      }
+    } while (changed);
+    owned.delete(rootSessionId);
+    return [...owned];
+  }
   async restoreChild(rootSessionId, parentThreadId, thread) {
     const session = this.sessions.get(rootSessionId);
     if (!session || session.children.has(thread.id) || thread.parentThreadId !== parentThreadId || parentThreadId !== rootSessionId && !session.children.has(parentThreadId)) return null;
     if (!this.attachChild(session, thread.id)) return null;
+    this.rememberParent(session, thread);
     if (thread.status.type === "notLoaded") return null;
     try {
       const response = await this.client.threadResume({ threadId: thread.id, excludeTurns: true });
@@ -40686,6 +40711,10 @@ var CodexSubagentSubscriptions = class {
     return null;
   }
   discover(session, event) {
+    if (event.method === "thread/started") {
+      if (session.children.has(event.params.thread.id)) this.rememberParent(session, event.params.thread);
+      return;
+    }
     if (event.method !== "item/started" && event.method !== "item/completed") {
       return;
     }
@@ -40714,8 +40743,13 @@ var CodexSubagentSubscriptions = class {
   }
   detachChild(session, childSessionId) {
     if (this.sessions.get(session.current.rootSessionId) !== session || !session.children.delete(childSessionId)) return;
+    session.childParents.delete(childSessionId);
     if (!this.sessions.has(childSessionId)) this.client.clearThreadHandlers(childSessionId);
   }
+  rememberParent(session, thread) {
+    if (thread.status.type === "notLoaded" || thread.parentThreadId === null) session.childParents.delete(thread.id);
+    else session.childParents.set(thread.id, thread.parentThreadId);
+  }
   registerInteractiveHandlers(session, targetSessionId) {
     this.client.onApprovalRequest(targetSessionId, {
       handleCommandExecution: async (params) => {
@@ -41635,6 +41669,9 @@ var CodexAcpClient = class _CodexAcpClient {
   isSubagentThread(threadId) {
     return this.subagents.isChildThread(threadId);
   }
+  readSubagentThread(threadId) {
+    return this.subagents.readChildThread(threadId);
+  }
   async newSession(request) {
     const instructions = await this.resolveSessionInstructions(request, void 0, true);
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
@@ -41735,11 +41772,30 @@ var CodexAcpClient = class _CodexAcpClient {
     }
   }
   async closeSession(sessionId) {
+    const children = this.subagents.verifiedChildThreadIds(sessionId);
+    for (const threadId of [...children, sessionId]) {
+      await this.stopBackgroundTerminals(threadId);
+    }
+    await this.codexClient.threadUnsubscribe({ threadId: sessionId });
+    this.codexClient.clearThreadHandlers(sessionId);
+    this.subagents.clear(sessionId);
+  }
+  async stopBackgroundTerminals(threadId) {
     try {
-      await this.codexClient.threadUnsubscribe({ threadId: sessionId });
-    } finally {
-      this.codexClient.clearThreadHandlers(sessionId);
-      this.subagents.clear(sessionId);
+      const terminals = [];
+      for await (const page of this.codexClient.backgroundTerminalPages(threadId)) terminals.push(...page);
+      for (const terminal of terminals) {
+        const result = await this.codexClient.threadBackgroundTerminalsTerminate({ threadId, processId: terminal.processId });
+        if (!result.terminated) {
+          for await (const page of this.codexClient.backgroundTerminalPages(threadId)) {
+            if (page.some((current) => current.processId === terminal.processId)) {
+              throw new Error(`Codex could not stop background terminal ${terminal.processId}`);
+            }
+          }
+        }
+      }
+    } catch (error62) {
+      if (!isThreadNotFoundError(error62) && !isThreadNotLoadedError(error62)) throw error62;
     }
   }
   /**
@@ -43277,6 +43333,19 @@ var CodexAppServerClient = class {
   async threadBackgroundTerminalsTerminate(params) {
     return await this.sendRequest({ method: "thread/backgroundTerminals/terminate", params });
   }
+  async *backgroundTerminalPages(threadId) {
+    const seen = /* @__PURE__ */ new Set();
+    let cursor = null;
+    do {
+      const response = await this.threadBackgroundTerminalsList({ threadId, cursor });
+      yield response.data;
+      cursor = response.nextCursor;
+      if (cursor !== null) {
+        if (seen.has(cursor)) throw new Error("Codex returned a repeated background terminal cursor");
+        seen.add(cursor);
+      }
+    } while (cursor !== null);
+  }
   async threadGoalSet(params) {
     return await this.sendRequest({ method: "thread/goal/set", params });
   }
@@ -46164,13 +46233,16 @@ function hasPayload(update) {
   return Object.keys(update).some((name) => name !== "sessionUpdate" && name !== "toolCallId");
 }
 
-// src/ToolCallReportingConnection.ts
-var ToolCallReportingConnection = class {
-  constructor(client) {
+// src/AcpClientDelivery.ts
+var AcpClientDelivery = class {
+  constructor(client, sessionIsClosing = () => false) {
     this.client = client;
+    this.sessionIsClosing = sessionIsClosing;
   }
   client;
+  sessionIsClosing;
   reports = new ToolCallReports();
+  sessionRequests = /* @__PURE__ */ new Map();
   /** Returns this connection with the signature of the SDK connection. */
   asClientConnection() {
     return this;
@@ -46186,12 +46258,12 @@ var ToolCallReportingConnection = class {
   }
   async request(method, params, options) {
     if (method !== methods.client.session.requestPermission || !isPermissionRequestParams(params)) {
-      return await this.client.request(method, params, options);
+      return await this.sendRequest(method, params, options);
     }
     this.reports.prepare(params.sessionId, { sessionUpdate: "tool_call_update", ...params.toolCall });
     let response;
     try {
-      response = await this.client.request(method, params, options);
+      response = await this.sendRequest(method, params, options);
     } catch (error62) {
       this.reports.forgetOpen(params.sessionId, params.toolCall.toolCallId);
       throw error62;
@@ -46199,7 +46271,37 @@ var ToolCallReportingConnection = class {
     if (isCancelled(response)) this.reports.forgetOpen(params.sessionId, params.toolCall.toolCallId);
     return response;
   }
+  /** Withdraw pending UI without waiting for the client to answer the cancelled requests. */
+  cancelSessionRequests(sessionId) {
+    for (const controller of this.sessionRequests.get(sessionId) ?? []) {
+      controller.abort(RequestError.requestCancelled(void 0, `Session ${sessionId} is closing`));
+    }
+  }
+  async sendRequest(method, params, options) {
+    const sessionId = interactionSessionId(method, params);
+    if (sessionId === null) return await this.client.request(method, params, options);
+    if (this.sessionIsClosing(sessionId)) {
+      throw RequestError.requestCancelled(void 0, `Session ${sessionId} is closing`);
+    }
+    const controller = new AbortController();
+    const requests = this.sessionRequests.get(sessionId) ?? /* @__PURE__ */ new Set();
+    this.sessionRequests.set(sessionId, requests);
+    requests.add(controller);
+    const cancellationSignal = options?.cancellationSignal ? AbortSignal.any([options.cancellationSignal, controller.signal]) : controller.signal;
+    try {
+      return await this.client.request(method, params, { ...options, cancellationSignal });
+    } finally {
+      requests.delete(controller);
+      if (requests.size === 0) this.sessionRequests.delete(sessionId);
+    }
+  }
 };
+function interactionSessionId(method, params) {
+  if (method !== methods.client.elicitation.create && method !== methods.client.session.requestPermission) return null;
+  if (params === null || typeof params !== "object") return null;
+  const sessionId = params.sessionId;
+  return typeof sessionId === "string" ? sessionId : null;
+}
 function isCancelled(response) {
   return response?.outcome?.outcome === "cancelled";
 }
@@ -49406,23 +49508,10 @@ var CodexBackgroundTerminalTasks = class {
     const appServer = this.appServer;
     const generation = this.appServerGeneration;
     const terminals = [];
-    const seenCursors = /* @__PURE__ */ new Set();
-    let cursor = null;
-    do {
-      const response = await appServer.threadBackgroundTerminalsList({
-        threadId,
-        cursor
-      });
+    for await (const page of appServer.backgroundTerminalPages(threadId)) {
       if (!this.queryIsCurrent(generation)) return null;
-      terminals.push(...response.data);
-      cursor = response.nextCursor;
-      if (cursor !== null) {
-        if (seenCursors.has(cursor)) {
-          throw new Error("Codex returned a repeated background terminal cursor");
-        }
-        seenCursors.add(cursor);
-      }
-    } while (cursor !== null);
+      terminals.push(...page);
+    }
     return { generation, terminals };
   }
   isActive() {
@@ -49559,7 +49648,7 @@ var CodexAcpServer = class {
   codexAcpClient;
   connection;
   mcpServerSignIn;
-  reportingConnection;
+  clientDelivery;
   /** ACP protocol version of the connection this agent serves, fixed by the protocol router. */
   protocolVersion;
   /** The v2 client handle; `null` on a v1 connection. */
@@ -49656,18 +49745,19 @@ var CodexAcpServer = class {
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
     this.permissionLifecycleContexts = /* @__PURE__ */ new WeakMap();
+    const sessionIsClosing = (id) => this.sessionIsClosing(this.subagentAssociations.get(id)?.rootSessionId ?? id);
     if (connection instanceof AcpV2Connection) {
       this.protocolVersion = 2;
       this.v2Connection = connection.client;
-      this.reportingConnection = new ToolCallReportingConnection(connection.extensionOnlyV1View());
-      this.connection = this.reportingConnection.asClientConnection();
+      this.clientDelivery = new AcpClientDelivery(connection.extensionOnlyV1View(), sessionIsClosing);
+      this.connection = this.clientDelivery.asClientConnection();
       connection.registerView(this.connection);
       connection.setTurnRunningCheck((sessionId) => this.isSessionBusy(sessionId));
     } else {
       this.protocolVersion = 1;
       this.v2Connection = null;
-      this.reportingConnection = new ToolCallReportingConnection(connection);
-      this.connection = this.reportingConnection.asClientConnection();
+      this.clientDelivery = new AcpClientDelivery(connection, sessionIsClosing);
+      this.connection = this.clientDelivery.asClientConnection();
     }
     this.codexAcpClient = codexAcpClient;
     this.mcpServerSignIn = createMcpServerSignIn(
@@ -49716,7 +49806,7 @@ var CodexAcpServer = class {
     const existing = this.sessions.get(sessionId)?.subagents;
     if (this.usesStandardSubagents() && existing instanceof StandardSubagentEventRouter && !existing.isRetired()) return existing;
     const session = new ACPSessionConnection(this.connection, sessionId);
-    const release = (id) => this.reportingConnection.reports.releaseOpen(id);
+    const release = (id) => this.clientDelivery.reports.releaseOpen(id);
     const models = () => {
       const state = this.sessions.get(sessionId);
       return state ? this.subagentModels(state) : null;
@@ -49740,7 +49830,7 @@ var CodexAcpServer = class {
     return router;
   }
   async readSubagentConfiguration(threadId, parentThreadId) {
-    const { thread } = await this.codexAcpClient.appServerClient.threadRead({ threadId });
+    const thread = await this.codexAcpClient.readSubagentThread(threadId);
     if (!thread || thread.id !== threadId || thread.parentThreadId !== parentThreadId || thread.status.type === "notLoaded") return null;
     return { model: thread.model, effort: thread.reasoningEffort };
   }
@@ -49834,7 +49924,7 @@ var CodexAcpServer = class {
     this.clientCapabilities = _params.clientCapabilities ?? null;
     this.initializeRequest = _params;
     this.capabilities = ClientCapabilities.from(_params.clientCapabilities);
-    this.reportingConnection.reports.compareMeta = this.capabilities.airToolCallContract;
+    this.clientDelivery.reports.compareMeta = this.capabilities.airToolCallContract;
     this.booleanConfigOptionsSupported = clientSupportsBooleanConfigOptions(_params.clientCapabilities);
     this.sessionIndex.configure(_params.clientCapabilities);
     this.sessionIndex.observe(this.codexAcpClient);
@@ -49892,7 +49982,7 @@ var CodexAcpServer = class {
     this.clientCapabilities = clientCapabilities;
     this.initializeRequest = { clientInfo: params.info };
     this.capabilities = ClientCapabilities.fromV2(clientCapabilities);
-    this.reportingConnection.reports.compareMeta = this.capabilities.airToolCallContract;
+    this.clientDelivery.reports.compareMeta = this.capabilities.airToolCallContract;
     this.booleanConfigOptionsSupported = true;
     this.sessionIndex.configure(clientCapabilities);
     this.sessionIndex.observe(this.codexAcpClient);
@@ -50359,7 +50449,7 @@ You have been logged out. Please try again.`);
       subagents: this.createSubagentRouter(sessionId),
       asyncTasks: this.createAsyncTasks(sessionId),
       compactions: new CodexSessionCompactions(),
-      toolCallReports: this.reportingConnection.reports,
+      toolCallReports: this.clientDelivery.reports,
       openToolCalls: new CodexSessionToolCalls()
     };
     sessionState.titleGen = new TitleGenerator(
@@ -50904,15 +50994,18 @@ You have been logged out. Please try again.`);
   }
   async closeSession(params) {
     logger.log("Closing session...", { sessionId: params.sessionId });
-    const closeGeneration = this.bumpSessionGeneration(params.sessionId);
+    if (!this.hasLocalSession(params.sessionId)) return {};
+    let closeGeneration = null;
     const sessionState = this.sessions.get(params.sessionId);
     this.beginSessionCloseFence(params.sessionId);
     try {
+      this.clientDelivery.cancelSessionRequests(params.sessionId);
+      for (const child of this.subagentAssociations.forRoot(params.sessionId)) {
+        this.clientDelivery.cancelSessionRequests(child.sessionId);
+      }
       this.cancelQueuedV2Prompts(params.sessionId);
       if (sessionState) {
         await this.interruptSessionTurn(sessionState, "Close", true);
-        if (sessionState.subagents instanceof StandardSubagentEventRouter) await sessionState.subagents.finishOutstanding("disconnected");
-        sessionState.asyncTasks.clear();
         sessionState.promptSuggestions?.invalidate();
       } else {
         logger.log("Close request received for unknown local session", { sessionId: params.sessionId });
@@ -50927,10 +51020,15 @@ You have been logged out. Please try again.`);
       } else {
         logger.log("Session closed without an app-server call: its app-server is gone", { sessionId: params.sessionId });
       }
+      closeGeneration = this.bumpSessionGeneration(params.sessionId);
+      if (sessionState) {
+        if (sessionState.subagents instanceof StandardSubagentEventRouter) await sessionState.subagents.finishOutstanding("disconnected");
+        await sessionState.asyncTasks.finishAll("stopped");
+      }
       await this.reportCodexTurnState(params.sessionId, { state: "idle", stopReason: "cancelled" });
       logger.log("Session closed", { sessionId: params.sessionId });
     } finally {
-      if (this.getSessionGeneration(params.sessionId) === closeGeneration) {
+      if (closeGeneration !== null && this.getSessionGeneration(params.sessionId) === closeGeneration) {
         this.sessions.delete(params.sessionId);
         this.asyncQuestions.get(params.sessionId)?.dispose();
         this.asyncQuestions.delete(params.sessionId);
@@ -50945,6 +51043,7 @@ You have been logged out. Please try again.`);
         this.queuedV2PromptCancellers.delete(params.sessionId);
         this.steeringQueues.delete(params.sessionId);
         if (sessionState) {
+          sessionState.asyncTasks.clear();
           this.availableCommands.cancelPendingSkillsPublish(sessionState);
         }
       }
@@ -52120,7 +52219,7 @@ You have been logged out. Please try again.`);
       subagents: this.createSubagentRouter(sessionId, true),
       asyncTasks: this.createAsyncTasks(sessionId),
       compactions: new CodexSessionCompactions(),
-      toolCallReports: this.reportingConnection.reports,
+      toolCallReports: this.clientDelivery.reports,
       openToolCalls: new CodexSessionToolCalls()
     };
     sessionState.titleGen = new TitleGenerator(
@@ -53831,7 +53930,7 @@ You have been logged out. Please try again.`);
   }
   async failUnfinishedToolCalls(sessionIds) {
     for (const sessionId of sessionIds) {
-      for (const toolCallId of this.reportingConnection.reports.unfinished(sessionId)) {
+      for (const toolCallId of this.clientDelivery.reports.unfinished(sessionId)) {
         await this.connection.notify(methods.client.session.update, {
           sessionId,
           update: { sessionUpdate: "tool_call_update", toolCallId, status: "failed" }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.5.1-preview.4",
+  "version": "2.5.1-preview.5",
   "description": "",
   "main": "dist/index.js",
   "bin": {