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

package/README.md

@@ -13,6 +13,7 @@ Use [OpenAI Codex](https://github.com/openai/codex) from [Agent Client Protocol]
 - Text prompts, embedded context, images, resource links, and additional workspace directories.
 - Shell command, file change, [permission request](docs/permission-extension.md), MCP tool call, terminal output, reasoning, plan, web search, image generation, image view, token usage, and review events.
 - [Native ACP subagent sessions](docs/subagent-sessions.md) (after capability negotiation) with separate child histories and root-routed permissions; a legacy tool-call fallback otherwise.
+- [Background terminal tasks](docs/async-tasks.md) in AIR, with task status and targeted stop support after capability negotiation.
 - Session-scoped long-running goals through the provider-neutral [goal extension](docs/goal-extension.md).
 - A per-turn [agent file-change report](docs/agent-file-change-report.md) after capability negotiation.
 - Client-provided MCP servers over command-based stdio config and HTTP transport.
@@ -39,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:
@@ -82,6 +93,12 @@ Subagent sessions follow the draft [ACP subagent RFD](https://github.com/agentcl
 
 See [docs/subagent-sessions.md](docs/subagent-sessions.md) for the negotiation, lifecycle events, `session/load` reconstruction, and legacy fallback details.
 
+### Background terminal tasks
+
+Codex can keep a shell command running after a turn continues. AIR clients can show this work in the Async Tasks panel and stop one command.
+
+See [docs/async-tasks.md](docs/async-tasks.md) for the capability, lifecycle events, and stop request.
+
 ## License
 
 By contributing, you agree that your contributions will be licensed under the Apache 2.0 License.

package/dist/index.js

@@ -22131,32 +22131,7 @@ function attachLogs(proc) {
   });
 }
 
-// src/AirExtension.ts
-var JETBRAINS_META_KEY = "jetbrains";
-var AIR_META_KEY = "air";
-var AIR_EXTENSION_VERSION_KEY = "version";
-var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
-var AIR_SESSION_FAILURE_KEY = "sessionFailure";
-var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
-var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
-var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
-var AIR_EXTENSION_VERSION = 1;
-function clientSupportsAirCapability(capabilities, capability) {
-  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
-  const air = jetbrains?.[AIR_META_KEY];
-  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
-  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
-  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
-}
-
-// src/subagents/AcpSubagents.ts
-function clientSupportsSubagents(capabilities) {
-  const subagents = capabilities?.subagents;
-  if (typeof subagents === "object" && subagents !== null && !Array.isArray(subagents)) {
-    return true;
-  }
-  return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
-}
+// src/AcpSessionExtensions.ts
 function asSdkSessionNotification(notification) {
   return notification;
 }
@@ -23676,6 +23651,26 @@ function sameThreadGoalSnapshot(left, right) {
 // src/CodexEventHandler.ts
 import { randomUUID } from "node:crypto";
 
+// src/AirExtension.ts
+var JETBRAINS_META_KEY = "jetbrains";
+var AIR_META_KEY = "air";
+var AIR_EXTENSION_VERSION_KEY = "version";
+var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
+var AIR_ASYNC_TASKS_KEY = "asyncTasks";
+var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
+var AIR_EXTENSION_VERSION = 1;
+function clientSupportsAirCapability(capabilities, capability) {
+  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
+  const air = jetbrains?.[AIR_META_KEY];
+  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
+  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+
 // src/subagents/CodexAgentPath.ts
 function normalizeAgentPath(path9) {
   const normalized = path9.trim().replace(/\/+$/, "");
@@ -23731,14 +23726,14 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
       }
       return childTurn;
     }
-    const notificationThreadId = notification.params.threadId;
-    if (typeof notificationThreadId === "string" && this.pendingSpawns.has(notificationThreadId)) {
-      const pending = this.pendingSpawns.get(notificationThreadId);
+    const notificationThreadId2 = notification.params.threadId;
+    if (typeof notificationThreadId2 === "string" && this.pendingSpawns.has(notificationThreadId2)) {
+      const pending = this.pendingSpawns.get(notificationThreadId2);
       if (pending.buffered.length === _CodexSubagentEventRouter.MAX_PENDING_NOTIFICATIONS) {
         pending.buffered.shift();
         pending.droppedBufferedNotifications += 1;
         if (pending.droppedBufferedNotifications === 1) {
-          logger.log(`Pending subagent ${notificationThreadId} exceeded the notification buffer; dropping oldest updates`);
+          logger.log(`Pending subagent ${notificationThreadId2} exceeded the notification buffer; dropping oldest updates`);
         }
       }
       pending.buffered.push(notification);
@@ -23823,6 +23818,25 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
     const threadId = notification.params.threadId;
     return typeof threadId === "string" && this.children.has(threadId) ? this.children.get(threadId).sessionId : this.rootSessionId;
   }
+  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);
+    }
+    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) : [];
+    }
+    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);
+    }
+    return [...closing.values()];
+  }
   takeBufferedNotifications() {
     return this.replayQueue.splice(0);
   }
