@agentclientprotocol/codex-acp 1.1.5 → 1.1.8

package/dist/index.js

@@ -18470,6 +18470,7 @@ var zToolCallUpdate = object({
   kind: defaultOnError(zToolKind.nullish(), () => void 0),
   status: defaultOnError(zToolCallStatus.nullish(), () => void 0),
   title: defaultOnError(string2().nullish(), () => void 0),
+  name: defaultOnError(string2().nullish(), () => void 0),
   content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => void 0),
   locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => void 0),
   rawInput: defaultOnError(unknown().optional(), () => void 0),
@@ -19235,6 +19236,7 @@ var zContentChunk = object({
 var zToolCall = object({
   toolCallId: zToolCallId,
   title: string2(),
+  name: defaultOnError(string2().nullish(), () => void 0),
   kind: defaultOnError(zToolKind.optional(), () => void 0),
   status: defaultOnError(zToolCallStatus.optional(), () => void 0),
   content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
@@ -19916,66 +19918,71 @@ var zCancelRequestNotification = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
 
-// node_modules/@agentclientprotocol/sdk/dist/schema/guards.gen.js
-function tagOf(value, key) {
-  return typeof value === "object" && value !== null ? value[key] : void 0;
-}
-var zGuardCreateElicitationRequestForm = zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string2() }));
-var zGuardCreateElicitationRequestUrl = zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string2() }));
-var zGuardCreateElicitationRequestCustom = union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string2() }));
-var zGuardElicitationPropertySchemaString = zStringPropertySchema.and(object({ type: literal("string") }));
-var zGuardElicitationPropertySchemaNumber = zNumberPropertySchema.and(object({ type: literal("number") }));
-var zGuardElicitationPropertySchemaInteger = zIntegerPropertySchema.and(object({ type: literal("integer") }));
-var zGuardElicitationPropertySchemaBoolean = zBooleanPropertySchema.and(object({ type: literal("boolean") }));
-var zGuardElicitationPropertySchemaArray = zMultiSelectPropertySchema.and(object({ type: literal("array") }));
-var zGuardMultiSelectItemsString = zStringMultiSelectItems.and(object({ type: literal("string") }));
-var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
-var zGuardCreateElicitationResponseDecline = object({
-  action: literal("decline")
-});
-var zGuardCreateElicitationResponseCancel = object({
-  action: literal("cancel")
-});
-var CreateElicitationResponse = {
-  /** Narrow to the `accept` variant, validating its payload. */
-  isAccept(value) {
-    return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
-  },
-  /** Narrow to the `decline` variant, validating its payload. */
-  isDecline(value) {
-    return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
-  },
-  /** Narrow to the `cancel` variant, validating its payload. */
-  isCancel(value) {
-    return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
-  },
-  /**
-   * Narrow to a custom or future variant: the `action` tag matches no known variant.
-   *
-   * TypeScript keeps the known variants in the narrowed union (they are
-   * structural subtypes of the catch-all), so read vendor payload keys
-   * via a widening cast: `(value as Record<string, unknown>).someKey`.
-   */
-  isCustom(value) {
-    const tag = tagOf(value, "action");
-    return typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag);
-  }
-};
-
 // node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
 var CANCEL_REQUEST_METHOD = "$/cancel_request";
