@agentclientprotocol/codex-acp 0.0.44 → 0.0.46

package/dist/index.js

@@ -14441,6 +14441,7 @@ var AGENT_METHODS = {
   document_did_save: "document/didSave",
   initialize: "initialize",
   logout: "logout",
+  mcp_message: "mcp/message",
   nes_accept: "nes/accept",
   nes_close: "nes/close",
   nes_reject: "nes/reject",
@@ -14451,6 +14452,7 @@ var AGENT_METHODS = {
   providers_set: "providers/set",
   session_cancel: "session/cancel",
   session_close: "session/close",
+  session_delete: "session/delete",
   session_fork: "session/fork",
   session_list: "session/list",
   session_load: "session/load",
@@ -14466,6 +14468,9 @@ var CLIENT_METHODS = {
   elicitation_create: "elicitation/create",
   fs_read_text_file: "fs/read_text_file",
   fs_write_text_file: "fs/write_text_file",
+  mcp_connect: "mcp/connect",
+  mcp_disconnect: "mcp/disconnect",
+  mcp_message: "mcp/message",
   session_request_permission: "session/request_permission",
   session_update: "session/update",
   terminal_create: "terminal/create",
@@ -14551,6 +14556,9 @@ var zCreateTerminalResponse = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   terminalId: external_exports.string()
 });
+var zDeleteSessionResponse = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
+});
 var zDiff = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   newText: external_exports.string(),
@@ -14564,6 +14572,9 @@ var zDisableProvidersRequest = external_exports.object({
 var zDisableProvidersResponse = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
 });
+var zDisconnectMcpResponse = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
+});
 var zElicitationContentValue = external_exports.union([
   external_exports.string(),
   external_exports.number(),
@@ -14669,7 +14680,6 @@ var zListProvidersRequest = external_exports.object({
 });
 var zListSessionsRequest = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
-  additionalDirectories: external_exports.array(external_exports.string()).optional(),
   cursor: external_exports.string().nullish(),
   cwd: external_exports.string().nullish()
 });
@@ -14696,9 +14706,29 @@ var zLogoutResponse = external_exports.object({
 });
 var zMcpCapabilities = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  acp: external_exports.boolean().optional().default(false),
   http: external_exports.boolean().optional().default(false),
   sse: external_exports.boolean().optional().default(false)
 });
+var zMcpConnectionId = external_exports.string();
+var zConnectMcpResponse = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  connectionId: zMcpConnectionId
+});
+var zDisconnectMcpRequest = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  connectionId: zMcpConnectionId
+});
+var zMcpServerAcpId = external_exports.string();
+var zConnectMcpRequest = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  acpId: zMcpServerAcpId
+});
+var zMcpServerAcp = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  id: zMcpServerAcpId,
+  name: external_exports.string()
+});
 var zMcpServerHttp = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   headers: external_exports.array(zHttpHeader),
@@ -14725,8 +14755,24 @@ var zMcpServer = external_exports.union([
   zMcpServerSse.and(external_exports.object({
     type: external_exports.literal("sse")
   })),
+  zMcpServerAcp.and(external_exports.object({
+    type: external_exports.literal("acp")
+  })),
   zMcpServerStdio
 ]);
+var zMessageMcpNotification = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  connectionId: zMcpConnectionId,
+  method: external_exports.string(),
+  params: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
+});
+var zMessageMcpRequest = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  connectionId: zMcpConnectionId,
+  method: external_exports.string(),
+  params: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
+});
+var zMessageMcpResponse = external_exports.unknown();
 var zModelId = external_exports.string();
 var zModelInfo = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
@@ -15134,6 +15180,9 @@ var zConfigOptionUpdate = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   configOptions: external_exports.array(zSessionConfigOption)
 });
+var zSessionDeleteCapabilities = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
+});
 var zSessionForkCapabilities = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
 });
@@ -15164,6 +15213,10 @@ var zCreateTerminalRequest = external_exports.object({
   outputByteLimit: external_exports.number().nullish(),
   sessionId: zSessionId
 });
+var zDeleteSessionRequest = external_exports.object({
+  _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
+  sessionId: zSessionId
+});
 var zDidCloseDocumentNotification = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   sessionId: zSessionId,
@@ -15313,6 +15366,7 @@ var zSessionCapabilities = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   additionalDirectories: zSessionAdditionalDirectoriesCapabilities.nullish(),
   close: zSessionCloseCapabilities.nullish(),
+  delete: zSessionDeleteCapabilities.nullish(),
   fork: zSessionForkCapabilities.nullish(),
   list: zSessionListCapabilities.nullish(),
   resume: zSessionResumeCapabilities.nullish()
@@ -15455,6 +15509,7 @@ var zClientNotification = external_exports.object({
     zDidFocusDocumentNotification,
     zAcceptNesNotification,
     zRejectNesNotification,
+    zMessageMcpNotification,
     zExtNotification
   ]).nullish()
 });