@@ -23898,6 +23912,10 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
   isKnownChild(threadId) {
     return threadId !== this.rootSessionId && (this.children.has(threadId) || this.pendingSpawns.has(threadId) || this.terminalPendingSpawns.has(threadId));
   }
+  closingChildSession(threadId) {
+    const child = this.children.get(threadId);
+    return child && child.terminalState === void 0 ? [{ threadId, sessionId: child.sessionId }] : [];
+  }
   async materialize(childSessionId, path9) {
     if (this.children.has(childSessionId)) return;
     const pending = this.pendingSpawns.get(childSessionId);
@@ -24306,17 +24324,29 @@ var CodexEventHandler = class _CodexEventHandler {
   }
   async handleNotification(notification) {
     await this.flushPendingErrors();
+    const closingChildren = this.subagents.closingChildSessions(notification);
+    for (const child of closingChildren) {
+      await this.sessionState.asyncTasks.reconcile(child.threadId, child.sessionId);
+    }
     const handledBySubagents = await this.subagents.handle(notification);
     for (const buffered of this.subagents.takeBufferedNotifications()) {
       await this.handleNotification(buffered);
     }
-    if (handledBySubagents) {
-      return;
+    const ignoredBySubagents = !handledBySubagents && this.subagents.shouldIgnore(notification);
+    let updateEvent;
+    if (!handledBySubagents && !ignoredBySubagents && notification.method === "item/started" && notification.params.item.type === "commandExecution") {
+      updateEvent = await this.createUpdateEvent(notification);
     }
-    if (this.subagents.shouldIgnore(notification)) {
-      return;
+    if (!handledBySubagents) {
+      await this.sessionState.asyncTasks.handleNotification(
+        notification,
+        this.subagents.notificationSessionId(notification),
+        toolCallTitle(updateEvent)
+      );
     }
-    const updateEvent = await this.createUpdateEvent(notification);
+    if (handledBySubagents) return;
+    if (ignoredBySubagents) return;
+    if (updateEvent === void 0) updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
       await this.session.update(updateEvent, this.subagents.notificationSessionId(notification));
     }
@@ -25153,6 +25183,10 @@ ${event.stdin}
     return createGuardianApprovalReviewToolCall(params);
   }
 };
+function toolCallTitle(update) {
+  if (update?.sessionUpdate !== "tool_call") return void 0;
+  return update.title;
+}
 
 // src/permissions/option-ids.ts
 var ApprovalOptionId = {
@@ -25922,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
@@ -25941,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
     },
@@ -26124,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) {
@@ -27285,7 +27339,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.9.0",
+  version: "1.10.1-preview.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27348,7 +27402,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.2",
+    "@openai/codex": "^0.153.3",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -27855,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,
@@ -27880,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;
@@ -28306,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(),
@@ -28340,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 {
@@ -28359,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);
@@ -28648,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,
@@ -29482,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 });
   }