+function isRequestMessage(value) {
+  return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
+}
+function isResponseMessage(value) {
+  if (!isJsonRpcEnvelope(value) || "method" in value) {
+    return false;
+  }
+  if (!("id" in value) || !isJsonRpcId(value["id"])) {
+    return false;
+  }
+  const hasResult = Object.hasOwn(value, "result");
+  const hasError = Object.hasOwn(value, "error");
+  if (hasResult === hasError) {
+    return false;
+  }
+  return !hasError || isErrorResponse(value["error"]);
+}
+function isNotificationMessage(value) {
+  return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
+function isJsonRpcEnvelope(value) {
+  return isRecord(value) && value["jsonrpc"] === "2.0";
+}
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
+function isResponseShapedMessage(value) {
+  return isRecord(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
+}
+function isResponseBatch(batch) {
+  let hasValidCall = false;
+  let hasValidResponse = false;
+  let hasCallShape = false;
+  let hasResponseShape = false;
+  for (const entry of batch) {
+    hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
+    hasValidResponse ||= isResponseMessage(entry);
+    if (!isRecord(entry)) {
+      continue;
+    }
+    hasCallShape ||= "method" in entry;
+    hasResponseShape ||= "result" in entry || "error" in entry;
+  }
+  if (hasValidCall) {
+    return false;
+  }
+  if (hasValidResponse) {
+    return true;
+  }
+  return hasResponseShape && !hasCallShape;
+}
 function cancelRequestId(params) {
   if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
 }
+function isErrorResponse(value) {
+  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+}
 var Handled = {
   /**
    * Marks a message as handled.
@@ -20135,6 +20142,12 @@ var ConnectionContext = class {
   sendNotification(method, params) {
     return this.connection.sendNotification(method, params);
   }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   */
+  sendBatch(entries) {
+    return this.connection.sendBatch(entries);
+  }
   /**
    * Sends a protocol-level request cancellation notification.
    */
@@ -20173,6 +20186,7 @@ var Connection = class {
   retryQueue = [];
   context = new ConnectionContext(this);
   receiveReader;
+  allowBatches = true;
   constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
     if (typeof requestHandlerOrStream === "function") {
       const requestHandler = requestHandlerOrStream;
@@ -20181,16 +20195,13 @@ var Connection = class {
       this.initialize(stream2, [
         ...options?.handlers ?? [],
         this.legacyHandler(requestHandler, notificationHandler)
-      ]);
+      ], options);
       return;
     }
     const stream = requestHandlerOrStream;
     const handlers = notificationHandlerOrHandlers;
     const connectionOptions = streamOrOptions;
-    this.initialize(stream, [
-      ...connectionOptions?.handlers ?? [],
-      ...handlers
-    ]);
+    this.initialize(stream, [...connectionOptions?.handlers ?? [], ...handlers], connectionOptions);
   }
   /**
    * Creates a builder for configuring a handler-based connection.
@@ -20264,15 +20275,89 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
+    const request = this.prepareRequest(method, params, mapResponse, options);
+    const requestSent = this.sendWireMessage(request.message);
+    void requestSent.catch(() => {
+    });
+    if (options.cancellationSignal?.aborted) {
+      request.cancel();
+    }
+    return request.response;
+  }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   *
+   * Requests and notifications are processed independently by the peer. The
+   * returned tuple preserves the input order: request entries resolve to their
+   * mapped response, while notification entries resolve to `undefined`.
+   */
+  sendBatch(entries) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    if (!this.allowBatches) {
+      return rejectedPromise(new TypeError("JSON-RPC batches are not supported on this connection"));
+    }
+    if (entries.length === 0) {
+      return rejectedPromise(new TypeError("JSON-RPC batch must contain at least one entry"));
+    }
+    const messages = [];
+    const cancellations = [];
+    const outputs = [];
+    for (const entry of entries) {
+      if (entry.kind === "notification") {
+        messages.push({
+          jsonrpc: "2.0",
+          method: entry.method,
+          params: entry.params
+        });
+        outputs.push(Promise.resolve(void 0));
+        continue;
+      }
+      const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
+      messages.push(request.message);
+      outputs.push(request.response);
+      cancellations.push({
+        signal: entry.options?.cancellationSignal,
+        cancel: request.cancel
+      });
+    }
+    const batch = messages;
+    const batchSent = this.sendWireMessage(batch);
+    for (const cancellation of cancellations) {
+      if (cancellation.signal?.aborted) {
+        cancellation.cancel();
+      }
+    }
+    const response = Promise.all([batchSent, ...outputs]).then(([, ...resolved]) => resolved);
+    response.catch(() => {
+    });
+    return response;
+  }
+  /**
+   * Sends a protocol-level request cancellation notification.
+   */
+  sendCancelRequest(requestId) {
+    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
+  }
+  /**
+   * Sends a JSON-RPC notification.
+   */
+  sendNotification(method, params) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    return this.sendWireMessage({ jsonrpc: "2.0", method, params });
+  }
+  prepareRequest(method, params, mapResponse, options = {}) {
     const id = this.nextRequestId++;
     let cancel = () => {
     };
-    const responsePromise = new Promise((resolve, reject) => {
+    const response = new Promise((resolve, reject) => {
       const pendingResponse = {
-        resolve: (response) => {
+        resolve: (value) => {
           try {
-            const value = mapResponse ? mapResponse(response) : response;
-            resolve(value);
+            resolve(mapResponse ? mapResponse(value) : value);
           } catch (error51) {
             reject(error51);
           }
@@ -20296,35 +20381,13 @@ var Connection = class {
       };
       this.pendingResponses.set(id, pendingResponse);
     });
-    responsePromise.catch(() => {
-    });
-    const requestSent = this.sendMessage({
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
+    response.catch(() => {
     });
-    void requestSent.catch(() => {
-    });
-    if (options.cancellationSignal?.aborted) {
-      cancel();
-    }
-    return responsePromise;
-  }
-  /**
-   * Sends a protocol-level request cancellation notification.
-   */
-  sendCancelRequest(requestId) {
-    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
-  }
-  /**
-   * Sends a JSON-RPC notification.
-   */
-  sendNotification(method, params) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    return this.sendMessage({ jsonrpc: "2.0", method, params });
+    return {
+      message: { jsonrpc: "2.0", id, method, params },
+      response,
+      cancel: () => cancel()
+    };
   }
   /**
    * Closes the connection and rejects pending requests.
@@ -20347,9 +20410,10 @@ var Connection = class {
     void this.receiveReader?.cancel(closeError).catch(() => {
     });
   }
-  initialize(stream, handlers) {
+  initialize(stream, handlers, options) {
     this.stream = stream;
     this.staticHandlers = handlers;
+    this.allowBatches = options?.allowBatches ?? true;
     this.closedPromise = new Promise((resolve) => {
       this.abortController.signal.addEventListener("abort", () => resolve());
     });
@@ -20385,7 +20449,7 @@ var Connection = class {
           if (!message) {
             continue;
           }
-          this.receiveMessage(message);
+          this.receiveWireMessage(message);
         }
       } finally {
         if (this.receiveReader === reader) {
@@ -20399,24 +20463,93 @@ var Connection = class {
       this.close(closeError);
     }
   }
-  receiveMessage(message) {
-    if (this.abortController.signal.aborted) {
+  receiveWireMessage(message) {
+    if (Array.isArray(message)) {
+      if (!this.allowBatches) {
+        this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
+        return;
+      }
+      this.receiveBatch(message);
       return;
     }
     if (!isRecord(message)) {
       console.error("Invalid message", { message });
       return;
     }
+    this.receiveMessage(message);
+  }
+  receiveBatch(batch) {
+    if (batch.length === 0) {
+      void this.sendWireMessage({
+        jsonrpc: "2.0",
+        id: null,
+        error: RequestError.invalidRequest(batch).toErrorResponse()
+      }).catch(() => {
+      });
+      return;
+    }
+    const responseBatch = isResponseBatch(batch);
+    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
+    let remaining = responseCount;
+    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
+    let responseSent = false;
+    const responses = [];
+    const sendResponsesIfReady = async () => {
+      if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
+        return;
+      }
+      responseSent = true;
+      await this.sendWireMessage(responses);
+    };
+    const collectResponse = async (response) => {
+      responses.push(response);
+      remaining -= 1;
+      await sendResponsesIfReady();
+    };
+    for (const message of batch) {
+      if (responseBatch) {
+        if (isResponseShapedMessage(message)) {
+          this.receiveMessage(message);
+        }
+        continue;
+      }
+      if (!isRequestMessage(message) && !isNotificationMessage(message)) {
+        void collectResponse({
+          jsonrpc: "2.0",
+          id: null,
+          error: RequestError.invalidRequest(message).toErrorResponse()
+        }).catch(() => {
+        });
+        continue;
+      }
+      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0);
+      if (isNotificationMessage(message)) {
+        void processing.finally(() => {
+          remainingNotifications -= 1;
+          void sendResponsesIfReady().catch((error51) => this.close(error51));
+        });
+      }
+    }
+  }
+  receiveMessage(message, sendResponse) {
+    if (this.abortController.signal.aborted) {
+      return Promise.resolve();
+    }
+    if (!isRecord(message)) {
+      console.error("Invalid message", { message });
+      return Promise.resolve();
+    }
     if ("method" in message) {
       if (!("id" in message)) {
         this.handleProtocolNotification(message);
       }
-      void this.processIncomingMessage(this.toIncomingMessage(message)).catch((error51) => this.close(error51));
+      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse)).catch((error51) => this.close(error51));
     } else if ("id" in message) {
       this.handleResponse(message);
     } else {
       console.error("Invalid message", { message });
     }
+    return Promise.resolve();
   }
   async processIncomingMessage(message) {
     if (this.abortController.signal.aborted) {
@@ -20460,7 +20593,7 @@ var Connection = class {
       }
     }
   }
-  toIncomingMessage(message) {
+  toIncomingMessage(message, sendResponse) {
     if ("id" in message) {
       const abortController = new AbortController();
       this.incomingRequests.set(message.id, abortController);
@@ -20475,11 +20608,14 @@ var Connection = class {
         params: message.params,
         raw: message,
         signal: abortController.signal,
-        responder: new RequestResponder(message.id, (result) => this.sendMessage({
-          jsonrpc: "2.0",
-          id: message.id,
-          ...result
-        }), abortController.signal, finishRequest)
+        responder: new RequestResponder(message.id, (result) => {
+          const response = {
+            jsonrpc: "2.0",
+            id: message.id,
+            ...result
+          };
+          return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
+        }, abortController.signal, finishRequest)
       };
     }
     return {
@@ -20494,13 +20630,13 @@ var Connection = class {
     if (pendingResponse) {
       this.pendingResponses.delete(response.id);
       pendingResponse.cleanup?.();
-      if ("result" in response) {
+      if (!isResponseMessage(response)) {
+        pendingResponse.reject(RequestError.invalidRequest(response));
+      } else if ("result" in response) {
         pendingResponse.resolve(response.result);
-      } else if ("error" in response && isRecord(response.error)) {
+      } else {
         const { code, message, data } = response.error;
         pendingResponse.reject(new RequestError(code, message, data));
-      } else {
-        pendingResponse.reject(RequestError.invalidRequest(response));
       }
     } else {
       console.error("Got response to unknown request", response.id);
@@ -20523,7 +20659,7 @@ var Connection = class {
   closedReason() {
     return this.abortController.signal.reason ?? new Error("ACP connection closed");
   }
-  async sendMessage(message) {
+  async sendWireMessage(message) {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
@@ -20769,7 +20905,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord(message)) {
+            if (isRecord(message) || Array.isArray(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -20843,7 +20979,56 @@ function ndJsonStream(output, input) {
   return { readable, writable };
 }
 
+// node_modules/@agentclientprotocol/sdk/dist/schema/guards.gen.js
+function tagOf(value, key) {
+  return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+var zGuardCreateElicitationRequestForm = zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string2() }));
+var zGuardCreateElicitationRequestUrl = zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string2() }));
+var zGuardCreateElicitationRequestCustom = union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string2() }));
+var zGuardElicitationPropertySchemaString = zStringPropertySchema.and(object({ type: literal("string") }));
+var zGuardElicitationPropertySchemaNumber = zNumberPropertySchema.and(object({ type: literal("number") }));
+var zGuardElicitationPropertySchemaInteger = zIntegerPropertySchema.and(object({ type: literal("integer") }));
+var zGuardElicitationPropertySchemaBoolean = zBooleanPropertySchema.and(object({ type: literal("boolean") }));
+var zGuardElicitationPropertySchemaArray = zMultiSelectPropertySchema.and(object({ type: literal("array") }));
+var zGuardMultiSelectItemsString = zStringMultiSelectItems.and(object({ type: literal("string") }));
+var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
+var zGuardCreateElicitationResponseDecline = object({
+  action: literal("decline")
+});
+var zGuardCreateElicitationResponseCancel = object({
+  action: literal("cancel")
+});
+var CreateElicitationResponse = {
+  /** Narrow to the `accept` variant, validating its payload. */
+  isAccept(value) {
+    return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
+  },
+  /** Narrow to the `decline` variant, validating its payload. */
+  isDecline(value) {
+    return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
+  },
+  /** Narrow to the `cancel` variant, validating its payload. */
+  isCancel(value) {
+    return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
+  },
+  /**
+   * Narrow to a custom or future variant: the `action` tag matches no known variant.
+   *
+   * TypeScript keeps the known variants in the narrowed union (they are
+   * structural subtypes of the catch-all), so read vendor payload keys
+   * via a widening cast: `(value as Record<string, unknown>).someKey`.
+   */
+  isCustom(value) {
+    const tag = tagOf(value, "action");
+    return typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag);
+  }
+};
+
 // node_modules/@agentclientprotocol/sdk/dist/acp.js
+function ndJsonStream2(output, input) {
+  return ndJsonStream(output, input);
+}
 function emptyObjectResponse(response) {
   return response ?? {};
 }
@@ -21505,6 +21690,7 @@ function runConnectHandlers(connection, handlers) {
 var appBuilder = /* @__PURE__ */ Symbol("appBuilder");
 var runAgentConnectHandlers = /* @__PURE__ */ Symbol("runAgentConnectHandlers");
 var runClientConnectHandlers = /* @__PURE__ */ Symbol("runClientConnectHandlers");
+var stableConnectionOptions = { allowBatches: false };
 function agent(options) {
   return new AgentApp(options);
 }
@@ -21578,7 +21764,7 @@ var AgentApp = class {
       return state2;
     }
     const [thisStream, peerStream] = memoryStreamPair();
-    const peerRawConnection = target[appBuilder]().connect(peerStream);
+    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
     const peerConnection = clientConnection(peerRawConnection);
     const state = this.openStreamConnection(thisStream);
     void state.rawConnection.closed.then(() => peerConnection.close());
@@ -21594,7 +21780,7 @@ var AgentApp = class {
     return state;
   }
   openStreamConnection(stream) {
-    const rawConnection = this.builder.connect(stream);
+    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
     return {
       rawConnection,
       connection: agentConnection(rawConnection, this.connectHandlers)
@@ -21673,7 +21859,7 @@ var ClientApp = class {
       return state2;
     }
     const [thisStream, peerStream] = memoryStreamPair();
-    const peerRawConnection = target[appBuilder]().connect(peerStream);
+    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
     const peerConnection = agentConnection(peerRawConnection);
     const state = this.openStreamConnection(thisStream);
     void state.rawConnection.closed.then(() => peerConnection.close());
@@ -21689,7 +21875,7 @@ var ClientApp = class {
     return state;
   }
   openStreamConnection(stream) {
-    const rawConnection = this.builder.connect(stream);
+    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
     return {
       rawConnection,
       connection: clientConnection(rawConnection, this.connectHandlers)
@@ -21811,7 +21997,7 @@ function createJSONRPCReader(readable) {
 function createJsonStream(readable, writable) {
   const input = Writable.toWeb(writable);
   const output = Readable.toWeb(readable);
-  return ndJsonStream(input, output);
+  return ndJsonStream2(input, output);
 }
 
 // src/Logger.ts
@@ -22858,7 +23044,7 @@ function createWebSearchStartUpdate(item) {
     kind: "search",
     title: formatWebSearchTitle(item),
     status: "in_progress",
-    rawInput: item
+    rawInput: createWebSearchRawInput(item)
   };
 }
 function createWebSearchCompleteUpdate(item) {
@@ -22867,7 +23053,15 @@ function createWebSearchCompleteUpdate(item) {
     toolCallId: item.id,
     title: formatWebSearchTitle(item),
     status: "completed",
-    rawInput: item
+    rawInput: createWebSearchRawInput(item)
+  };
+}
+function createWebSearchRawInput(item) {
+  return {
+    type: item.type,
+    id: item.id,
+    query: item.query,
+    action: item.action
   };
 }
 function createCollabAgentToolCallUpdate(item) {
@@ -23364,9 +23558,10 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
 
 // src/AcpExtensions.ts
 var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
+var SESSION_STEERING_METHOD = "_session/steering";
 var GOAL_CONTROL_METHOD = "_codex/session/goal_control";
 function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD;
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
 }
 
 // src/ThreadGoalSnapshot.ts
@@ -23390,23 +23585,32 @@ function sameThreadGoalSnapshot(left, right) {
 var CodexEventHandler = class {
   connection;
   sessionState;
+  supportsPlanUpdates;
   failure = null;
+  completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
   activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
   activeImageGenerationItems = /* @__PURE__ */ new Set();
   emittedImageViewItems = /* @__PURE__ */ new Set();
+  planDeltaTextByItemId = /* @__PURE__ */ new Map();
   seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   activeSubAgentActivities = /* @__PURE__ */ new Set();
-  constructor(connection, sessionState) {
+  constructor(connection, sessionState, supportsPlanUpdates = false) {
     this.connection = connection;
     this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
   }
   getFailure() {
     return this.failure;
   }
+  takeCompletedPlan() {
+    const plan = this.completedPlan;
+    this.completedPlan = null;
+    return plan;
+  }
   async handleNotification(notification) {
     const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
     const updateEvent = await this.createUpdateEvent(notification);
@@ -23418,6 +23622,8 @@ var CodexEventHandler = class {
     switch (notification.method) {
       case "item/agentMessage/delta":
         return await this.createTextEvent(notification.params);
+      case "item/plan/delta":
+        return this.createPlanDeltaEvent(notification.params);
       case "item/started":
         return await this.createItemEvent(notification.params);
       case "item/completed":
@@ -23496,6 +23702,8 @@ var CodexEventHandler = class {
         return this.createTerminalInteractionEvent(notification.params);
       // ignored events
       case "thread/deleted":
+      case "thread/environment/connected":
+      case "thread/environment/disconnected":
       case "command/exec/outputDelta":
       case "hook/started":
       case "hook/completed":
@@ -23525,8 +23733,8 @@ var CodexEventHandler = class {
       case "mcpServer/oauthLogin/completed":
       case "externalAgentConfig/import/completed":
       case "rawResponseItem/completed":
+      case "rawResponse/completed":
       case "thread/started":
-      case "item/plan/delta":
       case "remoteControl/status/changed":
       case "app/list/updated":
       case "thread/settings/updated":
@@ -23591,6 +23799,15 @@ ${event.details}` : "";
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent(event.delta, event.itemId);
   }
+  createPlanDeltaEvent(event) {
+    if (event.delta.length === 0) {
+      return null;
+    }
+    const text = this.planDeltaTextByItemId.get(event.itemId) ?? "";
+    const updatedText = text + event.delta;
+    this.planDeltaTextByItemId.set(event.itemId, updatedText);
+    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(updatedText, event.itemId) : null;
+  }
   createReasoningSectionBreakEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent("\n\n", event.itemId);
@@ -23684,6 +23901,11 @@ ${event.details}` : "";
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
+      case "plan": {
+        const deltaText = this.planDeltaTextByItemId.get(event.item.id) ?? "";
+        this.planDeltaTextByItemId.delete(event.item.id);
+        return this.createCompletedPlanEvent(event.item, deltaText);
+      }
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
@@ -23697,7 +23919,6 @@ ${event.details}` : "";
       case "userMessage":
       case "hookPrompt":
       case "enteredReviewMode":
-      case "plan":
         return null;
     }
   }
@@ -23712,6 +23933,31 @@ ${event.details}` : "";
     }
     return this.createAgentThoughtEvent(text, item.id);
   }
+  createCompletedPlanEvent(item, deltaText) {
+    const text = item.text.length > 0 ? item.text : deltaText;
+    if (text.length === 0) {
+      return null;
+    }
+    this.completedPlan = { itemId: item.id, text };
+    return this.supportsPlanUpdates ? this.createPlanUpdateEvent(text, item.id) : this.createPlanTextEvent(text, item.id);
+  }
+  createPlanUpdateEvent(text, planId) {
+    return {
+      sessionUpdate: "plan_update",
+      plan: {
+        type: "markdown",
+        planId,
+        content: text
+      }
+    };
+  }
+  createPlanTextEvent(text, messageId) {
+    return createAgentTextMessageChunk(
+      text,
+      messageId,
+      createCodexMessagePhaseMeta("final_answer")
+    );
+  }
   createExitedReviewModeEvent(item) {
     const text = item.review.trim();
     if (text.length === 0) {
@@ -23956,12 +24202,17 @@ var ApprovalOptionId = {
 };
 
 // src/CodexApprovalHandler.ts
-function permissionOption(optionId, name, kind, codexMeta) {
+function permissionOption(optionId, name, kind, codexMeta, permission) {
   return {
     optionId,
     name,
     kind,
-    ...codexMeta ? { _meta: { codex: codexMeta } } : {}
+    ...codexMeta || permission ? {
+      _meta: {
+        ...permission ? { permission } : {},
+        ...codexMeta ? { codex: codexMeta } : {}
+      }
+    } : {}
   };
 }
 var CodexApprovalHandler = class {
@@ -24068,13 +24319,15 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowPermissionsForSession,
           "Allow for Session",
           "allow_always",
-          { decision: "allowPermissionsForSession", permissions: params.permissions }
+          { decision: "allowPermissionsForSession", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "session")
         ),
         permissionOption(
           ApprovalOptionId.AllowPermissionsForTurn,
           "Allow Once",
           "allow_once",
-          { decision: "allowPermissionsForTurn", permissions: params.permissions }
+          { decision: "allowPermissionsForTurn", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "turn")
         ),
         permissionOption(
           ApprovalOptionId.RejectPermissions,
@@ -24136,7 +24389,24 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.networkApprovalContext ? "Allow Host for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession" }
+          { decision: "acceptForSession" },
+          params.networkApprovalContext ? {
+            version: 1,
+            changes: [{
+              type: "grant",
+              operation: "grant",
+              description: `Allow access to ${params.networkApprovalContext.host} for this session`,
+              lifetime: { scope: "session" },
+              targets: [{
+                type: "network",
+                matcher: {
+                  type: "host",
+                  host: params.networkApprovalContext.host,
+                  protocol: params.networkApprovalContext.protocol
+                }
+              }]
+            }]
+          } : void 0
         ),
         decision: "acceptForSession"
       }
@@ -24150,6 +24420,22 @@ var CodexApprovalHandler = class {
           {
             decision: "acceptWithExecpolicyAmendment",
             execpolicyAmendment: params.proposedExecpolicyAmendment
+          },
+          {
+            version: 1,
+            changes: [{
+              type: "policy_rule",
+              operation: "add",
+              ruleBehavior: "allow",
+              description: `Allow commands starting with ${params.proposedExecpolicyAmendment.join(" ")}`,
+              targets: [{
+                type: "command",
+                matcher: {
+                  type: "argv_prefix",
+                  argv: params.proposedExecpolicyAmendment
+                }
+              }]
+            }]
           }
         ),
         decision: {
@@ -24168,6 +24454,22 @@ var CodexApprovalHandler = class {
           {
             decision: "applyNetworkPolicyAmendment",
             networkPolicyAmendment: amendment
+          },
+          {
+            version: 1,
+            changes: [{
+              type: "policy_rule",
+              operation: "add",
+              ruleBehavior: amendment.action,
+              description: amendment.action === "allow" ? `Allow access to ${amendment.host}` : `Block access to ${amendment.host}`,
+              targets: [{
+                type: "network",
+                matcher: {
+                  type: "host",
+                  host: amendment.host
+                }
+              }]
+            }]
           }
         ),
         decision: {
@@ -24194,7 +24496,21 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.grantRoot ? "Allow Root for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null }
+          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null },
+          params.grantRoot ? {
+            version: 1,
+            changes: [{
+              type: "grant",
+              operation: "grant",
+              description: `Allow writes under ${params.grantRoot} for this session`,
+              lifetime: { scope: "session" },
+              targets: [{
+                type: "filesystem",
+                access: ["write"],
+                matcher: { type: "directory", path: params.grantRoot }
+              }]
+            }]
+          } : void 0
         ),
         decision: "acceptForSession"
       },
@@ -24217,6 +24533,68 @@ var CodexApprovalHandler = class {
       ...permissions.fileSystem ? { fileSystem: permissions.fileSystem } : {}
     };
   }
+  permissionGrantMetadata(permissions, scope) {
+    const changes = [];
+    const lifetime = { scope };
+    const suffix = scope === "session" ? " for this session" : " for this turn";
+    if (permissions.network?.enabled !== null && permissions.network?.enabled !== void 0) {
+      const allowed = permissions.network.enabled;
+      changes.push({
+        type: allowed ? "grant" : "policy_rule",
+        operation: allowed ? "grant" : "add",
+        ...allowed ? {} : { ruleBehavior: "deny" },
+        description: `${allowed ? "Allow" : "Deny"} network access${suffix}`,
+        lifetime,
+        targets: [{ type: "network", matcher: { type: "any" } }]
+      });
+    }
+    const fileSystem = permissions.fileSystem;
+    for (const path6 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "read", lifetime, suffix));
+    }
+    for (const path6 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "write", lifetime, suffix));
+    }
+    for (const entry of fileSystem?.entries ?? []) {
+      const matcher = (() => {
+        switch (entry.path.type) {
+          case "path":
+            return { type: "exact_path", path: entry.path.path };
+          case "glob_pattern":
+            return { type: "glob", pattern: entry.path.pattern };
+          case "special":
+            return { type: "special", provider: "codex", value: entry.path.value };
+        }
+      })();
+      const pathDescription = entry.path.type === "path" ? entry.path.path : entry.path.type === "glob_pattern" ? entry.path.pattern : JSON.stringify(entry.path.value);
+      changes.push({
+        type: entry.access === "deny" ? "policy_rule" : "grant",
+        operation: entry.access === "deny" ? "add" : "grant",
+        ...entry.access === "deny" ? { ruleBehavior: "deny" } : {},
+        description: entry.access === "deny" ? `Deny filesystem access to ${pathDescription}${suffix}` : `Allow ${entry.access} access to ${pathDescription}${suffix}`,
+        lifetime,
+        targets: [{
+          type: "filesystem",
+          ...entry.access === "deny" ? {} : { access: [entry.access] },
+          matcher
+        }]
+      });
+    }
+    return changes.length > 0 ? { version: 1, changes } : void 0;
+  }
+  fileSystemGrantChange(path6, access, lifetime, suffix) {
+    return {
+      type: "grant",
+      operation: "grant",
+      description: `Allow ${access} access to ${path6}${suffix}`,
+      lifetime,
+      targets: [{
+        type: "filesystem",
+        access: [access],
+        matcher: { type: "exact_path", path: path6 }
+      }]
+    };
+  }
   networkPolicyAmendmentOptionId(index) {
     return `${ApprovalOptionId.ApplyNetworkPolicyAmendment}:${index}`;
   }
@@ -25687,7 +26065,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.5",
+  version: "1.1.8",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -25717,11 +26095,13 @@ var package_default = {
     "package:win-x64": "cd dist/bin && zip codex-acp-x64-windows.zip codex-acp-x64-windows.exe",
     "package:win-arm64": "cd dist/bin && zip codex-acp-arm64-windows.zip codex-acp-arm64-windows.exe",
     start: "node --import tsx src/index.ts",
+    "example:steering": "node --import tsx examples/steering.ts",
+    "example:steering:multistep": "node --import tsx examples/steering.ts",
     "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
     test: "vitest run",
     "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run src/__tests__/CodexACPAgent/e2e",
     "test:watch": "vitest",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsc --noEmit && tsc --noEmit -p examples/tsconfig.json",
     "codex-test": "tsx .claude/skills/run-codex/scripts/run-codex-test.ts"
   },
   homepage: "https://github.com/agentclientprotocol/codex-acp#readme",
@@ -25740,13 +26120,13 @@ var package_default = {
     "@types/node": "^26.1.0",
     esbuild: "^0.28.1",
     "mcp-hello-world": "^1.1.2",
-    tsx: "^4.23.0",
-    typescript: "^6.0.3",
+    tsx: "^4.23.1",
+    typescript: "^7.0.2",
     vitest: "^4.1.10"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^1.2.1",
-    "@openai/codex": "^0.144.6",
+    "@agentclientprotocol/sdk": "^1.3.0",
+    "@openai/codex": "^0.145.0",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
@@ -26438,6 +26818,13 @@ var CodexAcpClient = class {
       turnId: params.turnId
     });
   }
+  async steerTurn(params) {
+    return await this.codexClient.turnSteer({
+      threadId: params.threadId,
+      expectedTurnId: params.turnId,
+      input: buildPromptItems(params.prompt)
+    });
+  }
   async fetchAvailableModels() {
     const models = [];
     let cursor = null;
@@ -27116,6 +27503,47 @@ var CodexCommands = class {
   }
 };
 
+// src/SteeringQueue.ts
+var SteeringQueue = class {
+  constructor(handle) {
+    this.handle = handle;
+  }
+  handle;
+  pending = [];
+  processing = false;
+  enqueue(params) {
+    return new Promise((resolve, reject) => {
+      this.pending.push({ params, resolve, reject });
+      this.startConsumer();
+    });
+  }
+  /** No request is queued and the consumer is not running. */
+  get isIdle() {
+    return !this.processing && this.pending.length === 0;
+  }
+  startConsumer() {
+    if (this.processing) {
+      return;
+    }
+    this.processing = true;
+    void this.consume();
+  }
+  async consume() {
+    try {
+      while (this.pending.length > 0) {
+        const next = this.pending.shift();
+        try {
+          next.resolve(await this.handle(next.params));
+        } catch (error51) {
+          next.reject(error51);
+        }
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+};
+
 // src/ResponseItemHistoryFallback.ts
 import { readFile as readFile2 } from "node:fs/promises";
 import path5 from "node:path";
@@ -28137,7 +28565,14 @@ function isJetBrains2026_1Client(clientInfo) {
   return (isIntelliJPlatform || isJetBrainsClient) && clientInfo.version.startsWith("2026.1");
 }
 
+// src/PlanCapabilities.ts
+function clientSupportsPlanUpdates(clientCapabilities) {
+  return clientCapabilities?.plan != null;
+}
+
 // src/CodexAcpServer.ts
+var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
+var REVISE_PLAN_OPTION_ID = "revise_plan";
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
     gpt: "GPT",
@@ -28158,6 +28593,7 @@ var CodexAcpServer = class _CodexAcpServer {
   pendingMcpStartupSessions;
   pendingTurnStarts;
   activePrompts;
+  steeringQueues;
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
@@ -28166,6 +28602,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
     this.pendingTurnStarts = /* @__PURE__ */ new Map();
     this.activePrompts = /* @__PURE__ */ new Map();
+    this.steeringQueues = /* @__PURE__ */ new Map();
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
@@ -28222,7 +28659,12 @@ var CodexAcpServer = class _CodexAcpServer {
           sse: false
         }
       },
-      authMethods: getCodexAuthMethods(_params.clientCapabilities)
+      authMethods: getCodexAuthMethods(_params.clientCapabilities),
+      _meta: {
+        steering: {
+          supported: true
+        }
+      }
     };
   }
   async extMethod(method, params) {
@@ -28239,6 +28681,8 @@ var CodexAcpServer = class _CodexAcpServer {
       }
       case LEGACY_SET_SESSION_MODEL_METHOD:
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
+      case SESSION_STEERING_METHOD:
+        return await this.executeOrQueueSteeringRequest(this.parseSessionSteerParams(methodRequest.params));
       case GOAL_CONTROL_METHOD: {
         const sessionState = this.sessions.get(methodRequest.params.sessionId);
         if (!sessionState) {
@@ -28545,6 +28989,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.pendingMcpStartupSessions.delete(params.sessionId);
         this.pendingTurnStarts.delete(params.sessionId);
         this.activePrompts.delete(params.sessionId);
+        this.steeringQueues.delete(params.sessionId);
       }
       this.endSessionCloseFence(params.sessionId);
     }
@@ -28765,6 +29210,199 @@ Check ${configPath} and project .codex directories, especially their config.toml
       modelId
     };
   }
+  /**
+   * Handles one incoming steering request, serialising it against any other
+   * steer already in flight for the same session.
+   *
+   * Every session gets its own {@link SteeringQueue}: the request is enqueued
+   * and awaited, so concurrent steers for one session run strictly one at a
+   * time, in arrival order, and can never race to inject into — or start —
+   * rival turns. Steers for different sessions use different queues and run
+   * concurrently. Once the queue drains to idle it is removed from the map,
+   * so no per-session entry leaks after the session goes quiet (the identity
+   * check guards against deleting a queue a later request has since reused).
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns Whether the prompt joined the active turn ("injected"), started a
+   *     new one ("startedNewTurn"), or could not be applied ("failed"); see
+   *     {@link performSteeringRequest}.
+   */
+  async executeOrQueueSteeringRequest(params) {
+    const queue = this.getSteeringQueue(params.sessionId);
+    try {
+      return await queue.enqueue(params);
+    } catch (error51) {
+      if (error51 instanceof RequestError) {
+        throw error51;
+      }
+      logger.error(`Steering request for session ${params.sessionId} failed`, error51);
+      return { outcome: "failed" };
+    } finally {
+      if (queue.isIdle && this.steeringQueues.get(params.sessionId) === queue) {
+        this.steeringQueues.delete(params.sessionId);
+      }
+    }
+  }
+  /**
+   * Returns the steering queue for a session, creating and registering it on
+   * first use.
+   *
+   * @param sessionId The session whose steering queue is required.
+   * @returns The session's existing queue, or a freshly created one.
+   */
+  getSteeringQueue(sessionId) {
+    let queue = this.steeringQueues.get(sessionId);
+    if (!queue) {
+      queue = new SteeringQueue((params) => this.performSteeringRequest(params));
+      this.steeringQueues.set(sessionId, queue);
+    }
+    return queue;
+  }
+  /**
+   * Delivers a steering prompt to the session: injects it into the live turn
+   * when there is one, otherwise starts a new turn.
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns "injected" when the prompt joined an existing turn, otherwise the
+   *     outcome of starting a new turn.
+   */
+  async performSteeringRequest(params) {
+    logger.log("Steering session requested", {
+      sessionId: params.sessionId,
+      prompt: params.prompt
+    });
+    const sessionState = this.getSessionState(params.sessionId);
+    this.assertSteerInputSupported(params, sessionState);
+    const turnId = await this.getSteerableTurnId(sessionState);
+    if (turnId) {
+      const injected = await this.injectSteerIntoActiveTurn(params, turnId, sessionState);
+      if (injected) {
+        logger.log("Steering session injected", { sessionId: params.sessionId, turnId });
+        return { outcome: "injected" };
+      }
+    }
+    return await this.startNewTurnFromSteering(params);
+  }
+  /**
+   * Rejects a steering prompt whose content the active model cannot accept
+   * (currently: image blocks on a text-only model).
+   */
+  assertSteerInputSupported(params, sessionState) {
+    const hasImage = params.prompt.some((block) => block.type === "image");
+    if (hasImage && !sessionState.supportedInputModalities.includes("image")) {
+      throw RequestError.invalidRequest("The current model does not support image input");
+    }
+  }
+  /**
+   * Attempts to inject the prompt into the given running turn.
+   *
+   * A failed injection is fatal only when the turn is still the session's
+   * current turn and Codex reported something other than "no active turn to
+   * steer". Otherwise the turn has already ended underneath us and the caller
+   * should start a new turn instead.
+   *
+   * @returns true when the prompt was injected; false when the caller should
+   *     fall back to starting a new turn.
+   */
+  async injectSteerIntoActiveTurn(params, turnId, sessionState) {
+    try {
+      await this.runWithProcessCheck(() => this.codexAcpClient.steerTurn({
+        threadId: params.sessionId,
+        turnId,
+        prompt: params.prompt
+      }));
+      return true;
+    } catch (err) {
+      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      const turnStillActive = sessionState.currentTurnId === turnId;
+      if (turnStillActive && !this.isNoActiveTurnToSteerError(err)) {
+        throw err;
+      }
+      return false;
+    }
+  }
+  /**
+   * Starts a new turn from a steering prompt when there is no live turn to
+   * inject into, and returns as soon as that turn is running.
+   *
+   * Waits for any previous prompt to drain first, then re-checks that the
+   * session is not closing — the await above is a window during which a close
+   * request can arrive.
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns "startedNewTurn" once the turn is running; throws if the prompt
+   *     fails or is cancelled before the turn starts.
+   */
+  async startNewTurnFromSteering(params) {
+    const previousPrompt = this.activePrompts.get(params.sessionId);
+    await previousPrompt?.completion;
+    if (this.sessionIsClosing(params.sessionId)) {
+      throw RequestError.invalidRequest(`Session ${params.sessionId} is closing`);
+    }
+    return await new Promise((resolve, reject) => {
+      let turnStarted = false;
+      const promptDone = this.prompt(params, void 0, () => {
+        turnStarted = true;
+        logger.log("Steering session started a new turn", { sessionId: params.sessionId });
+        resolve({ outcome: "startedNewTurn" });
+      });
+      promptDone.then(
+        (response) => {
+          if (!turnStarted && response.stopReason === "cancelled") {
+            reject(RequestError.invalidRequest(`Session ${params.sessionId} was cancelled before the steering turn started`));
+          } else {
+            resolve({ outcome: "startedNewTurn" });
+          }
+        },
+        (error51) => {
+          if (turnStarted) {
+            logger.error(`Steering-started prompt for session ${params.sessionId} failed`, error51);
+          } else {
+            reject(error51);
+          }
+        }
+      );
+    });
+  }
+  isNoActiveTurnToSteerError(error51) {
+    const messages = error51 instanceof Error ? [error51.message] : [];
+    if (typeof error51 === "object" && error51 !== null && "data" in error51) {
+      const data = error51.data;
+      if (typeof data === "string") {
+        messages.push(data);
+      } else if (typeof data === "object" && data !== null && "details" in data) {
+        const details = data.details;
+        if (typeof details === "string") {
+          messages.push(details);
+        }
+      }
+    }
+    return messages.some((message) => message.toLowerCase().includes("no active turn to steer"));
+  }
+  async getSteerableTurnId(sessionState) {
+    if (this.sessionIsClosing(sessionState.sessionId)) {
+      return null;
+    }
+    if (sessionState.currentTurnId) {
+      return sessionState.currentTurnId;
+    }
+    const pendingTurnStart = this.pendingTurnStarts.get(sessionState.sessionId);
+    if (!pendingTurnStart) {
+      return null;
+    }
+    return await pendingTurnStart.promise;
+  }
+  parseSessionSteerParams(params) {
+    const sessionId = params["sessionId"];
+    const prompt = params["prompt"];
+    if (typeof sessionId !== "string" || !Array.isArray(prompt)) {
+      throw RequestError.invalidParams();
+    }
+    return {
+      sessionId,
+      prompt
+    };
+  }
   createSessionConfigOptions(sessionState) {
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
     const configOptions = [
@@ -29053,7 +29691,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       case "contextCompaction":
         return [createCompletedContextCompactionUpdate(item)];
       case "plan":
-        return [this.createPlanUpdate(item)];
+        return item.text.length > 0 ? [this.createPlanHistoryUpdate(item)] : [];
     }
   }
   createUserMessageUpdates(item) {
@@ -29094,15 +29732,22 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
     };
   }
-  createPlanUpdate(item) {
-    return {
-      sessionUpdate: "agent_message_chunk",
-      content: {
-        type: "text",
-        text: `Plan:
-${item.text}`
-      }
-    };
+  createPlanHistoryUpdate(item) {
+    if (clientSupportsPlanUpdates(this.clientCapabilities)) {
+      return {
+        sessionUpdate: "plan_update",
+        plan: {
+          type: "markdown",
+          planId: item.id,
+          content: item.text
+        }
+      };
+    }
+    return createAgentTextMessageChunk(
+      item.text,
+      item.id,
+      createCodexMessagePhaseMeta("final_answer")
+    );
   }
   userInputToContentBlocks(input) {
     switch (input.type) {
@@ -29372,7 +30017,7 @@ ${item.text}`
     }
     return turnId;
   }
-  async prompt(params, signal) {
+  async prompt(params, signal, onTurnStarted) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
       prompt: params.prompt
@@ -29391,7 +30036,11 @@ ${item.text}`
     };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     try {
-      const eventHandler = new CodexEventHandler(this.connection, sessionState);
+      const eventHandler = new CodexEventHandler(
+        this.connection,
+        sessionState,
+        clientSupportsPlanUpdates(this.clientCapabilities)
+      );
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
@@ -29424,6 +30073,7 @@ ${item.text}`
           }
           sessionState.currentTurnId = turnId;
           pendingTurnStart?.resolve(turnId);
+          onTurnStarted?.();
         },
         setConfigOption: async (configId, value) => {
           await this.applySessionConfigOption(sessionState, {
@@ -29507,6 +30157,7 @@ ${item.text}`
             }
             sessionState.currentTurnId = turnId;
             pendingTurnStart?.resolve(turnId);
+            onTurnStarted?.();
           },
           () => this.promptShouldStop(params.sessionId, activePrompt)
         )
@@ -29516,7 +30167,7 @@ ${item.text}`
           logger.error(`Prompt for cancelled session ${params.sessionId} failed after prompt returned`, err);
         }
       });
-      const turnCompleted = await Promise.race([
+      let turnCompleted = await Promise.race([
         sendPromptPromise,
         activePrompt.closeSignal,
         this.cancelBeforeTurnStarted(activePrompt)
@@ -29533,6 +30184,73 @@ ${item.text}`
       if (error51) {
         throw error51;
       }
+      const completedPlan = eventHandler.takeCompletedPlan();
+      if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
+        const approved = await this.requestPlanImplementationPermission(
+          sessionState,
+          completedPlan,
+          activePrompt.signal
+        );
+        if (this.promptShouldStop(params.sessionId, activePrompt)) {
+          return this.cancelledPromptResponse(sessionState);
+        }
+        if (approved && !this.promptShouldStop(params.sessionId, activePrompt)) {
+          await this.applyCollaborationModeChange(sessionState, DEFAULT_COLLABORATION_MODE);
+          const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+          await session.update({
+            sessionUpdate: "config_option_update",
+            configOptions: this.createSessionConfigOptions(sessionState)
+          });
+          const implementationRequest = {
+            sessionId: params.sessionId,
+            prompt: [{ type: "text", text: "Implement the approved plan." }]
+          };
+          activePrompt.currentTurn = null;
+          const implementationPromise = this.runWithProcessCheck(
+            () => this.codexAcpClient.sendPrompt(
+              implementationRequest,
+              agentMode,
+              modelId,
+              serviceTier,
+              disableSummary,
+              sessionState.cwd,
+              sessionState.additionalDirectories,
+              (turnId) => {
+                const turn = { threadId: params.sessionId, turnId };
+                activePrompt.currentTurn = turn;
+                if (this.promptShouldStop(params.sessionId, activePrompt)) {
+                  this.interruptLateStartedTurn(turn);
+                  return;
+                }
+                sessionState.currentTurnId = turnId;
+              },
+              () => this.promptShouldStop(params.sessionId, activePrompt)
+            )
+          );
+          void implementationPromise.catch((err) => {
+            if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+              logger.error(`Implementation turn for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
+            }
+          });
+          turnCompleted = await Promise.race([
+            implementationPromise,
+            activePrompt.closeSignal,
+            this.cancelBeforeTurnStarted(activePrompt)
+          ]);
+          if (turnCompleted === null) {
+            return this.cancelledPromptResponse(sessionState);
+          }
+          await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          if (turnCompleted.turn.status === "interrupted") {
+            await this.notifyConversationInterrupted(params.sessionId);
+            return this.cancelledPromptResponse(sessionState);
+          }
+          const implementationError = eventHandler.getFailure();
+          if (implementationError) {
+            throw implementationError;
+          }
+        }
+      }
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -29557,6 +30275,57 @@ ${item.text}`
       activePrompt.complete();
     }
   }
+  async requestPlanImplementationPermission(sessionState, plan, cancellationSignal) {
+    const toolCallId = `plan-review:${plan.itemId}`;
+    try {
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        {
+          sessionId: sessionState.sessionId,
+          toolCall: {
+            toolCallId,
+            title: "Implement this plan?",
+            kind: "switch_mode",
+            status: "pending",
+            rawInput: { plan: plan.text }
+          },
+          options: [
+            {
+              optionId: IMPLEMENT_PLAN_OPTION_ID,
+              name: "Yes, implement this plan",
+              kind: "allow_once"
+            },
+            {
+              optionId: REVISE_PLAN_OPTION_ID,
+              name: "No, and tell Codex what to do differently",
+              kind: "reject_once"
+            }
+          ],
+          _meta: {
+            codex: {
+              kind: "plan_review",
+              planItemId: plan.itemId
+            }
+          }
+        },
+        { cancellationSignal }
+      );
+      const approved = response.outcome.outcome === "selected" && response.outcome.optionId === IMPLEMENT_PLAN_OPTION_ID;
+      await this.connection.notify(methods.client.session.update, {
+        sessionId: sessionState.sessionId,
+        update: {
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: "completed",
+          rawOutput: approved ? "User approved the plan." : "User kept the session in plan mode."
+        }
+      });
+      return approved;
+    } catch (error51) {
+      logger.error("Error requesting plan implementation permission", error51);
+      return false;
+    }
+  }
   cancelledPromptResponse(sessionState) {
     return {
       stopReason: "cancelled",
@@ -30034,6 +30803,9 @@ var CodexAppServerClient = class {
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
   }
+  async turnSteer(params) {
+    return await this.sendRequest({ method: "turn/steer", params });
+  }
   async reviewStart(params) {
     return await this.sendRequest({ method: "review/start", params });
   }
@@ -30607,6 +31379,10 @@ var legacySetSessionModelParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   modelId: external_exports.string()
 }).passthrough();
+var sessionSteerParamsParser = external_exports.object({
+  sessionId: external_exports.string(),
+  prompt: external_exports.array(external_exports.any())
+}).passthrough();
 var goalControlParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   action: external_exports.enum(["pause", "clear"])
@@ -30683,5 +31459,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.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)).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(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.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)).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);
 }