@@ -15487,7 +15542,11 @@ var zAgentCapabilities = external_exports.object({
   _meta: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
   auth: zAgentAuthCapabilities.optional().default({}),
   loadSession: external_exports.boolean().optional().default(false),
-  mcpCapabilities: zMcpCapabilities.optional().default({ http: false, sse: false }),
+  mcpCapabilities: zMcpCapabilities.optional().default({
+    acp: false,
+    http: false,
+    sse: false
+  }),
   nes: zNesCapabilities.nullish(),
   positionEncoding: zPositionEncodingKind.nullish(),
   promptCapabilities: zPromptCapabilities.optional().default({
@@ -15503,7 +15562,11 @@ var zInitializeResponse = external_exports.object({
   agentCapabilities: zAgentCapabilities.optional().default({
     auth: {},
     loadSession: false,
-    mcpCapabilities: { http: false, sse: false },
+    mcpCapabilities: {
+      acp: false,
+      http: false,
+      sse: false
+    },
     promptCapabilities: {
       audio: false,
       embeddedContext: false,
@@ -15734,6 +15797,7 @@ var zAgentResponse = external_exports.union([
       zNewSessionResponse,
       zLoadSessionResponse,
       zListSessionsResponse,
+      zDeleteSessionResponse,
       zForkSessionResponse,
       zResumeSessionResponse,
       zCloseSessionResponse,
@@ -15744,7 +15808,8 @@ var zAgentResponse = external_exports.union([
       zStartNesResponse,
       zSuggestNesResponse,
       zCloseNesResponse,
-      zExtResponse
+      zExtResponse,
+      zMessageMcpResponse
     ])
   }),
   external_exports.object({
@@ -15803,6 +15868,7 @@ var zAgentNotification = external_exports.object({
   params: external_exports.union([
     zSessionNotification,
     zCompleteElicitationNotification,
+    zMessageMcpNotification,
     zExtNotification
   ]).nullish()
 });
@@ -15841,6 +15907,7 @@ var zClientRequest = external_exports.object({
     zNewSessionRequest,
     zLoadSessionRequest,
     zListSessionsRequest,
+    zDeleteSessionRequest,
     zForkSessionRequest,
     zResumeSessionRequest,
     zCloseSessionRequest,
@@ -15851,6 +15918,7 @@ var zClientRequest = external_exports.object({
     zStartNesRequest,
     zSuggestNesRequest,
     zCloseNesRequest,
+    zMessageMcpRequest,
     zExtRequest
   ]).nullish()
 });
@@ -15873,6 +15941,9 @@ var zAgentRequest = external_exports.object({
     zWaitForTerminalExitRequest,
     zKillTerminalRequest,
     zCreateElicitationRequest,
+    zConnectMcpRequest,
+    zMessageMcpRequest,
+    zDisconnectMcpRequest,
     zExtRequest
   ]).nullish()
 });
@@ -15892,7 +15963,10 @@ var zClientResponse = external_exports.union([
       zWaitForTerminalExitResponse,
       zKillTerminalResponse,
       zCreateElicitationResponse,
-      zExtResponse
+      zConnectMcpResponse,
+      zDisconnectMcpResponse,
+      zExtResponse,
+      zMessageMcpResponse
     ])
   }),
   external_exports.object({
@@ -15967,6 +16041,15 @@ function ndJsonStream(output, input) {
 }
 
 // node_modules/@agentclientprotocol/sdk/dist/acp.js
+function emptyObjectResponse(response) {
+  return response ?? {};
+}
+function rejectedPromise(error40) {
+  const promise2 = Promise.reject(error40);
+  promise2.catch(() => {
+  });
+  return promise2;
+}
 var AgentSideConnection = class {
   connection;
   /**
@@ -16007,6 +16090,14 @@ var AgentSideConnection = class {
           const validatedParams = zListSessionsRequest.parse(params);
           return agent.listSessions(validatedParams);
         }
+        case AGENT_METHODS.session_delete: {
+          if (!agent.unstable_deleteSession) {
+            throw RequestError.methodNotFound(method);
+          }
+          const validatedParams = zDeleteSessionRequest.parse(params);
+          const result = await agent.unstable_deleteSession(validatedParams);
+          return result ?? {};
+        }
         case AGENT_METHODS.session_fork: {
           if (!agent.unstable_forkSession) {
             throw RequestError.methodNotFound(method);
@@ -16191,8 +16282,8 @@ var AgentSideConnection = class {
    *
    * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
    */
-  async sessionUpdate(params) {
-    return await this.connection.sendNotification(CLIENT_METHODS.session_update, params);
+  sessionUpdate(params) {
+    return this.connection.sendNotification(CLIENT_METHODS.session_update, params);
   }
   /**
    * Requests permission from the user for a tool call operation.
@@ -16206,8 +16297,8 @@ var AgentSideConnection = class {
    *
    * See protocol docs: [Requesting Permission](https://agentclientprotocol.com/protocol/tool-calls#requesting-permission)
    */
-  async requestPermission(params) {
-    return await this.connection.sendRequest(CLIENT_METHODS.session_request_permission, params);
+  requestPermission(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.session_request_permission, params);
   }
   /**
    * Reads content from a text file in the client's file system.
@@ -16217,8 +16308,8 @@ var AgentSideConnection = class {
    *
    * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
    */
-  async readTextFile(params) {
-    return await this.connection.sendRequest(CLIENT_METHODS.fs_read_text_file, params);
+  readTextFile(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.fs_read_text_file, params);
   }
   /**
    * Writes content to a text file in the client's file system.
@@ -16228,8 +16319,8 @@ var AgentSideConnection = class {
    *
    * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
    */
-  async writeTextFile(params) {
-    return await this.connection.sendRequest(CLIENT_METHODS.fs_write_text_file, params) ?? {};
+  writeTextFile(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.fs_write_text_file, params, emptyObjectResponse);
   }
   /**
    * Executes a command in a new terminal.
@@ -16243,9 +16334,8 @@ var AgentSideConnection = class {
    * @param params - The terminal creation parameters
    * @returns A handle to control and monitor the terminal
    */
-  async createTerminal(params) {
-    const response = await this.connection.sendRequest(CLIENT_METHODS.terminal_create, params);
-    return new TerminalHandle(response.terminalId, params.sessionId, this.connection);
+  createTerminal(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_create, params, (response) => new TerminalHandle(response.terminalId, params.sessionId, this.connection));
   }
   /**
    * **UNSTABLE**
@@ -16256,8 +16346,8 @@ var AgentSideConnection = class {
    *
    * @experimental
    */
-  async unstable_createElicitation(params) {
-    return await this.connection.sendRequest(CLIENT_METHODS.elicitation_create, params);
+  unstable_createElicitation(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.elicitation_create, params);
   }
   /**
    * **UNSTABLE**
@@ -16268,24 +16358,24 @@ var AgentSideConnection = class {
    *
    * @experimental
    */
-  async unstable_completeElicitation(params) {
-    return await this.connection.sendNotification(CLIENT_METHODS.elicitation_complete, params);
+  unstable_completeElicitation(params) {
+    return this.connection.sendNotification(CLIENT_METHODS.elicitation_complete, params);
   }
   /**
    * Extension method
    *
    * Allows the Agent to send an arbitrary request that is not part of the ACP spec.
    */
-  async extMethod(method, params) {
-    return await this.connection.sendRequest(method, params);
+  extMethod(method, params) {
+    return this.connection.sendRequest(method, params);
   }
   /**
    * Extension notification
    *
    * Allows the Agent to send an arbitrary notification that is not part of the ACP spec.
    */
-  async extNotification(method, params) {
-    return await this.connection.sendNotification(method, params);
+  extNotification(method, params) {
+    return this.connection.sendNotification(method, params);
   }
   /**
    * AbortSignal that aborts when the connection closes.
@@ -16349,8 +16439,8 @@ var TerminalHandle = class {
   /**
    * Gets the current terminal output without waiting for the command to exit.
    */
-  async currentOutput() {
-    return await this.connection.sendRequest(CLIENT_METHODS.terminal_output, {
+  currentOutput() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_output, {
       sessionId: this.sessionId,
       terminalId: this.id
     });
@@ -16358,8 +16448,8 @@ var TerminalHandle = class {
   /**
    * Waits for the terminal command to complete and returns its exit status.
    */
-  async waitForExit() {
-    return await this.connection.sendRequest(CLIENT_METHODS.terminal_wait_for_exit, {
+  waitForExit() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_wait_for_exit, {
       sessionId: this.sessionId,
       terminalId: this.id
     });
@@ -16374,11 +16464,11 @@ var TerminalHandle = class {
    *
    * Useful for implementing timeouts or cancellation.
    */
-  async kill() {
-    return await this.connection.sendRequest(CLIENT_METHODS.terminal_kill, {
+  kill() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_kill, {
       sessionId: this.sessionId,
       terminalId: this.id
-    }) ?? {};
+    }, emptyObjectResponse);
   }
   /**
    * Releases the terminal and frees all associated resources.
@@ -16392,11 +16482,11 @@ var TerminalHandle = class {
    *
    * **Important:** Always call this method when done with the terminal.
    */
-  async release() {
-    return await this.connection.sendRequest(CLIENT_METHODS.terminal_release, {
+  release() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_release, {
       sessionId: this.sessionId,
       terminalId: this.id
-    }) ?? {};
+    }, emptyObjectResponse);
   }
   async [Symbol.asyncDispose]() {
     await this.release();
@@ -16581,25 +16671,36 @@ var Connection = class {
       console.error("Got response to unknown request", response.id);
     }
   }
-  sendRequest(method, params) {
-    this.throwIfClosed();
+  sendRequest(method, params, mapResponse) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
     const id = this.nextRequestId++;
     const responsePromise = new Promise((resolve, reject) => {
-      this.pendingResponses.set(id, { resolve, reject });
+      this.pendingResponses.set(id, {
+        resolve: (response) => {
+          try {
+            resolve(mapResponse ? mapResponse(response) : response);
+          } catch (error40) {
+            reject(error40);
+          }
+        },
+        reject
+      });
     });
     responsePromise.catch(() => {
     });
     void this.sendMessage({ jsonrpc: "2.0", id, method, params });
     return responsePromise;
   }
-  async sendNotification(method, params) {
-    this.throwIfClosed();
-    await this.sendMessage({ jsonrpc: "2.0", method, params });
-  }
-  throwIfClosed() {
+  sendNotification(method, params) {
     if (this.abortController.signal.aborted) {
-      throw this.abortController.signal.reason ?? new Error("ACP connection closed");
+      return rejectedPromise(this.closedReason());
     }
+    return this.sendMessage({ jsonrpc: "2.0", method, params });
+  }
+  closedReason() {
+    return this.abortController.signal.reason ?? new Error("ACP connection closed");
   }
   async sendMessage(message) {
     this.writeQueue = this.writeQueue.then(async () => {
@@ -17218,6 +17319,30 @@ function applyStructuredPatch(source, patch, options = {}) {
   return resultLines.join("\n");
 }
 
+// node_modules/diff/libesm/patch/reverse.js
+function reversePatch(structuredPatch) {
+  if (Array.isArray(structuredPatch)) {
+    return structuredPatch.map((patch) => reversePatch(patch)).reverse();
+  }
+  return Object.assign(Object.assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map((hunk) => {
+    return {
+      oldLines: hunk.newLines,
+      oldStart: hunk.newStart,
+      newLines: hunk.oldLines,
+      newStart: hunk.oldStart,
+      lines: hunk.lines.map((l) => {
+        if (l.startsWith("-")) {
+          return `+${l.slice(1)}`;
+        }
+        if (l.startsWith("+")) {
+          return `-${l.slice(1)}`;
+        }
+        return l;
+      })
+    };
+  }) });
+}
+
 // src/CodexToolCallMapper.ts
 import { readFile } from "node:fs/promises";
 import path2 from "node:path";
@@ -17369,7 +17494,7 @@ function createCommandActionEvent(id, status, cwd, commandAction) {
       toolCallId: id,
       status: acpStatus,
       kind: "read",
-      title: "Read file",
+      title: `Read file '${commandAction.path}'`,
       locations: [{ path: commandAction.path }]
     };
   } else if (commandAction.type === "search") {
@@ -17420,80 +17545,93 @@ function createSearchTitle(query, path5) {
   return "Search";
 }
 async function createPatchContent(change) {
-  if (change.kind.type === "add" && !isUnifiedDiff(change.diff)) {
-    return {
-      type: "diff",
-      oldText: null,
-      newText: change.diff,
-      path: change.path,
-      _meta: {
-        kind: "add"
-      }
-    };
-  }
-  if (change.kind.type === "delete") {
-    const oldContent2 = await readFile(change.path, { encoding: "utf8" }).catch(
-      () => isUnifiedDiff(change.diff) ? patchToDeletedContent(change.diff) : change.diff
-    );
-    return {
-      type: "diff",
-      oldText: oldContent2,
-      newText: "",
-      path: change.path,
-      _meta: {
-        kind: "delete"
-      }
-    };
-  }
-  const oldContent = change.kind.type === "add" ? "" : await readFile(change.path, { encoding: "utf8" }).catch(() => null);
-  if (oldContent === null) {
-    return null;
-  }
-  const newContent = applyPatch(oldContent, change.diff);
-  if (newContent === false) {
+  try {
+    switch (change.kind.type) {
+      case "add":
+        return await createAddFileContent(change);
+      case "delete":
+        return await createDeleteFileContent(change);
+      case "update":
+        return await createUpdateFileContent(change);
+    }
+  } catch (error40) {
+    logger.log(`Error processing file update change: ${error40}`);
     return null;
   }
+}
+async function createAddFileContent(change) {
   return {
     type: "diff",
-    oldText: change.kind.type === "add" ? null : oldContent,
-    newText: newContent,
+    oldText: null,
+    newText: change.diff,
+    // app-server always returns file content instead of diff
     path: change.path,
     _meta: {
-      kind: change.kind.type
+      kind: "add"
     }
   };
 }
-function isUnifiedDiff(content) {
-  return content.startsWith("--- ") || content.includes("\n--- ");
-}
-function patchToDeletedContent(unifiedDiff) {
-  try {
-    const [patch] = parsePatch(unifiedDiff);
-    if (!patch || patch.hunks.length === 0) {
-      return null;
-    }
-    const oldLines = [];
-    let hasNoTrailingNewlineMarker = false;
-    for (const hunk of patch.hunks) {
-      for (const line of hunk.lines) {
-        if (line === "\") {
-          hasNoTrailingNewlineMarker = true;
-          continue;
-        }
-        if (line.startsWith("-") || line.startsWith(" ")) {
-          oldLines.push(line.slice(1));
+async function createUpdateFileContent(change) {
+  if (change.kind.type !== "update") return null;
+  const unifiedDiff = recoverCorruptedDiff(change.diff);
+  const movePath = change.kind.move_path;
+  const oldContent = await readFileContent(change.path);
+  if (oldContent !== null) {
+    const patchedContent = applyPatch(oldContent, unifiedDiff);
+    if (patchedContent === false) {
+      const revertedPatch2 = revertPatch(unifiedDiff);
+      if (revertedPatch2) {
+        const revertedContent2 = applyPatch(oldContent, revertedPatch2);
+        if (revertedContent2 !== false) {
+          return createUpdateDiffContent(change.path, revertedContent2, oldContent);
         }
       }
+      return null;
     }
-    if (oldLines.length === 0) {
-      return "";
-    }
-    const oldText = oldLines.join("\n");
-    return hasNoTrailingNewlineMarker || !unifiedDiff.endsWith("\n") ? oldText : `${oldText}
-`;
-  } catch {
-    return null;
+    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent);
   }
+  if (!movePath) return null;
+  const newContent = await readFileContent(movePath);
+  if (newContent === null) return null;
+  const revertedPatch = revertPatch(unifiedDiff);
+  if (!revertedPatch) return null;
+  const revertedContent = applyPatch(newContent, revertedPatch);
+  if (revertedContent === false) return null;
+  return createUpdateDiffContent(movePath, revertedContent, newContent);
+}
+function revertPatch(unifiedDiff) {
+  const [patch] = parsePatch(unifiedDiff);
+  if (!patch) return null;
+  return reversePatch(patch);
+}
+function createUpdateDiffContent(path5, oldText, newText) {
+  return {
+    type: "diff",
+    oldText,
+    newText,
+    path: path5,
+    _meta: {
+      kind: "update"
+    }
+  };
+}
+async function createDeleteFileContent(change) {
+  return {
+    type: "diff",
+    oldText: change.diff,
+    // app-server always returns file content instead of diff
+    newText: "",
+    path: change.path,
+    _meta: {
+      kind: "delete"
+    }
+  };
+}
+async function readFileContent(filePath) {
+  return await readFile(filePath, { encoding: "utf8" }).catch(() => null);
+}
+function recoverCorruptedDiff(diff) {
+  return diff.replace(/\n\nMoved to: .*$/, "");
 }
 
 // src/CodexEventHandler.ts
@@ -17536,6 +17674,27 @@ var CodexEventHandler = class {
         return null;
       case "thread/tokenUsage/updated":
         return this.createUsageUpdate(notification.params);
+      case "thread/name/updated":
+        return {
+          sessionUpdate: "session_info_update",
+          title: notification.params.threadName ?? null
+        };
+      case "thread/status/changed":
+        return this.createCodexSessionInfoUpdate({
+          threadStatus: notification.params.status
+        });
+      case "thread/archived":
+        return this.createCodexSessionInfoUpdate({
+          archived: true
+        });
+      case "thread/unarchived":
+        return this.createCodexSessionInfoUpdate({
+          archived: false
+        });
+      case "thread/closed":
+        return this.createCodexSessionInfoUpdate({
+          closed: true
+        });
       case "item/commandExecution/outputDelta":
         return this.createCommandOutputDeltaEvent(notification.params);
       case "item/mcpToolCall/progress":
@@ -17582,10 +17741,6 @@ var CodexEventHandler = class {
       case "serverRequest/resolved":
       case "model/verification":
       case "windows/worldWritableWarning":
-      case "thread/status/changed":
-      case "thread/archived":
-      case "thread/unarchived":
-      case "thread/closed":
       case "thread/realtime/started":
       case "thread/realtime/itemAdded":
       case "thread/realtime/transcript/delta":
@@ -17602,15 +17757,25 @@ var CodexEventHandler = class {
       case "externalAgentConfig/import/completed":
       case "rawResponseItem/completed":
       case "thread/started":
-      case "thread/name/updated":
       case "item/plan/delta":
       case "thread/goal/updated":
       case "thread/goal/cleared":
       case "remoteControl/status/changed":
       case "app/list/updated":
+      case "thread/settings/updated":
+      case "process/outputDelta":
+      case "process/exited":
         return null;
     }
   }
+  createCodexSessionInfoUpdate(codexMetadata) {
+    return {
+      sessionUpdate: "session_info_update",
+      _meta: {
+        codex: codexMetadata
+      }
+    };
+  }
   async createTextEvent(event) {
     return {
       sessionUpdate: "agent_message_chunk",
@@ -17934,42 +18099,28 @@ var CodexApprovalHandler = class {
     }
   }
   buildCommandPermissionRequest(sessionId, params) {
-    const reasonContent = this.createContentFromReason(params.reason ?? null);
     return {
       sessionId,
       toolCall: {
         toolCallId: params.itemId,
         kind: "execute",
         status: "pending",
-        content: reasonContent ? [reasonContent] : null,
         rawInput: params.command ? { command: stripShellPrefix(params.command), cwd: params.cwd } : null
       },
-      options: APPROVAL_OPTIONS
-    };
-  }
-  createContentFromReason(reason) {
-    if (reason === null || reason === "") {
-      return null;
-    }
-    return {
-      type: "content",
-      content: {
-        type: "text",
-        text: reason
-      }
+      options: APPROVAL_OPTIONS,
+      _meta: { codex: { params } }
     };
   }
   buildFileChangePermissionRequest(sessionId, params) {
-    const reasonContent = this.createContentFromReason(params.reason ?? null);
     return {
       sessionId,
       toolCall: {
         toolCallId: params.itemId,
         kind: "edit",
-        status: "pending",
-        content: reasonContent ? [reasonContent] : null
+        status: "pending"
       },
-      options: APPROVAL_OPTIONS
+      options: APPROVAL_OPTIONS,
+      _meta: { codex: { params } }
     };
   }
   convertCommandResponse(response) {
@@ -18000,12 +18151,19 @@ var CodexApprovalHandler = class {
   }
 };
 
+// src/McpApprovalOptionId.ts
+var McpApprovalOptionId = {
+  AllowOnce: "allow_once",
+  AllowSession: "allow_session",
+  AllowAlways: "allow_always",
+  Decline: "decline"
+};
+
 // src/CodexElicitationHandler.ts
 var ELICITATION_OPTIONS = [
   { optionId: "accept", name: "Accept", kind: "allow_once" },
   { optionId: "decline", name: "Decline", kind: "reject_once" }
 ];
-var OPTION_ALLOW_SESSION = "allow_session";
 function parsePersistOptions(meta) {
   const result = /* @__PURE__ */ new Set();
   if (!meta || typeof meta !== "object") return result;
@@ -18025,15 +18183,15 @@ function isMcpToolCallApproval(meta) {
 }
 function buildToolApprovalOptions(persistOptions) {
   const options = [
-    { optionId: ApprovalOptionId.AllowOnce, name: "Allow", kind: "allow_once" }
+    { optionId: McpApprovalOptionId.AllowOnce, name: "Allow", kind: "allow_once" }
   ];
   if (persistOptions.has("session")) {
-    options.push({ optionId: OPTION_ALLOW_SESSION, name: "Allow for This Session", kind: "allow_always" });
+    options.push({ optionId: McpApprovalOptionId.AllowSession, name: "Allow for This Session", kind: "allow_always" });
   }
   if (persistOptions.has("always")) {
-    options.push({ optionId: ApprovalOptionId.AllowAlways, name: "Allow and Don't Ask Again", kind: "allow_always" });
+    options.push({ optionId: McpApprovalOptionId.AllowAlways, name: "Allow and Don't Ask Again", kind: "allow_always" });
   }
-  options.push({ optionId: "decline", name: "Decline", kind: "reject_once" });
+  options.push({ optionId: McpApprovalOptionId.Decline, name: "Decline", kind: "reject_once" });
   return options;
 }
 var CodexElicitationHandler = class {
@@ -18080,7 +18238,7 @@ var CodexElicitationHandler = class {
       const response = await this.connection.requestPermission(request);
       if (correlatedCallId !== void 0 && response.outcome.outcome !== "cancelled") {
         const optionId = response.outcome.optionId;
-        if (optionId !== "decline") {
+        if (optionId !== McpApprovalOptionId.Decline) {
           await this.connection.sessionUpdate({
             sessionId: this.sessionState.sessionId,
             update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
@@ -18158,13 +18316,13 @@ var CodexElicitationHandler = class {
       return { action: "cancel", content: null, _meta: null };
     }
     const optionId = response.outcome.optionId;
-    if (optionId === OPTION_ALLOW_SESSION) {
+    if (optionId === McpApprovalOptionId.AllowSession) {
       return { action: "accept", content: null, _meta: { persist: "session" } };
     }
-    if (optionId === ApprovalOptionId.AllowAlways) {
+    if (optionId === McpApprovalOptionId.AllowAlways) {
       return { action: "accept", content: null, _meta: { persist: "always" } };
     }
-    if (optionId === ApprovalOptionId.AllowOnce || optionId === "accept") {
+    if (optionId === McpApprovalOptionId.AllowOnce || optionId === "accept") {
       return { action: "accept", content: null, _meta: null };
     }
     return { action: "decline", content: null, _meta: null };
@@ -18870,6 +19028,7 @@ var ModelId = class _ModelId {
 };
 
 // src/AgentMode.ts
+var MODE_CONFIG_ID = "mode";
 var AgentMode = class _AgentMode {
   id;
   name;
@@ -18932,6 +19091,21 @@ var AgentMode = class _AgentMode {
       currentModeId: this.id
     };
   }
+  toConfigOption() {
+    return {
+      id: MODE_CONFIG_ID,
+      name: "Mode",
+      description: "Approval and sandboxing preset for the session",
+      category: "mode",
+      type: "select",
+      currentValue: this.id,
+      options: _AgentMode.all().map((mode) => ({
+        value: mode.id,
+        name: mode.name,
+        description: mode.description
+      }))
+    };
+  }
   static all() {
     return [_AgentMode.ReadOnly, _AgentMode.Agent, _AgentMode.AgentFullAccess];
   }
@@ -18952,13 +19126,19 @@ var AgentMode = class _AgentMode {
 // src/CodexAcpClient.ts
 import path4 from "node:path";
 
+// src/McpServerName.ts
+var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
+function sanitizeMcpServerName(name) {
+  return name.replace(MCP_SERVER_NAME_WHITESPACE, "_");
+}
+
 // package.json
 var package_default = {
   name: "@agentclientprotocol/codex-acp",
   publishConfig: {
     access: "public"
   },
-  version: "0.0.44",
+  version: "0.0.46",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -19016,8 +19196,8 @@ var package_default = {
     vitest: "^4.0.10"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^0.21.0",
-    "@openai/codex": "^0.128.0",
+    "@agentclientprotocol/sdk": "^0.22.1",
+    "@openai/codex": "^0.137.0",
     diff: "^8.0.3",
     open: "^11.0.0",
     "vscode-jsonrpc": "^8.2.1"
@@ -19032,6 +19212,7 @@ var CodexAcpClient = class {
   gatewayConfig;
   pendingLoginCompleted = null;
   pendingAccountUpdated = null;
+  sessionNotificationQueues = /* @__PURE__ */ new Map();
   constructor(codexClient, codexConfig, modelProvider) {
     this.codexClient = codexClient;
     this.config = codexConfig ?? {};
@@ -19157,47 +19338,39 @@ var CodexAcpClient = class {
   async getAccount() {
     return this.codexClient.accountRead({ refreshToken: false });
   }
-  async resumeSession(request) {
+  async resumeSession(request, onSubscribed) {
     await this.refreshSkills(request.cwd, request._meta);
     const response = await this.codexClient.threadResume({
-      approvalPolicy: null,
-      sandbox: null,
-      baseInstructions: null,
       config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
       cwd: request.cwd,
-      developerInstructions: null,
-      model: null,
       modelProvider: this.getResumeModelProvider(),
-      personality: null,
       threadId: request.sessionId
     });
+    onSubscribed?.();
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
       sessionId: request.sessionId,
       currentModelId,
-      models: codexModels
+      models: codexModels,
+      currentServiceTier: response.serviceTier ?? null
     };
   }
-  async loadSession(request) {
+  async loadSession(request, onSubscribed) {
     const response = await this.codexClient.threadResume({
-      approvalPolicy: null,
-      sandbox: null,
-      baseInstructions: null,
       config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
       cwd: request.cwd,
-      developerInstructions: null,
-      model: null,
       modelProvider: this.getResumeModelProvider(),
-      personality: null,
       threadId: request.sessionId
     });
+    onSubscribed?.();
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      currentServiceTier: response.serviceTier ?? null,
       thread: response.thread
     };
   }
@@ -19206,14 +19379,7 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadStart({
       config: await this.createSessionConfig(request.cwd, request.mcpServers),
       modelProvider: this.getModelProvider(),
-      model: null,
-      cwd: request.cwd,
-      approvalPolicy: null,
-      sandbox: null,
-      baseInstructions: null,
-      developerInstructions: null,
-      personality: null,
-      ephemeral: null
+      cwd: request.cwd
     });
     const codexModels = await this.fetchAvailableModels();
     if (codexModels.length === 0) {
@@ -19223,9 +19389,17 @@ var CodexAcpClient = class {
     return {
       sessionId: response.thread.id,
       currentModelId,
-      models: codexModels
+      models: codexModels,
+      currentServiceTier: response.serviceTier ?? null
     };
   }
+  async closeSession(sessionId) {
+    try {
+      await this.codexClient.threadUnsubscribe({ threadId: sessionId });
+    } finally {
+      this.codexClient.clearThreadHandlers(sessionId);
+    }
+  }
   async awaitMcpServerStartup(serverNames, afterVersion) {
     return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
   }
@@ -19245,13 +19419,17 @@ var CodexAcpClient = class {
       return mergedConfig;
     }
     const existingNames = await this.getConfigMcpServerNames(projectPath);
-    const uniqueServers = mcpServers.filter((mcp) => !existingNames.has(mcp.name));
+    const requestedServers = mcpServers.map((mcp) => ({
+      name: sanitizeMcpServerName(mcp.name),
+      server: mcp
+    }));
+    const uniqueServers = requestedServers.filter((mcp) => !existingNames.has(mcp.name));
     if (uniqueServers.length === 0) {
       return mergedConfig;
     }
     return {
       ...mergedConfig,
-      "mcp_servers": Object.fromEntries(uniqueServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp)]))
+      "mcp_servers": Object.fromEntries(uniqueServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]))
     };
   }
   async getConfigMcpServerNames(projectPath) {
@@ -19272,14 +19450,13 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const additionalRoots = readAdditionalRoots(meta);
+    const additionalRoots = readAdditionalRoots(meta).map((root) => path4.join(root, ".agents", "skills"));
+    if (additionalRoots.length > 0) {
+      await this.codexClient.skillsExtraRootsSet({ extraRoots: additionalRoots });
+    }
     await this.codexClient.listSkills({
       cwds: [cwd],
-      forceReload: true,
-      perCwdExtraUserRoots: [{
-        cwd,
-        extraUserRoots: additionalRoots
-      }]
+      forceReload: true
     });
   }
   /**
@@ -19287,13 +19464,17 @@ var CodexAcpClient = class {
    */
   createMcpSeverConfig(mcpServer) {
     if ("type" in mcpServer) {
-      if (mcpServer.type == "sse") {
-        throw RequestError.invalidRequest("Codex doesn't support MCP SSE transport protocol");
+      switch (mcpServer.type) {
+        case "acp":
+          throw RequestError.invalidRequest("Codex doesn't support MCP ACP transport protocol");
+        case "sse":
+          throw RequestError.invalidRequest("Codex doesn't support MCP SSE transport protocol");
+        case "http":
+          return {
+            "url": mcpServer.url,
+            "http_headers": Object.fromEntries(mcpServer.headers.map((h) => [h.name, h.value]))
+          };
       }
-      return {
-        "url": mcpServer.url,
-        "http_headers": Object.fromEntries(mcpServer.headers.map((h) => [h.name, h.value]))
-      };
     }
     return {
       "command": mcpServer.command,
@@ -19313,26 +19494,73 @@ var CodexAcpClient = class {
     return ModelId.create(selectedModel.id, reasoningEffort ?? selectedModel.defaultReasoningEffort);
   }
   async subscribeToSessionEvents(sessionId, eventHandler, approvalHandler, elicitationHandler) {
-    this.codexClient.onServerNotification(sessionId, eventHandler);
-    this.codexClient.onApprovalRequest(sessionId, approvalHandler);
-    this.codexClient.onElicitationRequest(sessionId, elicitationHandler);
+    this.codexClient.onServerNotification(sessionId, (event) => {
+      this.enqueueSessionNotification(sessionId, () => eventHandler(event));
+    });
+    this.codexClient.onApprovalRequest(sessionId, {
+      handleCommandExecution: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await approvalHandler.handleCommandExecution(params);
+      },
+      handleFileChange: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await approvalHandler.handleFileChange(params);
+      }
+    });
+    this.codexClient.onElicitationRequest(sessionId, {
+      handleElicitation: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await elicitationHandler.handleElicitation(params);
+      }
+    });
+  }
+  async waitForSessionNotifications(sessionId) {
+    while (true) {
+      const queue = this.sessionNotificationQueues.get(sessionId);
+      if (!queue) return;
+      await queue;
+    }
+  }
+  enqueueSessionNotification(sessionId, operation) {
+    const run = async () => {
+      try {
+        await operation();
+      } catch (error40) {
+        logger.error("Error handling Codex session notification", error40);
+      }
+    };
+    const previous = this.sessionNotificationQueues.get(sessionId);
+    const next = previous ? previous.then(run, run) : run();
+    this.sessionNotificationQueues.set(sessionId, next);
+    void next.finally(() => {
+      if (this.sessionNotificationQueues.get(sessionId) === next) {
+        this.sessionNotificationQueues.delete(sessionId);
+      }
+    });
   }
-  async sendPrompt(request, agentMode, modelId, disableSummary, cwd) {
+  async sendPrompt(request, agentMode, modelId, serviceTier, disableSummary, cwd, onTurnStarted, shouldCancel) {
     const input = buildPromptItems(request.prompt);
     const effort = modelId.effort;
     await this.refreshSkills(cwd, request._meta);
+    if (shouldCancel?.()) {
+      return null;
+    }
     return await this.codexClient.runTurn({
-      outputSchema: null,
       threadId: request.sessionId,
       input,
       approvalPolicy: agentMode.approvalPolicy,
       sandboxPolicy: agentMode.sandboxPolicy,
       summary: disableSummary ? "none" : null,
-      personality: null,
-      cwd: null,
       effort,
-      model: modelId.model
-    });
+      model: modelId.model,
+      serviceTier
+    }, onTurnStarted);
+  }
+  resolveTurnInterrupted(params) {
+    this.codexClient.resolveTurnInterrupted(params.threadId, params.turnId);
+  }
+  markTurnStale(params) {
+    this.codexClient.markTurnStale(params.threadId, params.turnId);
   }
   async listSkills(params) {
     return this.codexClient.listSkills(params ?? {});
@@ -19374,8 +19602,8 @@ var CodexAcpClient = class {
       });
     });
   }
-  async listMcpServers(params = { cursor: null, limit: null }) {
-    return this.codexClient.listMcpServerStatus(params);
+  async listMcpServers() {
+    return this.codexClient.listMcpServerStatus({});
   }
   async listSessions(request) {
     const sourceKinds = [
@@ -19403,11 +19631,8 @@ var CodexAcpClient = class {
     const modelProviders = preferredProvider ? [preferredProvider] : [];
     const listResponse = await this.codexClient.threadList({
       cursor: request.cursor ?? null,
-      limit: null,
-      sortKey: null,
       modelProviders,
-      sourceKinds,
-      archived: null
+      sourceKinds
     });
     if (listResponse.data.length === 0) {
       const diagnostics = await this.runSessionListDiagnostics();
@@ -19416,14 +19641,14 @@ var CodexAcpClient = class {
     let sessions = listResponse.data.map((thread) => ({
       sessionId: thread.id,
       cwd: thread.cwd,
-      title: thread.preview || null,
+      title: (thread.name ?? thread.preview) || null,
       updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
     }));
     if (requestedCwd) {
       const filtered = listResponse.data.filter(filterByCwd).map((thread) => ({
         sessionId: thread.id,
         cwd: thread.cwd,
-        title: thread.preview || null,
+        title: (thread.name ?? thread.preview) || null,
         updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
       }));
       if (filtered.length > 0 || path4.isAbsolute(requestedCwd)) {
@@ -19455,30 +19680,9 @@ var CodexAcpClient = class {
   }
   async runSessionListDiagnostics() {
     const [allProviders, archivedAllProviders, customGateway] = await Promise.all([
-      this.codexClient.threadList({
-        cursor: null,
-        limit: null,
-        sortKey: null,
-        modelProviders: [],
-        sourceKinds: null,
-        archived: null
-      }),
-      this.codexClient.threadList({
-        cursor: null,
-        limit: null,
-        sortKey: null,
-        modelProviders: [],
-        sourceKinds: null,
-        archived: true
-      }),
-      this.codexClient.threadList({
-        cursor: null,
-        limit: null,
-        sortKey: null,
-        modelProviders: ["custom-gateway"],
-        sourceKinds: null,
-        archived: null
-      })
+      this.codexClient.threadList({}),
+      this.codexClient.threadList({ archived: true }),
+      this.codexClient.threadList({ modelProviders: ["custom-gateway"] })
     ]);
     return {
       allProviders: {
@@ -19557,6 +19761,44 @@ function mergeGatewayConfig(config2, gatewayConfig) {
   }
 }
 
+// src/ModelConfigOption.ts
+var MODEL_CONFIG_ID = "model";
+var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function findSupportedEffort(options, effort) {
+  if (!effort) return void 0;
+  return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
+}
+function createModelConfigOption(availableModels, currentBaseModelId) {
+  return {
+    id: MODEL_CONFIG_ID,
+    name: "Model",
+    description: "Model Codex uses for the session",
+    category: "model",
+    type: "select",
+    currentValue: currentBaseModelId,
+    options: availableModels.map((model) => ({
+      value: model.id,
+      name: model.displayName,
+      description: model.description
+    }))
+  };
+}
+function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
+  return {
+    id: REASONING_EFFORT_CONFIG_ID,
+    name: "Reasoning effort",
+    description: "How much reasoning effort the model should use",
+    category: "thought_level",
+    type: "select",
+    currentValue: currentEffort,
+    options: supportedReasoningEfforts.map((option) => ({
+      value: option.reasoningEffort,
+      name: option.reasoningEffort,
+      description: option.description
+    }))
+  };
+}
+
 // src/CodexCommands.ts
 var CodexCommands = class {
   connection;
@@ -19583,13 +19825,6 @@ var CodexCommands = class {
       logger.error(`Failed to publish available commands for session ${sessionId}`, err);
     }
   }
-  async tryHandle(prompt, sessionState) {
-    const command = this.parseCommand(prompt);
-    if (command) {
-      return this.handleCommand(command, sessionState);
-    }
-    return false;
-  }
   buildAvailableCommands(skillsEntries) {
     const commands = /* @__PURE__ */ new Map();
     for (const builtin of this.getBuiltinCommands()) {
@@ -19636,25 +19871,22 @@ var CodexCommands = class {
       }
     ];
   }
-  parseCommand(prompt) {
-    if (prompt.length !== 1) return null;
-    const [single] = prompt;
-    if (!single) return null;
-    if (single.type !== "text") return null;
-    const trimmed = single.text.trim();
-    if (!trimmed.startsWith("/")) return null;
-    const commandText = trimmed.slice(1).trim();
+  getCommandName(prompt) {
+    const firstBlock = prompt[0];
+    if (!firstBlock || firstBlock.type != "text") return null;
+    const text = firstBlock.text.trim();
+    if (!text.startsWith("/")) return null;
+    const commandText = text.slice(1).trim();
     if (commandText.length === 0) return null;
-    const [name, ...rest] = commandText.split(/\s+/);
-    const input = rest.join(" ").trim();
-    return {
-      name: name.toLowerCase(),
-      input: input.length > 0 ? input : null
-    };
+    const [name] = commandText.split(/\s+/);
+    return name?.toLowerCase() ?? null;
   }
-  async handleCommand(command, sessionState) {
+  async tryHandleCommand(prompt, sessionState) {
+    const commandName = this.getCommandName(prompt);
+    if (commandName === null) return false;
+    if (commandName.startsWith("$")) return false;
     const sessionId = sessionState.sessionId;
-    switch (command.name) {
+    switch (commandName) {
       case "status": {
         const session = new ACPSessionConnection(this.connection, sessionId);
         const message = this.buildStatusMessage(sessionState);
@@ -19706,7 +19938,7 @@ var CodexCommands = class {
         return true;
       }
       default:
-        await this.sendUnknownCommandMessage(command.name, sessionId);
+        await this.sendUnknownCommandMessage(commandName, sessionId);
         return true;
     }
   }
@@ -19863,22 +20095,84 @@ function isExtMethodRequest(request) {
   return request.method === "authentication/status" || request.method === "authentication/logout";
 }
 
+// src/FastModeConfig.ts
+var FAST_MODE_CONFIG_ID = "fast-mode";
+var FAST_MODE_ON = "on";
+var FAST_MODE_OFF = "off";
+var FAST_MODE_DESCRIPTION = "1.5x speed, increased usage";
+function modelSupportsFast(model) {
+  return model?.additionalSpeedTiers?.includes("fast") ?? false;
+}
+function resolveFastServiceTier(fastModeEnabled, currentModelSupportsFast) {
+  return fastModeEnabled && currentModelSupportsFast ? "fast" : null;
+}
+function createFastModeConfigOption(fastModeEnabled) {
+  return {
+    id: FAST_MODE_CONFIG_ID,
+    name: "Fast mode",
+    description: FAST_MODE_DESCRIPTION,
+    category: FAST_MODE_CONFIG_ID,
+    type: "select",
+    currentValue: fastModeEnabled ? FAST_MODE_ON : FAST_MODE_OFF,
+    options: [
+      {
+        value: FAST_MODE_OFF,
+        name: "Off",
+        description: "Default speed, normal usage"
+      },
+      {
+        value: FAST_MODE_ON,
+        name: "On",
+        description: FAST_MODE_DESCRIPTION
+      }
+    ]
+  };
+}
+
+// src/JBUtils.ts
+function isJetBrains2026_1Client(clientInfo) {
+  if (!clientInfo) {
+    return false;
+  }
+  const platform2 = clientInfo._meta?.["platform"];
+  const isIntelliJPlatform = platform2 === "intellij";
+  const isJetBrainsClient = clientInfo.name.startsWith("JetBrains");
+  return (isIntelliJPlatform || isJetBrainsClient) && clientInfo.version.startsWith("2026.1");
+}
+
 // src/CodexAcpServer.ts
-var CodexAcpServer = class {
+var CodexAcpServer = class _CodexAcpServer {
+  static MODEL_NAME_TOKEN_OVERRIDES = {
+    gpt: "GPT",
+    mini: "Mini",
+    codex: "Codex"
+  };
   codexAcpClient;
   connection;
   defaultAuthRequest;
   getExitCode;
   availableCommands;
+  clientInfo;
   sessions;
   pendingMcpStartupSessions;
+  pendingTurnStarts;
+  activePrompts;
+  closingSessions;
+  sessionGenerations;
+  sessionOpenGenerations;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
+    this.pendingTurnStarts = /* @__PURE__ */ new Map();
+    this.activePrompts = /* @__PURE__ */ new Map();
+    this.closingSessions = /* @__PURE__ */ new Map();
+    this.sessionGenerations = /* @__PURE__ */ new Map();
+    this.sessionOpenGenerations = /* @__PURE__ */ new Map();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.defaultAuthRequest = defaultAuthRequest ?? null;
     this.getExitCode = getExitCode ?? (() => null);
+    this.clientInfo = null;
     this.availableCommands = new CodexCommands(
       connection,
       codexAcpClient,
@@ -19887,22 +20181,31 @@ var CodexAcpServer = class {
   }
   async initialize(_params) {
     logger.log("Initialize request received");
+    this.clientInfo = _params.clientInfo ?? null;
     await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
     return {
       protocolVersion: PROTOCOL_VERSION,
+      agentInfo: {
+        name: package_default.name,
+        title: "Codex",
+        version: package_default.version
+      },
       agentCapabilities: {
         auth: {
           logout: {}
         },
         loadSession: true,
         promptCapabilities: {
+          embeddedContext: true,
           image: true
         },
         sessionCapabilities: {
           resume: {},
-          list: {}
+          list: {},
+          close: {}
         },
         mcpCapabilities: {
+          acp: false,
           http: true,
           sse: false
         }
@@ -19941,24 +20244,123 @@ var CodexAcpServer = class {
     }
   }
   async getOrCreateSession(request) {
+    try {
+      return await this.tryCreateSession(request);
+    } catch (e) {
+      const error40 = e instanceof Error ? e : new Error(String(e));
+      await this.handleError(error40);
+      throw e;
+    }
+  }
+  async handleError(e) {
+    if (e.message.includes("log out")) {
+      await this.runWithProcessCheck(() => this.codexAcpClient.logout());
+      throw RequestError.internalError(`${e.message}
+
+You have been logged out. Please try again.`);
+    }
+  }
+  beginSessionOpen(sessionId) {
+    const generation = this.getSessionGeneration(sessionId);
+    if (this.sessionIsClosing(sessionId)) {
+      throw RequestError.invalidRequest(`Session ${sessionId} is closing`);
+    }
+    this.sessionOpenGenerations.set(sessionId, generation);
+    return generation;
+  }
+  sessionOpenCanInstall(sessionId, generation) {
+    return !this.sessionIsClosing(sessionId) && this.getSessionGeneration(sessionId) === generation;
+  }
+  async cleanupStaleSessionOpen(sessionId, generation) {
+    if (this.sessionOpenGenerations.get(sessionId) === generation) {
+      if (!this.sessionIsClosing(sessionId)) {
+        this.bumpSessionGeneration(sessionId);
+      }
+      this.beginSessionCloseFence(sessionId);
+      try {
+        await this.runWithProcessCheck(() => this.codexAcpClient.closeSession(sessionId));
+      } catch (err) {
+        logger.error(`Failed to close stale session open for ${sessionId}`, err);
+      } finally {
+        this.endSessionCloseFence(sessionId);
+      }
+      return true;
+    }
+    return false;
+  }
+  async closeStaleSessionOpen(sessionId, generation) {
+    await this.cleanupStaleSessionOpen(sessionId, generation);
+    throw RequestError.invalidRequest(`Session ${sessionId} is closing`);
+  }
+  sessionIsClosing(sessionId) {
+    return (this.closingSessions.get(sessionId) ?? 0) > 0;
+  }
+  beginSessionCloseFence(sessionId) {
+    this.closingSessions.set(sessionId, (this.closingSessions.get(sessionId) ?? 0) + 1);
+  }
+  endSessionCloseFence(sessionId) {
+    const count = this.closingSessions.get(sessionId) ?? 0;
+    if (count <= 1) {
+      this.closingSessions.delete(sessionId);
+      return;
+    }
+    this.closingSessions.set(sessionId, count - 1);
+  }
+  getSessionGeneration(sessionId) {
+    return this.sessionGenerations.get(sessionId) ?? 0;
+  }
+  bumpSessionGeneration(sessionId) {
+    const generation = this.getSessionGeneration(sessionId) + 1;
+    this.sessionGenerations.set(sessionId, generation);
+    return generation;
+  }
+  async tryCreateSession(request) {
+    const requestedSessionGeneration = "sessionId" in request ? this.beginSessionOpen(request.sessionId) : null;
     await this.checkAuthorization();
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     let sessionMetadata;
+    let resumeSubscribed = false;
     if ("sessionId" in request) {
       logger.log(`Resume existing session: ${request.sessionId}...`);
-      sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.resumeSession(request));
+      try {
+        sessionMetadata = await this.runWithProcessCheck(
+          () => this.codexAcpClient.resumeSession(request, () => {
+            resumeSubscribed = true;
+          })
+        );
+      } catch (err) {
+        if (resumeSubscribed && requestedSessionGeneration !== null) {
+          await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+        }
+        throw err;
+      }
     } else {
       logger.log(`Create new session...`);
       sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.newSession(request));
     }
-    const account = await this.getActiveAccount();
     const { sessionId, currentModelId, models } = sessionMetadata;
+    let account;
+    try {
+      account = await this.getActiveAccount();
+    } catch (err) {
+      if (resumeSubscribed && requestedSessionGeneration !== null) {
+        await this.cleanupStaleSessionOpen(sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
+    const sessionGeneration = requestedSessionGeneration ?? this.beginSessionOpen(sessionId);
+    if (!this.sessionOpenCanInstall(sessionId, sessionGeneration)) {
+      resumeSubscribed = false;
+      await this.closeStaleSessionOpen(sessionId, sessionGeneration);
+    }
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, "sessionId" in request);
     const currentModel = this.findCurrentModel(models, currentModelId);
+    const currentModelSupportsFast = modelSupportsFast(currentModel);
     const sessionState = {
       sessionId,
       currentModelId,
+      availableModels: models,
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
@@ -19969,12 +20371,15 @@ var CodexAcpServer = class {
       rateLimits: null,
       account,
       cwd: request.cwd,
+      fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
+      currentModelSupportsFast,
       sessionMcpServers
     };
     this.sessions.set(sessionId, sessionState);
+    resumeSubscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
-        requestedServers: new Set(requestedMcpServers.map((server) => server.name)),
+        requestedServers: new Set(getRequestedMcpServerNames(requestedMcpServers)),
         afterVersion: mcpServerStartupVersion
       });
       this.publishMcpStartupStatusAsync(sessionId);
@@ -20007,7 +20412,8 @@ var CodexAcpServer = class {
     });
     return {
       models: modelState,
-      modes: modeState
+      modes: modeState,
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async resumeSession(params) {
@@ -20020,7 +20426,8 @@ var CodexAcpServer = class {
     });
     return {
       models: modelState,
-      modes: modeState
+      modes: modeState,
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async listSessions(params) {
@@ -20028,6 +20435,35 @@ var CodexAcpServer = class {
     await this.checkAuthorization();
     return await this.runWithProcessCheck(() => this.codexAcpClient.listSessions(params));
   }
+  async closeSession(params) {
+    logger.log("Closing session...", { sessionId: params.sessionId });
+    const closeGeneration = this.bumpSessionGeneration(params.sessionId);
+    const sessionState = this.sessions.get(params.sessionId);
+    this.beginSessionCloseFence(params.sessionId);
+    try {
+      if (sessionState) {
+        await this.interruptSessionTurn(sessionState, "Close", true);
+      } else {
+        logger.log("Close request received for unknown local session", { sessionId: params.sessionId });
+      }
+      const activePrompt = this.activePrompts.get(params.sessionId);
+      if (activePrompt) {
+        activePrompt.requestClose();
+        await activePrompt.completion;
+      }
+      await this.runWithProcessCheck(() => this.codexAcpClient.closeSession(params.sessionId));
+      logger.log("Session closed", { sessionId: params.sessionId });
+    } finally {
+      if (this.getSessionGeneration(params.sessionId) === closeGeneration) {
+        this.sessions.delete(params.sessionId);
+        this.pendingMcpStartupSessions.delete(params.sessionId);
+        this.pendingTurnStarts.delete(params.sessionId);
+        this.activePrompts.delete(params.sessionId);
+      }
+      this.endSessionCloseFence(params.sessionId);
+    }
+    return {};
+  }
   async newSession(params) {
     logger.log("Starting new session...");
     const [sessionId, modelState, modeState] = await this.getOrCreateSession(params);
@@ -20039,7 +20475,8 @@ var CodexAcpServer = class {
     return {
       sessionId,
       models: modelState,
-      modes: modeState
+      modes: modeState,
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async authenticate(_params) {
@@ -20064,12 +20501,75 @@ var CodexAcpServer = class {
     });
     const sessionState = this.sessions.get(_params.sessionId);
     if (!sessionState) throw new Error(`Session ${_params.sessionId} not found`);
-    const newMode = AgentMode.find(_params.modeId);
+    this.applyModeChange(sessionState, _params.modeId);
+    return {};
+  }
+  async setSessionConfigOption(params) {
+    logger.log("Set session config option requested", {
+      sessionId: params.sessionId,
+      configId: params.configId
+    });
+    const sessionState = this.sessions.get(params.sessionId);
+    if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
+    if (typeof params.value !== "string") {
+      throw RequestError.invalidParams();
+    }
+    const value = params.value;
+    switch (params.configId) {
+      case FAST_MODE_CONFIG_ID:
+        this.applyFastModeChange(sessionState, value);
+        break;
+      case MODE_CONFIG_ID:
+        this.applyModeChange(sessionState, value);
+        break;
+      case MODEL_CONFIG_ID:
+        this.applyModelChange(sessionState, value);
+        break;
+      case REASONING_EFFORT_CONFIG_ID:
+        this.applyReasoningEffortChange(sessionState, value);
+        break;
+      default:
+        throw RequestError.invalidParams();
+    }
+    return {
+      configOptions: this.createSessionConfigOptions(sessionState)
+    };
+  }
+  applyFastModeChange(sessionState, value) {
+    if (value !== FAST_MODE_ON && value !== FAST_MODE_OFF) {
+      throw RequestError.invalidParams();
+    }
+    sessionState.fastModeEnabled = value === FAST_MODE_ON;
+  }
+  applyModeChange(sessionState, value) {
+    const newMode = AgentMode.find(value);
     if (!newMode) {
       throw RequestError.invalidParams();
     }
     sessionState.agentMode = newMode;
-    return {};
+  }
+  applyModelChange(sessionState, value) {
+    const model = sessionState.availableModels.find((m) => m.id === value);
+    if (!model) {
+      throw RequestError.invalidParams();
+    }
+    const currentEffort = ModelId.fromString(sessionState.currentModelId).effort;
+    const effort = findSupportedEffort(model.supportedReasoningEfforts, currentEffort) ?? model.defaultReasoningEffort;
+    this.applyModelAndEffort(sessionState, model, effort);
+  }
+  applyReasoningEffortChange(sessionState, value) {
+    const effort = findSupportedEffort(sessionState.supportedReasoningEfforts, value);
+    if (!effort) {
+      throw RequestError.invalidParams();
+    }
+    const { model } = ModelId.fromString(sessionState.currentModelId);
+    sessionState.currentModelId = ModelId.create(model, effort).toString();
+  }
+  applyModelAndEffort(sessionState, model, effort) {
+    sessionState.currentModelId = ModelId.fromComponents(model, effort).toString();
+    sessionState.supportedReasoningEfforts = model.supportedReasoningEfforts;
+    sessionState.supportedInputModalities = model.inputModalities;
+    sessionState.currentModelSupportsFast = modelSupportsFast(model);
   }
   async unstable_setSessionModel(params) {
     logger.log("Set session model requested", {
@@ -20078,30 +20578,44 @@ var CodexAcpServer = class {
     });
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
-    const requestedModelId = ModelId.fromString(params.modelId);
-    const requestedModelName = requestedModelId.model;
-    const requestedEffort = requestedModelId.effort;
+    const { model: requestedModelName, effort: requestedEffort } = ModelId.fromString(params.modelId);
     const models = await this.codexAcpClient.fetchAvailableModels();
     const model = models.find((m) => m.id === requestedModelName);
     if (!model) throw new Error(`Unknown model ${params.modelId}`);
-    const requestedEffortValue = requestedEffort;
     let reasoningEffort;
-    if (requestedEffortValue) {
-      const matchedEffort = model.supportedReasoningEfforts.find(
-        (option) => option.reasoningEffort === requestedEffortValue
-      )?.reasoningEffort;
+    if (requestedEffort) {
+      const matchedEffort = findSupportedEffort(model.supportedReasoningEfforts, requestedEffort);
       if (!matchedEffort) {
-        throw new Error(`Unsupported reasoning effort ${requestedEffortValue} for model ${requestedModelName}`);
+        throw new Error(`Unsupported reasoning effort ${requestedEffort} for model ${requestedModelName}`);
       }
       reasoningEffort = matchedEffort;
     } else {
       reasoningEffort = model.defaultReasoningEffort;
     }
-    sessionState.currentModelId = ModelId.fromComponents(model, reasoningEffort).toString();
-    sessionState.supportedReasoningEfforts = model.supportedReasoningEfforts;
-    sessionState.supportedInputModalities = model.inputModalities;
+    sessionState.availableModels = models;
+    this.applyModelAndEffort(sessionState, model, reasoningEffort);
     return {};
   }
+  createSessionConfigOptions(sessionState) {
+    const currentModelId = ModelId.fromString(sessionState.currentModelId);
+    return [
+      sessionState.agentMode.toConfigOption(),
+      createModelConfigOption(sessionState.availableModels, currentModelId.model),
+      createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort),
+      createFastModeConfigOption(sessionState.fastModeEnabled)
+    ];
+  }
+  createSessionConfigOptionsResponse(sessionState) {
+    if (!this.isSessionConfigEnabled()) {
+      return {};
+    }
+    return {
+      configOptions: this.createSessionConfigOptions(sessionState)
+    };
+  }
+  isSessionConfigEnabled() {
+    return !isJetBrains2026_1Client(this.clientInfo);
+  }
   publishAvailableCommandsAsync(sessionId) {
     void this.availableCommands.publish(sessionId);
   }
@@ -20109,11 +20623,14 @@ var CodexAcpServer = class {
     const modelId = ModelId.fromString(currentModelId);
     return models.find((m) => m.id === modelId.model);
   }
+  normalizeModelDisplayName(displayName) {
+    return displayName.split("-").map((token) => _CodexAcpServer.MODEL_NAME_TOKEN_OVERRIDES[token.toLowerCase()] ?? token).join("-");
+  }
   createModelState(availableModels, selectedModelId) {
     const allowedModels = availableModels.flatMap(
       (model) => model.supportedReasoningEfforts.map((effort) => ({
         modelId: ModelId.fromComponents(model, effort.reasoningEffort).toString(),
-        name: `${model.displayName} (${effort.reasoningEffort})`,
+        name: `${this.normalizeModelDisplayName(model.displayName)} (${effort.reasoningEffort})`,
         description: `${model.description} ${effort.description}`
       }))
     );
@@ -20123,20 +20640,46 @@ var CodexAcpServer = class {
     };
   }
   async getOrCreateSessionWithHistory(request) {
+    const requestedSessionGeneration = this.beginSessionOpen(request.sessionId);
     await this.checkAuthorization();
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     logger.log(`Load existing session: ${request.sessionId}...`);
-    const sessionMetadata = await this.runWithProcessCheck(
-      () => this.codexAcpClient.loadSession(request)
-    );
-    const account = await this.getActiveAccount();
+    let subscribed = false;
+    let sessionMetadata;
+    try {
+      sessionMetadata = await this.runWithProcessCheck(
+        () => this.codexAcpClient.loadSession(request, () => {
+          subscribed = true;
+        })
+      );
+    } catch (err) {
+      if (subscribed) {
+        await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
     const { sessionId, currentModelId, models, thread } = sessionMetadata;
+    let account;
+    try {
+      account = await this.getActiveAccount();
+    } catch (err) {
+      if (subscribed) {
+        await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
+    if (!this.sessionOpenCanInstall(sessionId, requestedSessionGeneration)) {
+      subscribed = false;
+      await this.closeStaleSessionOpen(sessionId, requestedSessionGeneration);
+    }
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, true);
     const currentModel = this.findCurrentModel(models, currentModelId);
+    const currentModelSupportsFast = modelSupportsFast(currentModel);
     const sessionState = {
       sessionId,
       currentModelId,
+      availableModels: models,
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
@@ -20147,12 +20690,15 @@ var CodexAcpServer = class {
       rateLimits: null,
       account,
       cwd: request.cwd,
+      fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
+      currentModelSupportsFast,
       sessionMcpServers
     };
     this.sessions.set(sessionId, sessionState);
+    subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
-        requestedServers: new Set(requestedMcpServers.map((server) => server.name)),
+        requestedServers: new Set(getRequestedMcpServerNames(requestedMcpServers)),
         afterVersion: mcpServerStartupVersion
       });
       this.publishMcpStartupStatusAsync(sessionId);
@@ -20398,11 +20944,16 @@ ${item.text}`
           pendingStartup.afterVersion
         )
       );
+      if (!this.sessions.has(sessionId) || this.sessionIsClosing(sessionId) || this.pendingMcpStartupSessions.get(sessionId) !== pendingStartup) {
+        return;
+      }
       await this.publishMcpStartupStatus(sessionId, mcpStartup, pendingStartup.requestedServers);
     } catch (err) {
       logger.error(`Failed to publish MCP startup status for session ${sessionId}`, err);
     } finally {
-      this.pendingMcpStartupSessions.delete(sessionId);
+      if (this.pendingMcpStartupSessions.get(sessionId) === pendingStartup) {
+        this.pendingMcpStartupSessions.delete(sessionId);
+      }
     }
   }
   async publishMcpStartupStatus(sessionId, mcpStartup, requestedServers) {
@@ -20418,6 +20969,125 @@ ${item.text}`
       });
     }
   }
+  trackActivePrompt(sessionId) {
+    let resolveCompletion = () => {
+    };
+    const completion = new Promise((resolve) => {
+      resolveCompletion = resolve;
+    });
+    let resolveCloseSignal = () => {
+    };
+    const closeSignal = new Promise((resolve) => {
+      resolveCloseSignal = resolve;
+    });
+    let completed = false;
+    let closeRequested = false;
+    const activePrompt = {
+      completion,
+      closeSignal,
+      requestClose: () => {
+        if (closeRequested) {
+          return;
+        }
+        closeRequested = true;
+        resolveCloseSignal(null);
+      },
+      complete: () => {
+        if (completed) {
+          return;
+        }
+        completed = true;
+        if (this.activePrompts.get(sessionId) === activePrompt) {
+          this.activePrompts.delete(sessionId);
+        }
+        resolveCompletion();
+      }
+    };
+    this.activePrompts.set(sessionId, activePrompt);
+    return activePrompt;
+  }
+  createPendingTurnStart() {
+    let resolve = () => {
+    };
+    const promise2 = new Promise((innerResolve) => {
+      resolve = innerResolve;
+    });
+    return { promise: promise2, resolve };
+  }
+  interruptLateStartedTurn(sessionId, turnId) {
+    this.codexAcpClient.markTurnStale({
+      threadId: sessionId,
+      turnId
+    });
+    void this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
+      threadId: sessionId,
+      turnId
+    })).catch((err) => {
+      logger.error(`Close - late turnInterrupt failed`, err);
+    }).finally(() => {
+      this.codexAcpClient.resolveTurnInterrupted({
+        threadId: sessionId,
+        turnId
+      });
+    });
+  }
+  promptIsClosedOrStale(sessionId, activePrompt) {
+    return this.activePrompts.get(sessionId) !== activePrompt || this.sessionIsClosing(sessionId);
+  }
+  async interruptSessionTurn(sessionState, requestName, resolveInterruptedTurn) {
+    const turnId = await this.getInterruptibleTurnId(sessionState, requestName);
+    if (!turnId) {
+      return;
+    }
+    logger.log(`${requestName} session requested`, {
+      sessionId: sessionState.sessionId,
+      currentTurnId: turnId
+    });
+    if (resolveInterruptedTurn) {
+      this.codexAcpClient.markTurnStale({
+        threadId: sessionState.sessionId,
+        turnId
+      });
+    }
+    try {
+      await this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
+        threadId: sessionState.sessionId,
+        turnId
+      }));
+      logger.log(`${requestName} - turnInterrupt succeeded`, {
+        sessionId: sessionState.sessionId,
+        currentTurnId: turnId
+      });
+    } catch (err) {
+      logger.error(`${requestName} - turnInterrupt failed`, err);
+    } finally {
+      if (resolveInterruptedTurn) {
+        this.codexAcpClient.resolveTurnInterrupted({
+          threadId: sessionState.sessionId,
+          turnId
+        });
+      }
+    }
+  }
+  async getInterruptibleTurnId(sessionState, requestName) {
+    if (sessionState.currentTurnId) {
+      return sessionState.currentTurnId;
+    }
+    const pendingTurnStart = this.pendingTurnStarts.get(sessionState.sessionId);
+    if (!pendingTurnStart) {
+      logger.log(`${requestName} request rejected: no current turn`, { sessionId: sessionState.sessionId });
+      return null;
+    }
+    if (requestName === "Close") {
+      pendingTurnStart.resolve(null);
+      return null;
+    }
+    const turnId = await pendingTurnStart.promise;
+    if (!turnId) {
+      logger.log(`${requestName} request rejected: no current turn`, { sessionId: sessionState.sessionId });
+    }
+    return turnId;
+  }
   async prompt(params) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
@@ -20426,6 +21096,8 @@ ${item.text}`
     const sessionState = this.getSessionState(params.sessionId);
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
+    const activePrompt = this.trackActivePrompt(params.sessionId);
+    let pendingTurnStart = null;
     try {
       const eventHandler = new CodexEventHandler(this.connection, sessionState);
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState);
@@ -20439,7 +21111,7 @@ ${item.text}`
         approvalHandler,
         elicitationHandler
       );
-      if (await this.availableCommands.tryHandle(params.prompt, sessionState)) {
+      if (await this.availableCommands.tryHandleCommand(params.prompt, sessionState)) {
         logger.log("Prompt handled by a command");
         return {
           stopReason: "end_turn",
@@ -20447,6 +21119,13 @@ ${item.text}`
           _meta: this.buildQuotaMeta(sessionState)
         };
       }
+      if (this.sessionIsClosing(params.sessionId)) {
+        return {
+          stopReason: "cancelled",
+          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+          _meta: this.buildQuotaMeta(sessionState)
+        };
+      }
       const modelId = ModelId.fromString(sessionState.currentModelId);
       const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0 && sessionState.supportedReasoningEfforts.every((e) => e.reasoningEffort === "none");
       const disableSummary = sessionState.account?.type === "apiKey" || modelLacksReasoning;
@@ -20460,20 +21139,61 @@ ${item.text}`
         throw RequestError.invalidRequest("The current model does not support image input");
       }
       const agentMode = sessionState.agentMode;
-      const turnCompleted = await this.runWithProcessCheck(
-        () => this.codexAcpClient.sendPrompt(params, agentMode, modelId, disableSummary, sessionState.cwd)
+      const serviceTier = resolveFastServiceTier(
+        sessionState.fastModeEnabled,
+        sessionState.currentModelSupportsFast
       );
+      pendingTurnStart = this.createPendingTurnStart();
+      this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      const sendPromptPromise = this.runWithProcessCheck(
+        () => this.codexAcpClient.sendPrompt(
+          params,
+          agentMode,
+          modelId,
+          serviceTier,
+          disableSummary,
+          sessionState.cwd,
+          (turnId) => {
+            if (this.promptIsClosedOrStale(params.sessionId, activePrompt)) {
+              this.interruptLateStartedTurn(params.sessionId, turnId);
+              return;
+            }
+            sessionState.currentTurnId = turnId;
+            pendingTurnStart?.resolve(turnId);
+          },
+          () => this.promptIsClosedOrStale(params.sessionId, activePrompt)
+        )
+      );
+      void sendPromptPromise.catch((err) => {
+        if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+          logger.error(`Prompt for closed session ${params.sessionId} failed after close`, err);
+        }
+      });
+      const turnCompleted = await Promise.race([
+        sendPromptPromise,
+        activePrompt.closeSignal
+      ]);
+      if (turnCompleted === null) {
+        return {
+          stopReason: "cancelled",
+          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+          _meta: this.buildQuotaMeta(sessionState)
+        };
+      }
+      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
-        await this.connection.sessionUpdate({
-          sessionId: params.sessionId,
-          update: {
-            sessionUpdate: "agent_message_chunk",
-            content: {
-              type: "text",
-              text: "*Conversation interrupted*"
+        if (!this.sessionIsClosing(params.sessionId) && this.sessions.has(params.sessionId)) {
+          await this.connection.sessionUpdate({
+            sessionId: params.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "*Conversation interrupted*"
+              }
             }
-          }
-        });
+          });
+        }
         return {
           stopReason: "cancelled",
           usage: this.buildPromptUsage(sessionState.lastTokenUsage),
@@ -20495,6 +21215,11 @@ ${item.text}`
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
       sessionState.currentTurnId = null;
+      if (pendingTurnStart !== null && this.pendingTurnStarts.get(params.sessionId) === pendingTurnStart) {
+        this.pendingTurnStarts.delete(params.sessionId);
+      }
+      pendingTurnStart?.resolve(null);
+      activePrompt.complete();
     }
   }
   buildQuotaMeta(sessionState) {
@@ -20535,30 +21260,11 @@ ${item.text}`
       logger.log("Cancel request rejected: session not found", { sessionId: params.sessionId });
       return;
     }
-    if (!sessionState.currentTurnId) {
-      logger.log("Cancel request rejected: no current turn", { sessionId: params.sessionId });
-      return;
-    }
-    logger.log("Cancel session requested", {
-      sessionId: params.sessionId,
-      currentTurnId: sessionState.currentTurnId
-    });
-    try {
-      await this.codexAcpClient.turnInterrupt({
-        threadId: params.sessionId,
-        turnId: sessionState.currentTurnId
-      });
-      logger.log("Cancel - turnInterrupt succeeded", {
-        sessionId: params.sessionId,
-        currentTurnId: sessionState.currentTurnId
-      });
-    } catch (err) {
-      logger.error(`Cancel - turnInterrupt failed`, err);
-    }
+    await this.interruptSessionTurn(sessionState, "Cancel", false);
   }
 };
 function getRequestedMcpServerNames(mcpServers) {
-  return Array.from(new Set(mcpServers.map((server) => server.name)));
+  return Array.from(new Set(mcpServers.map((server) => sanitizeMcpServerName(server.name))));
 }
 
 // src/CodexAppServerClient.ts
@@ -20575,6 +21281,7 @@ var CodexAppServerClient = class {
   mcpServerStartupResolvers = [];
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
+  staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
     this.connection.onUnhandledNotification((data) => {
@@ -20591,12 +21298,26 @@ var CodexAppServerClient = class {
       if (isTurnCompletedNotification(serverNotification)) {
         this.recordTurnCompleted(serverNotification.params);
       }
+      const routing = extractTurnRouting(serverNotification);
+      const staleTurnNotification = this.isStaleTurn(routing.threadId, routing.turnId);
+      if (staleTurnNotification) {
+        if (isTurnCompletedNotification(serverNotification) && routing.threadId !== null && routing.turnId !== null) {
+          this.clearStaleTurn(routing.threadId, routing.turnId);
+        }
+        for (const callback of this.codexEventHandlers) {
+          callback({ eventType: "notification", ...serverNotification });
+        }
+        return;
+      }
       this.notify(serverNotification);
       for (const callback of this.codexEventHandlers) {
         callback({ eventType: "notification", ...serverNotification });
       }
     });
     this.connection.onRequest(CommandExecutionApprovalRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { decision: "cancel" };
+      }
       const handler = this.approvalHandlers.get(params.threadId);
       if (!handler) {
         return { decision: "cancel" };
@@ -20604,6 +21325,9 @@ var CodexAppServerClient = class {
       return await handler.handleCommandExecution(params);
     });
     this.connection.onRequest(FileChangeApprovalRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { decision: "cancel" };
+      }
       const handler = this.approvalHandlers.get(params.threadId);
       if (!handler) {
         return { decision: "cancel" };
@@ -20611,6 +21335,9 @@ var CodexAppServerClient = class {
       return await handler.handleFileChange(params);
     });
     this.connection.onRequest(McpServerElicitationRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { action: "cancel", content: null, _meta: null };
+      }
       const handler = this.elicitationHandlers.get(params.threadId);
       if (!handler) {
         return { action: "cancel", content: null, _meta: null };
@@ -20624,19 +21351,25 @@ var CodexAppServerClient = class {
   onElicitationRequest(threadId, handler) {
     this.elicitationHandlers.set(threadId, handler);
   }
+  clearThreadHandlers(threadId) {
+    this.notificationHandlers.delete(threadId);
+    this.approvalHandlers.delete(threadId);
+    this.elicitationHandlers.delete(threadId);
+  }
   async initialize(params) {
     return await this.sendRequest({ method: "initialize", params });
   }
   async turnStart(params) {
     return await this.sendRequest({ method: "turn/start", params });
   }
-  async runTurn(params) {
+  async runTurn(params, onTurnStarted) {
     const capturedCompletions = [];
     const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
       capturedCompletions.push(event);
     });
     try {
       const turnStarted = await this.turnStart(params);
+      onTurnStarted?.(turnStarted.turn.id);
       const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnStarted.turn.id);
       releaseCapture();
       if (earlyCompletion) {
@@ -20650,6 +21383,11 @@ var CodexAppServerClient = class {
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
   }
+  markTurnStale(threadId, turnId) {
+    const threadStaleTurns = this.staleTurnIds.get(threadId) ?? /* @__PURE__ */ new Set();
+    threadStaleTurns.add(turnId);
+    this.staleTurnIds.set(threadId, threadStaleTurns);
+  }
   async threadStart(params) {
     return await this.sendRequest({ method: "thread/start", params });
   }
@@ -20665,6 +21403,9 @@ var CodexAppServerClient = class {
   async threadRead(params) {
     return await this.sendRequest({ method: "thread/read", params });
   }
+  async threadUnsubscribe(params) {
+    return await this.sendRequest({ method: "thread/unsubscribe", params });
+  }
   async listMcpServerStatus(params) {
     return await this.sendRequest({ method: "mcpServerStatus/list", params });
   }
@@ -20707,10 +21448,28 @@ var CodexAppServerClient = class {
       threadResolvers.set(turnId, resolve);
     });
   }
-  async listModels(params = { cursor: null, limit: null }) {
+  resolveTurnInterrupted(threadId, turnId) {
+    this.recordTurnCompleted({
+      threadId,
+      turn: {
+        id: turnId,
+        items: [],
+        itemsView: "notLoaded",
+        status: "interrupted",
+        error: null,
+        startedAt: null,
+        completedAt: null,
+        durationMs: null
+      }
+    });
+  }
+  async listModels(params) {
     return await this.sendRequest({ method: "model/list", params });
   }
-  async listSkills(params = {}) {
+  async skillsExtraRootsSet(params) {
+    return await this.sendRequest({ method: "skills/extraRoots/set", params });
+  }
+  async listSkills(params) {
     return await this.sendRequest({ method: "skills/list", params });
   }
   /**
@@ -20757,6 +21516,22 @@ var CodexAppServerClient = class {
       capture(event);
     }
   }
+  isStaleTurn(threadId, turnId) {
+    if (threadId === null || turnId === null) {
+      return false;
+    }
+    return this.staleTurnIds.get(threadId)?.has(turnId) ?? false;
+  }
+  clearStaleTurn(threadId, turnId) {
+    const threadStaleTurns = this.staleTurnIds.get(threadId);
+    if (!threadStaleTurns) {
+      return;
+    }
+    threadStaleTurns.delete(turnId);
+    if (threadStaleTurns.size === 0) {
+      this.staleTurnIds.delete(threadId);
+    }
+  }
   getOrCreatePendingTurnCompletionResolvers(threadId) {
     const existing = this.pendingTurnCompletionResolvers.get(threadId);
     if (existing) {
@@ -20851,6 +21626,17 @@ function extractThreadId(notification) {
   }
   return null;
 }
+function extractTurnRouting(notification) {
+  const params = notification.params;
+  const threadId = extractThreadId(notification);
+  if (params && typeof params.turnId === "string") {
+    return { threadId, turnId: params.turnId };
+  }
+  if (params && typeof params.turn?.id === "string") {
+    return { threadId, turnId: params.turn.id };
+  }
+  return { threadId, turnId: null };
+}
 
 // src/login.ts
 function parseArgs(args) {
@@ -20955,6 +21741,34 @@ async function runLoginCommand(args) {
   return login(options);
 }
 
+// src/CodexCli.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createRequire as createRequire2 } from "node:module";
+function runCodexCli(codexPath, args) {
+  const child = spawnCodexCli(codexPath, args);
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+function spawnCodexCli(codexPath, args) {
+  const options = {
+    env: process.env,
+    stdio: "inherit"
+  };
+  if (codexPath) {
+    return spawn2(codexPath, args, { ...options, shell: process.platform === "win32" });
+  }
+  const bundledCodexPath = createRequire2(import.meta.url).resolve("@openai/codex/bin/codex.js");
+  return spawn2(process.execPath, [bundledCodexPath, ...args], options);
+}
+
 // src/index.ts
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
@@ -20966,6 +21780,12 @@ if (process.argv[2] === "login") {
     console.error("Login error:", error40.message);
     process.exit(1);
   });
+} else if (process.argv[2] === "cli") {
+  const args = process.argv.slice(3);
+  runCodexCli(process.env["CODEX_PATH"], args).then((exitCode) => process.exit(exitCode)).catch((error40) => {
+    console.error("Codex CLI error:", error40.message);
+    process.exit(1);
+  });
 } else {
   startAcpServer();
 }