@@ -29491,6 +29578,12 @@ var CodexAppServerClient = class {
   async threadCompactStart(params) {
     return await this.sendRequest({ method: "thread/compact/start", params });
   }
+  async threadBackgroundTerminalsList(params) {
+    return await this.sendRequest({ method: "thread/backgroundTerminals/list", params });
+  }
+  async threadBackgroundTerminalsTerminate(params) {
+    return await this.sendRequest({ method: "thread/backgroundTerminals/terminate", params });
+  }
   async threadGoalSet(params) {
     return await this.sendRequest({ method: "thread/goal/set", params });
   }
@@ -31462,6 +31555,9 @@ function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+// src/async-tasks/AsyncTaskExtension.ts
+var ASYNC_TASK_STOP_METHOD = "_session/async_task/stop";
+
 // src/AuthStatusMeta.ts
 var AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
 var AUTH_STATUS_META_KEY = "authStatus";
@@ -31599,7 +31695,7 @@ function sameAuthStatus(previous, next) {
 var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
 var SESSION_STEERING_METHOD = "_session/steering";
 function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD || request.method === ASYNC_TASK_STOP_METHOD;
 }
 
 // src/FastModeConfig.ts
@@ -31666,6 +31762,15 @@ function clientSupportsPlanUpdates(clientCapabilities) {
   return clientCapabilities?.plan != null;
 }
 
+// src/subagents/AcpSubagents.ts
+function clientSupportsSubagents(capabilities) {
+  const subagents = capabilities?.subagents;
+  if (typeof subagents === "object" && subagents !== null && !Array.isArray(subagents)) {
+    return true;
+  }
+  return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
+}
+
 // src/CodexAcpServer.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
@@ -31754,6 +31859,332 @@ function extractTitle(turn) {
 
 // src/CodexAcpServer.ts
 import { once } from "node:events";
+
+// src/async-tasks/CodexBackgroundTerminalTasks.ts
+var CodexBackgroundTerminalTasks = class {
+  constructor(enabled, rootSessionId, appServer, session) {
+    this.enabled = enabled;
+    this.rootSessionId = rootSessionId;
+    this.appServer = appServer;
+    this.session = session;
+  }
+  enabled;
+  rootSessionId;
+  appServer;
+  session;
+  tasks = /* @__PURE__ */ new Map();
+  syncs = /* @__PURE__ */ new Map();
+  appServerGeneration = 0;
+  appServerQueriesEnabled = true;
+  disposed = false;
+  async handleNotification(notification, sessionId, commandTitle2) {
+    if (!this.isActive()) return;
+    const threadId = notificationThreadId(notification);
+    if (threadId === null) return;
+    if (notification.method === "item/started" && notification.params.item.type === "commandExecution") {
+      this.observeCommandStarted(notification.params.item, threadId, sessionId, commandTitle2);
+      return;
+    }
+    if (notification.method === "item/completed" && notification.params.item.type === "commandExecution") {
+      await this.observeCommandCompleted(notification.params.item, threadId);
+      return;
+    }
+    if (notification.method === "turn/completed") {
+      await this.reconcile(threadId, sessionId);
+      return;
+    }
+    if (notification.method === "item/started") {
+      this.refresh(threadId, sessionId);
+    }
+  }
+  observeCommandStarted(item, threadId, sessionId, commandTitle2) {
+    if (!this.isActive() || item.processId === null) return;
+    this.remember(threadId, sessionId, {
+      itemId: item.id,
+      processId: item.processId,
+      command: item.command
+    }, commandTitle2);
+  }
+  async observeCommandCompleted(item, threadId) {
+    if (!this.isActive()) return;
+    const task = this.tasks.get(wireTaskId(this.rootSessionId, threadId, item.id));
+    if (task) await this.finish(task, item.status === "completed" ? "completed" : "failed");
+  }
+  refresh(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    void this.reconcile(threadId, sessionId);
+  }
+  async reconcile(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    try {
+      await this.sync(threadId, sessionId);
+    } catch (error51) {
+      if (this.isActive()) logger.error(`Failed to list background terminals for ${threadId}`, error51);
+    }
+  }
+  setAppServer(appServer) {
+    this.appServer = appServer;
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = true;
+  }
+  prepareForAppServerReplacement() {
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = false;
+  }
+  async recover(threadId, sessionId, itemIds) {
+    if (!this.canQueryAppServer() || itemIds.size === 0) return;
+    const snapshot = await this.listAll(threadId);
+    if (snapshot === null) return;
+    for (const terminal of snapshot.terminals) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      if (!itemIds.has(terminal.itemId)) continue;
+      const task = this.remember(threadId, sessionId, terminal);
+      if (task.publication === "unpublished" && task.state === "running") await this.announce(task);
+    }
+  }
+  async finishAll(state) {
+    if (!this.isActive()) return;
+    const errors = [];
+    for (const task of this.tasks.values()) {
+      try {
+        await this.finish(task, state);
+      } catch (error51) {
+        errors.push(error51);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, `Failed to finish ${errors.length} background terminal task(s)`);
+    }
+  }
+  async sync(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    if (!this.canQueryAppServer()) return;
+    const current = this.syncs.get(threadId);
+    if (current) {
+      current.requested = true;
+      current.sessionId = sessionId;
+      return await current.promise;
+    }
+    const pending = {
+      requested: false,
+      sessionId,
+      promise: Promise.resolve()
+    };
+    pending.promise = this.syncUntilCurrent(threadId, pending).finally(() => {
+      if (this.syncs.get(threadId) === pending) this.syncs.delete(threadId);
+    });
+    this.syncs.set(threadId, pending);
+    await pending.promise;
+  }
+  async stop(taskId) {
+    if (!this.isActive()) return false;
+    const task = this.tasks.get(taskId);
+    if (!task || task.publication !== "published") return false;
+    if (task.state === "stopped" && !task.terminalPublished) {
+      await this.publishTerminalState(task);
+      return true;
+    }
+    if (task.state !== "running") return false;
+    task.state = "stopping";
+    try {
+      const response = await this.appServer.threadBackgroundTerminalsTerminate({
+        threadId: task.threadId,
+        processId: task.processId
+      });
+      if (!response.terminated) {
+        if (task.state === "stopping") task.state = "running";
+        return false;
+      }
+      await this.finish(task, "stopped");
+      return true;
+    } catch (error51) {
+      if (task.state === "stopping") task.state = "running";
+      throw error51;
+    }
+  }
+  clear() {
+    this.disposed = true;
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = false;
+    this.tasks.clear();
+    this.syncs.clear();
+  }
+  async syncThread(threadId, sessionId) {
+    const snapshot = await this.listAll(threadId);
+    if (snapshot === null || !this.queryIsCurrent(snapshot.generation)) return;
+    const liveTaskIds = /* @__PURE__ */ new Set();
+    for (const terminal of snapshot.terminals) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      liveTaskIds.add(terminal.itemId);
+      const task = this.remember(threadId, sessionId, terminal);
+      if (task.publication === "unpublished" && task.state === "running") await this.announce(task);
+    }
+    for (const task of this.tasks.values()) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      if (task.threadId === threadId && task.publication === "published" && (task.state === "running" || task.state === "stopping") && !liveTaskIds.has(task.itemId)) {
+        await this.finish(task, "stopped");
+      }
+    }
+  }
+  async syncUntilCurrent(threadId, pending) {
+    let hasFailure = false;
+    let failure;
+    do {
+      pending.requested = false;
+      try {
+        await this.syncThread(threadId, pending.sessionId);
+        hasFailure = false;
+      } catch (error51) {
+        hasFailure = true;
+        failure = error51;
+      }
+    } while (pending.requested && this.canQueryAppServer());
+    if (hasFailure) throw failure;
+  }
+  async announce(task) {
+    if (task.publication === "published") return;
+    if (task.announcement !== null) {
+      await task.announcement;
+      return;
+    }
+    task.publication = "publishing";
+    const announcement = this.publishAnnouncement(task);
+    task.announcement = announcement;
+    try {
+      await announcement;
+    } finally {
+      if (task.announcement === announcement) task.announcement = null;
+    }
+    if (isTerminalState(task.state)) await this.publishTerminalState(task);
+  }
+  async publishAnnouncement(task) {
+    try {
+      await this.publishSpawn(task);
+      task.publication = "published";
+    } catch (error51) {
+      task.publication = "unpublished";
+      throw error51;
+    }
+  }
+  async publishSpawn(task) {
+    await this.session.update({
+      sessionUpdate: "tool_call_update",
+      toolCallId: task.itemId,
+      _meta: {
+        [JETBRAINS_META_KEY]: {
+          [AIR_META_KEY]: {
+            [AIR_ASYNC_TASKS_KEY]: {
+              [AIR_ASYNC_TASKS_BACKGROUNDED_KEY]: true
+            }
+          }
+        }
+      }
+    }, task.sessionId);
+    await this.session.update({
+      sessionUpdate: "async_task_spawned",
+      asyncTaskId: task.asyncTaskId,
+      name: task.name,
+      taskType: "shell",
+      showInTranscript: false,
+      canStop: true,
+      toolCallId: task.itemId
+    }, task.sessionId);
+  }
+  remember(threadId, sessionId, terminal, commandTitle2) {
+    const asyncTaskId = wireTaskId(this.rootSessionId, threadId, terminal.itemId);
+    const existing = this.tasks.get(asyncTaskId);
+    if (existing) {
+      existing.processId = terminal.processId;
+      if (commandTitle2 !== void 0) existing.name = commandTitle2;
+      return existing;
+    }
+    const task = {
+      threadId,
+      sessionId,
+      asyncTaskId,
+      processId: terminal.processId,
+      itemId: terminal.itemId,
+      name: commandTitle2 ?? terminal.command,
+      publication: "unpublished",
+      announcement: null,
+      terminalUpdate: null,
+      terminalPublished: false,
+      state: "running"
+    };
+    this.tasks.set(asyncTaskId, task);
+    return task;
+  }
+  async finish(task, state) {
+    if (task.state === "running" || task.state === "stopping") {
+      task.state = state;
+    } else if (task.state !== state) {
+      return;
+    }
+    if (task.announcement !== null) await task.announcement;
+    if (task.publication === "published") await this.publishTerminalState(task);
+  }
+  async publishTerminalState(task) {
+    if (!isTerminalState(task.state) || task.terminalPublished) return;
+    if (task.terminalUpdate !== null) {
+      await task.terminalUpdate;
+      return;
+    }
+    const terminalUpdate = this.session.update({
+      sessionUpdate: "async_task_state_update",
+      asyncTaskId: task.asyncTaskId,
+      state: task.state,
+      toolCallId: task.itemId
+    }, task.sessionId);
+    task.terminalUpdate = terminalUpdate;
+    try {
+      await terminalUpdate;
+      task.terminalPublished = true;
+    } finally {
+      if (task.terminalUpdate === terminalUpdate) task.terminalUpdate = null;
+    }
+  }
+  async listAll(threadId) {
+    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
+      });
+      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);
+    return { generation, terminals };
+  }
+  isActive() {
+    return this.enabled && !this.disposed;
+  }
+  canQueryAppServer() {
+    return this.isActive() && this.appServerQueriesEnabled;
+  }
+  queryIsCurrent(generation) {
+    return this.canQueryAppServer() && generation === this.appServerGeneration;
+  }
+};
+function isTerminalState(state) {
+  return state === "completed" || state === "failed" || state === "stopped";
+}
+function wireTaskId(rootSessionId, threadId, itemId) {
+  return threadId === rootSessionId ? itemId : `${threadId}:${itemId}`;
+}
+function notificationThreadId(notification) {
+  const threadId = notification.params.threadId;
+  return typeof threadId === "string" ? threadId : null;
+}
+
+// src/CodexAcpServer.ts
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
 function clientSupportsTypedSessionFailures(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
@@ -31791,6 +32222,7 @@ var CodexAcpServer = class _CodexAcpServer {
   goalControlGenerations;
   permissionLifecycleContexts;
   codexProcessState;
+  codexProcessGeneration = 0;
   initializeRequest = null;
   providerUpdate = null;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr, codexProcessState) {
@@ -31818,6 +32250,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.booleanConfigOptionsSupported = false;
     this.currentAuthStatus = null;
     this.availableCommands = this.createAvailableCommands(codexAcpClient);
+    this.observeCodexProcess();
   }
   createAvailableCommands(client) {
     return new CodexCommands(
@@ -31890,7 +32323,8 @@ var CodexAcpServer = class _CodexAcpServer {
             [AIR_EXTENSION_CAPABILITIES_KEY]: [
               AIR_SESSION_FAILURE_KEY,
               AIR_AGENT_FILE_CHANGE_REPORT_KEY,
-              AIR_NATIVE_SUBAGENT_SESSIONS_KEY
+              AIR_NATIVE_SUBAGENT_SESSIONS_KEY,
+              AIR_ASYNC_TASKS_KEY
             ]
           }
         }
@@ -31913,6 +32347,18 @@ var CodexAcpServer = class _CodexAcpServer {
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
       case SESSION_STEERING_METHOD:
         return await this.executeOrQueueSteeringRequest(this.parseSessionSteerParams(methodRequest.params));
+      case ASYNC_TASK_STOP_METHOD: {
+        if (this.providerUpdate !== null) {
+          await this.providerUpdate;
+        }
+        const sessionState = this.sessions.get(methodRequest.params.sessionId);
+        if (!sessionState) return { stopped: false };
+        return {
+          stopped: await this.runWithProcessCheck(
+            () => sessionState.asyncTasks.stop(methodRequest.params.asyncTaskId)
+          )
+        };
+      }
       case GOAL_CONTROL_METHOD:
       case LEGACY_GOAL_CONTROL_METHOD: {
         const sessionState = this.sessions.get(methodRequest.params.sessionId);
@@ -32154,7 +32600,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionId,
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
-      )
+      ),
+      asyncTasks: this.createAsyncTasks(sessionId)
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -32162,7 +32609,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
-    this.sessions.set(sessionId, sessionState);
+    this.installSessionState(sessionState);
     resumeSubscribed = false;
     const canPublishSessionUpdates = operation !== "fork";
     if (canPublishSessionUpdates && requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
@@ -32177,6 +32624,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     if (operation === "resume") {
       this.publishCurrentGoalAsync(sessionState, sessionGeneration);
+      this.publishAsyncTasksAsync(sessionState, sessionGeneration);
     }
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
@@ -32206,6 +32654,18 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     return a === b;
   }
+  createAsyncTasks(sessionId) {
+    return new CodexBackgroundTerminalTasks(
+      clientSupportsAirCapability(this.clientCapabilities, AIR_ASYNC_TASKS_KEY),
+      sessionId,
+      this.codexAcpClient.appServerClient,
+      new ACPSessionConnection(this.connection, sessionId)
+    );
+  }
+  installSessionState(sessionState) {
+    this.sessions.get(sessionState.sessionId)?.asyncTasks.clear();
+    this.sessions.set(sessionState.sessionId, sessionState);
+  }
   getAuthProviderForAuthenticateRequest(request) {
     if (isCodexAuthRequest(request) && request.methodId === "gateway") {
       return "custom-gateway";
@@ -32224,6 +32684,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       thread
     } = await this.getOrCreateSessionWithHistory(params);
     await this.streamThreadHistory(sessionId, thread);
+    await this.getSessionState(sessionId).asyncTasks.reconcile();
     logger.log("Session loaded", {
       sessionId,
       modelId: modelState.currentModelId,
@@ -32297,6 +32758,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     try {
       if (sessionState) {
         await this.interruptSessionTurn(sessionState, "Close", true);
+        sessionState.asyncTasks.clear();
       } else {
         logger.log("Close request received for unknown local session", { sessionId: params.sessionId });
       }
@@ -32432,6 +32894,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
         await Promise.all(activePrompts);
       }
       logger.log("Restarting Codex app-server for provider update", { sessionCount: this.sessions.size });
+      for (const session of this.sessions.values()) {
+        session.asyncTasks.prepareForAppServerReplacement();
+      }
+      await this.finishAllAsyncTasks("stopped", "before the provider restart");
       const replacement = await this.restartCodexClient();
       apply(replacement);
       if (this.initializeRequest === null) {
@@ -32442,6 +32908,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       this.availableCommands = this.createAvailableCommands(replacement);
       const resumeErrors = [];
       for (const session of this.sessions.values()) {
+        session.asyncTasks.setAppServer(replacement.appServerClient);
         try {
           await replacement.resumeSession({
             sessionId: session.sessionId,
@@ -32450,6 +32917,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             mcpServers: session.mcpServers ?? []
           });
           session.authProvider = replacement.getModelProvider();
+          session.asyncTasks.refresh();
           logger.log("Resumed session after provider restart", { sessionId: session.sessionId });
         } catch (error51) {
           resumeErrors.push(error51);
@@ -32479,12 +32947,22 @@ Check ${configPath} and project .codex directories, especially their config.toml
       state.stderr = (state.stderr + data.toString()).slice(-2 * 1024);
     });
   }
+  observeCodexProcess() {
+    const process12 = this.codexProcessState?.connection.process;
+    if (!process12) return;
+    const generation = ++this.codexProcessGeneration;
+    process12.once("exit", () => {
+      if (generation !== this.codexProcessGeneration) return;
+      void this.finishAllAsyncTasks("failed", "after the Codex process exited");
+    });
+  }
   async restartCodexClient() {
     const state = this.codexProcessState;
     if (state === null) {
       throw new Error("Codex process state is unavailable");
     }
     const previous = state.connection;
+    this.codexProcessGeneration += 1;
     const exited = previous.process.exitCode === null ? once(previous.process, "exit") : Promise.resolve();
     previous.process.stdin.end();
     const forceKill = setTimeout(() => {
@@ -32498,6 +32976,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     state.stderr = "";
     state.connection = startCodexConnection(state.codexPath);
     this.captureStderr();
+    this.observeCodexProcess();
     return new CodexAcpClient(
       new CodexAppServerClient(state.connection.connection),
       state.config,
@@ -33047,6 +33526,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
   publishCurrentGoalAsync(sessionState, sessionGeneration) {
     void this.publishCurrentGoalBestEffort(sessionState, sessionGeneration, true);
   }
+  publishAsyncTasksAsync(sessionState, sessionGeneration) {
+    if (!this.sessionPublishIsCurrent(sessionState, sessionGeneration)) return;
+    sessionState.asyncTasks.refresh();
+  }
   async publishCurrentGoalBestEffort(sessionState, sessionGeneration, force) {
     try {
       await this.publishCurrentGoal(sessionState, sessionGeneration, force);
@@ -33170,7 +33653,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionId,
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
-      )
+      ),
+      asyncTasks: this.createAsyncTasks(sessionId)
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -33178,7 +33662,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
-    this.sessions.set(sessionId, sessionState);
+    this.installSessionState(sessionState);
     subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
@@ -33270,6 +33754,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
                   /* @__PURE__ */ new Set([...ancestry, item.agentThreadId]),
                   threadCache
                 );
+                try {
+                  await sessionState.asyncTasks.recover(
+                    item.agentThreadId,
+                    childSessionId,
+                    commandItemIds(childTurn.items)
+                  );
+                } catch (error51) {
+                  logger.error(`Failed to restore background terminals for ${item.agentThreadId}`, error51);
+                }
               }
             }
           } else if (activityKind === "completed" || activityKind === "interrupted") {
@@ -34320,6 +34813,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw new RequestError(requestErrorCode, `VC++ redistributable should be installed`);
       }
       if (exitCode !== null) {
+        await this.finishAllAsyncTasks("failed", "after the Codex process exited");
         const stderr = this.getRecentStderr().trim();
         const detail = stderr ? `:
 ${stderr}` : "";
@@ -34328,6 +34822,15 @@ ${stderr}` : "";
       throw err;
     }
   }
+  async finishAllAsyncTasks(state, reason) {
+    for (const session of this.sessions.values()) {
+      try {
+        await session.asyncTasks.finishAll(state);
+      } catch (error51) {
+        logger.error(`Failed to finish background terminal tasks ${reason}`, error51);
+      }
+    }
+  }
   async cancel(params) {
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) {
@@ -34377,6 +34880,9 @@ function mergeHistoryUpdates(responseItemFallbackUpdates, threadUpdates) {
   }
   return merged;
 }
+function commandItemIds(items) {
+  return new Set(items.filter((item) => item.type === "commandExecution").map((item) => item.id));
+}
 function historyUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -34560,6 +35066,10 @@ var goalControlParamsParser = external_exports.discriminatedUnion("action", [
     action: external_exports.enum(["pause", "resume", "clear"])
   }).passthrough()
 ]);
+var asyncTaskStopParamsParser = external_exports.object({
+  sessionId: external_exports.string().trim().min(1),
+  asyncTaskId: external_exports.string().trim().min(1)
+}).passthrough();
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);
@@ -34640,5 +35150,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(ASYNC_TASK_STOP_METHOD, asyncTaskStopParamsParser, (ctx) => getAgent().extMethod(ASYNC_TASK_STOP_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.9.0",
+  "version": "1.10.1-preview.1",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.2",
+    "@openai/codex": "^0.153.3",
     "diff": "^9.0.0",
     "open": "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",