@agentclientprotocol/codex-acp 1.0.0 → 1.0.2

package/dist/index.js

@@ -3343,6 +3343,9 @@ var CLIENT_METHODS = {
   elicitation_create: "elicitation/create",
   elicitation_complete: "elicitation/complete"
 };
+var PROTOCOL_METHODS = {
+  cancel_request: "$/cancel_request"
+};
 var PROTOCOL_VERSION = 1;
 
 // node_modules/zod/v4/classic/external.js
@@ -18935,6 +18938,17 @@ var zFileSystemCapabilities = object({
   writeTextFile: boolean2().optional().default(false),
   _meta: record(string2(), unknown()).nullish()
 });
+var zBooleanConfigOptionCapabilities = object({
+  _meta: record(string2(), unknown()).nullish()
+});
+var zSessionConfigOptionsCapabilities = object({
+  boolean: defaultOnError(zBooleanConfigOptionCapabilities.nullish(), () => void 0),
+  _meta: record(string2(), unknown()).nullish()
+});
+var zClientSessionCapabilities = object({
+  configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => void 0),
+  _meta: record(string2(), unknown()).nullish()
+});
 var zPlanCapabilities = object({
   _meta: record(string2(), unknown()).nullish()
 });
@@ -18971,6 +18985,7 @@ var zClientNesCapabilities = object({
 var zClientCapabilities = object({
   fs: zFileSystemCapabilities.optional().default({ readTextFile: false, writeTextFile: false }),
   terminal: boolean2().optional().default(false),
+  session: defaultOnError(zClientSessionCapabilities.nullish(), () => void 0),
   plan: defaultOnError(zPlanCapabilities.nullish(), () => void 0),
   auth: zAuthCapabilities.optional().default({ terminal: false }),
   elicitation: defaultOnError(zElicitationCapabilities.nullish(), () => void 0),
@@ -19515,6 +19530,19 @@ function ndJsonStream(output, input) {
 }
 
 // node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
+var CANCEL_REQUEST_METHOD = "$/cancel_request";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonRpcId(value) {
+  return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function cancelRequestId(params) {
+  if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
+    return void 0;
+  }
+  return params["requestId"];
+}
 var Handled = {
   /**
    * Marks a message as handled.
@@ -19561,13 +19589,40 @@ function errorToResult(error51) {
     return RequestError.internalError({ details }).toResult();
   }
 }
+function requestCancelledError(reason) {
+  if (reason instanceof RequestError && reason.code === -32800) {
+    return reason;
+  }
+  return RequestError.requestCancelled(reason);
+}
+function errorToRequestResult(error51, signal) {
+  const requestCancelled = abortErrorToRequestCancelled(error51, signal);
+  return requestCancelled ? requestCancelled.toResult() : errorToResult(error51);
+}
+function abortErrorToRequestCancelled(error51, signal) {
+  if (!signal.aborted || !isAbortError(error51)) {
+    return void 0;
+  }
+  return requestCancelledError(signal.reason);
+}
+function isAbortError(error51) {
+  if (typeof error51 !== "object" || error51 === null) {
+    return false;
+  }
+  const maybeAbortError = error51;
+  return maybeAbortError.name === "AbortError" || maybeAbortError.code === "ABORT_ERR";
+}
 var RequestResponder = class {
   id;
   sendResult;
+  signal;
+  finishRequest;
   didRespond = false;
-  constructor(id, sendResult) {
+  constructor(id, sendResult, signal = new AbortController().signal, finishRequest) {
     this.id = id;
     this.sendResult = sendResult;
+    this.signal = signal;
+    this.finishRequest = finishRequest;
   }
   /**
    * Whether this request has already received a response.
@@ -19596,7 +19651,9 @@ var RequestResponder = class {
       return rejectedPromise(new Error("JSON-RPC request already responded"));
     }
     this.didRespond = true;
-    return this.sendResult(result);
+    return this.sendResult(result).finally(() => {
+      this.finishRequest?.();
+    });
   }
 };
 var HandlerRegistration = class {
@@ -19636,8 +19693,8 @@ var ConnectionContext = class {
   /**
    * Sends a request over the connection.
    */
-  sendRequest(method, params, mapResponse) {
-    return this.connection.sendRequest(method, params, mapResponse);
+  sendRequest(method, params, mapResponse, options) {
+    return this.connection.sendRequest(method, params, mapResponse, options);
   }
   /**
    * Sends a notification over the connection.
@@ -19645,6 +19702,12 @@ var ConnectionContext = class {
   sendNotification(method, params) {
     return this.connection.sendNotification(method, params);
   }
+  /**
+   * Sends a protocol-level request cancellation notification.
+   */
+  sendCancelRequest(requestId) {
+    return this.connection.sendCancelRequest(requestId);
+  }
   /**
    * Registers a handler that can be disposed independently.
    */
@@ -19666,6 +19729,7 @@ var ConnectionContext = class {
 };
 var Connection = class {
   pendingResponses = /* @__PURE__ */ new Map();
+  incomingRequests = /* @__PURE__ */ new Map();
   nextRequestId = 0;
   staticHandlers = [];
   dynamicHandlers = /* @__PURE__ */ new Set();
@@ -19763,13 +19827,15 @@ var Connection = class {
    * `mapResponse` can convert the raw result before the returned promise
    * resolves.
    */
-  sendRequest(method, params, mapResponse) {
+  sendRequest(method, params, mapResponse, options = {}) {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
     const id = this.nextRequestId++;
+    let cancel = () => {
+    };
     const responsePromise = new Promise((resolve, reject) => {
-      this.pendingResponses.set(id, {
+      const pendingResponse = {
         resolve: (response) => {
           try {
             const value = mapResponse ? mapResponse(response) : response;
@@ -19779,14 +19845,45 @@ var Connection = class {
           }
         },
         reject
+      };
+      cancel = () => {
+        if (pendingResponse.cancellationSent) {
+          return;
+        }
+        pendingResponse.cancellationSent = true;
+        pendingResponse.cleanup?.();
+        void this.sendCancelRequest(id).catch(() => {
+        });
+      };
+      options.cancellationSignal?.addEventListener("abort", cancel, {
+        once: true
       });
+      pendingResponse.cleanup = () => {
+        options.cancellationSignal?.removeEventListener("abort", cancel);
+      };
+      this.pendingResponses.set(id, pendingResponse);
     });
     responsePromise.catch(() => {
     });
-    void this.sendMessage({ jsonrpc: "2.0", id, method, params }).catch(() => {
+    const requestSent = this.sendMessage({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
     });
+    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.
    */
@@ -19804,11 +19901,16 @@ var Connection = class {
       return;
     }
     const closeError = error51 ?? new Error("ACP connection closed");
+    this.abortController.abort(closeError);
     for (const pendingResponse of this.pendingResponses.values()) {
+      pendingResponse.cleanup?.();
       pendingResponse.reject(closeError);
     }
     this.pendingResponses.clear();
-    this.abortController.abort(closeError);
+    for (const controller of this.incomingRequests.values()) {
+      controller.abort(closeError);
+    }
+    this.incomingRequests.clear();
     void this.receiveReader?.cancel(closeError).catch(() => {
     });
   }
@@ -19869,6 +19971,9 @@ var Connection = class {
       return;
     }
     if ("method" in message) {
+      if (!("id" in message)) {
+        this.handleProtocolNotification(message);
+      }
       void this.processIncomingMessage(this.toIncomingMessage(message)).catch((error51) => this.close(error51));
     } else if ("id" in message) {
       this.handleResponse(message);
@@ -19909,7 +20014,7 @@ var Connection = class {
         return;
       }
       if (current.kind === "request" && !current.responder.responded) {
-        await current.responder.respondWithResult(errorToResult(error51));
+        await current.responder.respondWithResult(errorToRequestResult(error51, current.responder.signal));
       } else {
         const response = errorToResult(error51);
         if ("error" in response) {
@@ -19920,16 +20025,24 @@ var Connection = class {
   }
   toIncomingMessage(message) {
     if ("id" in message) {
+      const abortController = new AbortController();
+      this.incomingRequests.set(message.id, abortController);
+      const finishRequest = () => {
+        if (this.incomingRequests.get(message.id) === abortController) {
+          this.incomingRequests.delete(message.id);
+        }
+      };
       return {
         kind: "request",
         method: message.method,
         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)
       };
     }
     return {
@@ -19942,6 +20055,8 @@ var Connection = class {
   handleResponse(response) {
     const pendingResponse = this.pendingResponses.get(response.id);
     if (pendingResponse) {
+      this.pendingResponses.delete(response.id);
+      pendingResponse.cleanup?.();
       if ("result" in response) {
         pendingResponse.resolve(response.result);
       } else if ("error" in response) {
@@ -19950,11 +20065,24 @@ var Connection = class {
       } else {
         pendingResponse.reject(RequestError.invalidRequest(response));
       }
-      this.pendingResponses.delete(response.id);
     } else {
       console.error("Got response to unknown request", response.id);
     }
   }
+  handleProtocolNotification(message) {
+    if (message.method !== CANCEL_REQUEST_METHOD) {
+      return;
+    }
+    const requestId = cancelRequestId(message.params);
+    if (requestId === void 0) {
+      return;
+    }
+    const controller = this.incomingRequests.get(requestId);
+    if (!controller || controller.signal.aborted) {
+      return;
+    }
+    controller.abort(RequestError.requestCancelled({ requestId }));
+  }
   closedReason() {
     return this.abortController.signal.reason ?? new Error("ACP connection closed");
   }
@@ -20095,6 +20223,12 @@ var RequestError = class _RequestError extends Error {
   static internalError(data, additionalMessage) {
     return new _RequestError(-32603, `Internal error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
   }
+  /**
+   * Execution of the request was aborted.
+   */
+  static requestCancelled(data, additionalMessage) {
+    return new _RequestError(-32800, `Request cancelled${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
   /**
    * Authentication required.
    */
@@ -20210,6 +20344,9 @@ var methods = {
       create: CLIENT_METHODS.elicitation_create,
       complete: CLIENT_METHODS.elicitation_complete
     }
+  },
+  protocol: {
+    cancelRequest: PROTOCOL_METHODS.cancel_request
   }
 };
 var startActiveSession = /* @__PURE__ */ Symbol("startActiveSession");
@@ -20224,8 +20361,8 @@ var AcpContext = class {
     return this.cx;
   }
   /** @internal */
-  sendRequest(method, params, mapResponse) {
-    return this.cx.sendRequest(method, params, mapResponse);
+  sendRequest(method, params, mapResponse, options) {
+    return this.cx.sendRequest(method, params, mapResponse, options);
   }
   /** @internal */
   sendNotification(method, params) {
@@ -20244,9 +20381,9 @@ var AgentContext = class _AgentContext extends AcpContext {
   static create(cx) {
     return new _AgentContext(cx);
   }
-  request(method, params) {
+  request(method, params, options) {
     const spec = clientRequestSpecsByMethod[method];
-    return this.sendRequest(method, params, spec?.mapResponse);
+    return this.sendRequest(method, params, spec?.mapResponse, options);
   }
   notify(method, params) {
     return this.sendNotification(method, params);
@@ -20261,8 +20398,8 @@ var ClientContext = class _ClientContext extends AcpContext {
     return new _ClientContext(cx);
   }
   /** @internal */
-  [startActiveSession](params) {
-    return this.sendRequest(AGENT_METHODS.session_new, params, (response) => this.attachSession(response));
+  [startActiveSession](params, options) {
+    return this.sendRequest(AGENT_METHODS.session_new, params, (response) => this.attachSession(response), options);
   }
   buildSession(cwdOrRequest) {
     if (typeof cwdOrRequest === "string") {
@@ -20296,9 +20433,9 @@ var ClientContext = class _ClientContext extends AcpContext {
       closeRegistration
     ]);
   }
-  request(method, params) {
+  request(method, params, options) {
     const spec = agentRequestSpecsByMethod[method];
-    return this.sendRequest(method, params, spec?.mapResponse);
+    return this.sendRequest(method, params, spec?.mapResponse, options);
   }
   notify(method, params) {
     return this.sendNotification(method, params);
@@ -20475,8 +20612,8 @@ var SessionBuilder = class _SessionBuilder {
    * Call `dispose()` on the returned session when you no longer need update
    * routing, or use `withSession(...)` to scope disposal automatically.
    */
-  async start() {
-    return this.cx[startActiveSession](this.toRequest());
+  async start(options) {
+    return this.cx[startActiveSession](this.toRequest(), options);
   }
   /**
    * Starts the session, runs `op`, and disposes the active-session update
@@ -20538,12 +20675,12 @@ var ActiveSession = class _ActiveSession {
    * `PromptResponse`, and the same completion is also queued as a `stop`
    * message for `nextUpdate()`.
    */
-  prompt(prompt) {
+  prompt(prompt, options) {
     this.updates.clearErrors();
     const response = this.cx.request(AGENT_METHODS.session_prompt, {
       sessionId: this.sessionId,
       prompt: this.promptBlocks(prompt)
-    });
+    }, options);
     void response.then((value) => {
       this.updates.enqueue({
         kind: "stop",
@@ -20627,12 +20764,12 @@ function notificationSpec(method, params) {
 }
 function registerAppRequest(builder, spec, context, handler) {
   builder.onReceiveRequest(spec.method, (params) => parseParams(spec.params, params), async (params, responder, cx) => {
-    const response = await handler(context(params, cx));
+    const response = await handler(context(params, cx, responder.signal));
     await responder.respond(spec.mapResponse ? spec.mapResponse(response) : response);
   });
 }
 function registerAppNotification(builder, spec, context, handler) {
-  builder.onReceiveNotification(spec.method, (params) => parseParams(spec.params, params), (params, cx) => handler(context(params, cx)));
+  builder.onReceiveNotification(spec.method, (params) => parseParams(spec.params, params), (params, cx) => handler(context(params, cx, cx.signal)));
 }
 function specsByMethod(specs) {
   const byMethod = {};
@@ -20691,15 +20828,17 @@ var agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
 var agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
 var clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
 var clientNotificationSpecsByMethod = specsByMethod(clientNotificationSpecs);
-function agentHandlerContext(params, client) {
+function agentHandlerContext(params, client, signal) {
   return {
     params,
+    signal,
     client
   };
 }
-function clientHandlerContext(params, agent2) {
+function clientHandlerContext(params, agent2, signal) {
   return {
     params,
+    signal,
     agent: agent2
   };
 }
@@ -20818,11 +20957,11 @@ var AgentApp = class {
     return this.notification(spec, handlerOrParams);
   }
   request(spec, handler) {
-    registerAppRequest(this.builder, spec, (params, cx) => agentHandlerContext(params, AgentContext.create(cx)), handler);
+    registerAppRequest(this.builder, spec, (params, cx, signal) => agentHandlerContext(params, AgentContext.create(cx), signal), handler);
     return this;
   }
   notification(spec, handler) {
-    registerAppNotification(this.builder, spec, (params, cx) => agentHandlerContext(params, AgentContext.create(cx)), handler);
+    registerAppNotification(this.builder, spec, (params, cx, signal) => agentHandlerContext(params, AgentContext.create(cx), signal), handler);
     return this;
   }
   connectConnection(target, options = {}) {
@@ -20915,11 +21054,11 @@ var ClientApp = class {
     return this.notification(spec, handlerOrParams);
   }
   request(spec, handler) {
-    registerAppRequest(this.builder, spec, (params, cx) => clientHandlerContext(params, ClientContext.create(cx)), handler);
+    registerAppRequest(this.builder, spec, (params, cx, signal) => clientHandlerContext(params, ClientContext.create(cx), signal), handler);
     return this;
   }
   notification(spec, handler) {
-    registerAppNotification(this.builder, spec, (params, cx) => clientHandlerContext(params, ClientContext.create(cx)), handler);
+    registerAppNotification(this.builder, spec, (params, cx, signal) => clientHandlerContext(params, ClientContext.create(cx), signal), handler);
     return this;
   }
   connectConnection(target) {
@@ -21844,6 +21983,34 @@ function createWebSearchCompleteUpdate(item) {
     rawInput: item
   };
 }
+function createCollabAgentToolCallUpdate(item) {
+  return {
+    sessionUpdate: "tool_call",
+    toolCallId: item.id,
+    kind: "other",
+    title: item.tool,
+    status: toAcpStatus(item.status),
+    rawInput: createCollabAgentToolCallRawInput(item)
+  };
+}
+function createCollabAgentToolCallCompleteUpdate(item) {
+  return {
+    sessionUpdate: "tool_call_update",
+    toolCallId: item.id,
+    title: item.tool,
+    status: toAcpStatus(item.status),
+    rawInput: createCollabAgentToolCallRawInput(item)
+  };
+}
+function createCollabAgentToolCallRawInput(item) {
+  return {
+    prompt: item.prompt,
+    senderThreadId: item.senderThreadId,
+    receiverThreadIds: item.receiverThreadIds,
+    agentsStates: item.agentsStates,
+    status: item.status
+  };
+}
 function formatWebSearchTitle(item) {
   const action = item.action;
   if (!action) {
@@ -22295,6 +22462,7 @@ var CodexEventHandler = class {
       case "mcpServer/startupStatus/updated":
       case "serverRequest/resolved":
       case "model/verification":
+      case "model/safetyBuffering/updated":
       case "windows/worldWritableWarning":
       case "thread/realtime/started":
       case "thread/realtime/itemAdded":
@@ -22316,6 +22484,7 @@ var CodexEventHandler = class {
       case "remoteControl/status/changed":
       case "app/list/updated":
       case "thread/settings/updated":
+      case "externalAgentConfig/import/progress":
       case "process/outputDelta":
       case "process/exited":
         return null;
@@ -22375,15 +22544,24 @@ ${event.details}` : "";
     };
   }
   createThreadGoalUpdatedEvent(event) {
+    const goalSnapshot = this.createThreadGoalSnapshot(event);
+    if (this.sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
+      return null;
+    }
+    this.sessionState.currentGoal = goalSnapshot;
     const status = this.formatThreadGoalStatus(event.goal.status);
-    const objective = event.goal.objective.trim();
+    const objective = goalSnapshot.objective;
     const text = objective.includes("\n") ? `Goal updated (${status}):
 ${objective}` : `Goal updated (${status}): ${objective}`;
     return {
       sessionUpdate: "agent_message_chunk",
       content: {
         type: "text",
-        text
+        text: `
+
+${text}
+
+`
       }
     };
   }
@@ -22404,14 +22582,28 @@ ${objective}` : `Goal updated (${status}): ${objective}`;
     }
   }
   createThreadGoalClearedEvent(_event) {
+    if (this.sessionState.currentGoal === null) {
+      return null;
+    }
+    this.sessionState.currentGoal = null;
     return {
       sessionUpdate: "agent_message_chunk",
       content: {
         type: "text",
-        text: "Goal cleared."
+        text: "\n\nGoal cleared.\n\n"
       }
     };
   }
+  createThreadGoalSnapshot(event) {
+    return {
+      objective: event.goal.objective.trim(),
+      status: event.goal.status,
+      tokenBudget: event.goal.tokenBudget
+    };
+  }
+  sameThreadGoalSnapshot(left, right) {
+    return left !== null && left !== void 0 && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget;
+  }
   createReasoningDeltaEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent(event.delta);
@@ -22455,6 +22647,7 @@ ${objective}` : `Goal updated (${status}): ${objective}`;
         this.activeImageGenerationItems.add(event.item.id);
         return createImageGenerationStartUpdate(event.item);
       case "collabAgentToolCall":
+        return createCollabAgentToolCallUpdate(event.item);
       case "subAgentActivity":
       case "sleep":
       case "userMessage":
@@ -22504,12 +22697,13 @@ ${objective}` : `Goal updated (${status}): ${objective}`;
         return this.createCompletedReasoningEvent(event.item);
       case "webSearch":
         return createWebSearchCompleteUpdate(event.item);
+      case "collabAgentToolCall":
+        return createCollabAgentToolCallCompleteUpdate(event.item);
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
         return this.createContextCompactedEvent();
       //ignored types
-      case "collabAgentToolCall":
       case "subAgentActivity":
       case "sleep":
       case "userMessage":
@@ -22668,8 +22862,12 @@ ${event.stdin}
   }
   async createErrorEvent(params) {
     const error51 = params.error.codexErrorInfo;
-    if (error51 == "unauthorized" || error51 == "usageLimitExceeded" || this.getHttpStatusCode(error51) == 401) {
-      this.failure = RequestError.authRequired();
+    if (error51 === "usageLimitExceeded") {
+      this.failure = RequestError.internalError(
+        this.createTurnErrorData(params.error)
+      );
+    } else if (this.isAuthenticationRequiredError(error51)) {
+      this.failure = this.sessionState.authConfigured ? RequestError.internalError(this.createTurnErrorData(params.error)) : RequestError.authRequired(this.createTurnErrorData(params.error), params.error.message);
     }
     return {
       sessionUpdate: "agent_message_chunk",
@@ -22681,6 +22879,9 @@ ${event.stdin}
       }
     };
   }
+  isAuthenticationRequiredError(error51) {
+    return error51 === "unauthorized" || this.getHttpStatusCode(error51) === 401;
+  }
   getHttpStatusCode(error51) {
     if (error51 !== null && typeof error51 === "object") {
       if ("httpConnectionFailed" in error51) {
@@ -22695,6 +22896,18 @@ ${event.stdin}
     }
     return null;
   }
+  createTurnErrorData(error51) {
+    const data = {
+      message: error51.additionalDetails ?? error51.message
+    };
+    if (error51.codexErrorInfo !== null) {
+      data.codexErrorInfo = error51.codexErrorInfo;
+    }
+    if (error51.additionalDetails !== null) {
+      data.additionalDetails = error51.additionalDetails;
+    }
+    return data;
+  }
   handleTokenUsageUpdated(params) {
     this.sessionState.lastTokenUsage = toTokenCount(params.tokenUsage.last);
     this.sessionState.totalTokenUsage = toTokenCount(params.tokenUsage.total);
@@ -22774,15 +22987,21 @@ function permissionOption(optionId, name, kind, codexMeta) {
 var CodexApprovalHandler = class {
   connection;
   sessionState;
-  constructor(connection, sessionState) {
+  cancellationSignal;
+  constructor(connection, sessionState, cancellationSignal) {
     this.connection = connection;
     this.sessionState = sessionState;
+    this.cancellationSignal = cancellationSignal;
   }
   async handleCommandExecution(params) {
     try {
       const sessionId = this.sessionState.sessionId;
       const acpRequest = this.buildCommandPermissionRequest(sessionId, params);
-      const response = await this.connection.request(methods.client.session.requestPermission, acpRequest);
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        acpRequest,
+        this.requestOptions()
+      );
       return this.convertCommandResponse(params, response);
     } catch (error51) {
       logger.error("Error requesting command execution permission", error51);
@@ -22793,7 +23012,11 @@ var CodexApprovalHandler = class {
     try {
       const sessionId = this.sessionState.sessionId;
       const acpRequest = this.buildFileChangePermissionRequest(sessionId, params);
-      const response = await this.connection.request(methods.client.session.requestPermission, acpRequest);
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        acpRequest,
+        this.requestOptions()
+      );
       return this.convertFileChangeResponse(params, response);
     } catch (error51) {
       logger.error("Error requesting file change permission", error51);
@@ -22804,13 +23027,20 @@ var CodexApprovalHandler = class {
     try {
       const sessionId = this.sessionState.sessionId;
       const acpRequest = this.buildPermissionsRequest(sessionId, params);
-      const response = await this.connection.request(methods.client.session.requestPermission, acpRequest);
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        acpRequest,
+        this.requestOptions()
+      );
       return this.convertPermissionsResponse(params, response);
     } catch (error51) {
       logger.error("Error requesting permissions", error51);
       return this.rejectPermissionsResponse();
     }
   }
+  requestOptions() {
+    return this.cancellationSignal ? { cancellationSignal: this.cancellationSignal } : void 0;
+  }
   buildCommandPermissionRequest(sessionId, params) {
     const options = this.buildCommandOptions(params).map(({ option }) => option);
     return {
@@ -23095,6 +23325,7 @@ function buildToolApprovalOptions(persistOptions) {
 var CodexElicitationHandler = class {
   connection;
   sessionState;
+  cancellationSignal;
   // In Rust, the MCP elicitation handler receives ElicitationRequestEvent directly from the MCP
   // protocol layer, where id is set to "mcp_tool_call_approval_<call_id>" — the call ID is extracted
   // by stripping that prefix.
@@ -23111,9 +23342,10 @@ var CodexElicitationHandler = class {
   // call's elicitation before starting the next, so there is at most one pending approval per
   // (threadId, serverName).
   pendingMcpApprovals = /* @__PURE__ */ new Map();
-  constructor(connection, sessionState) {
+  constructor(connection, sessionState, cancellationSignal) {
     this.connection = connection;
     this.sessionState = sessionState;
+    this.cancellationSignal = cancellationSignal;
   }
   handleNotification(notification) {
     switch (notification.method) {
@@ -23133,7 +23365,11 @@ var CodexElicitationHandler = class {
   async handleElicitation(params) {
     try {
       const { request, correlatedCallId } = this.buildPermissionRequest(params);
-      const response = await this.connection.request(methods.client.session.requestPermission, request);
+      const response = await this.connection.request(
+        methods.client.session.requestPermission,
+        request,
+        this.requestOptions()
+      );
       if (correlatedCallId !== void 0 && response.outcome.outcome !== "cancelled") {
         const optionId = response.outcome.optionId;
         if (optionId !== McpApprovalOptionId.Decline) {
@@ -23149,6 +23385,9 @@ var CodexElicitationHandler = class {
       return { action: "cancel", content: null, _meta: null };
     }
   }
+  requestOptions() {
+    return this.cancellationSignal ? { cancellationSignal: this.cancellationSignal } : void 0;
+  }
   buildPermissionRequest(params) {
     const sessionId = this.sessionState.sessionId;
     const messageContent = {
@@ -23158,7 +23397,7 @@ var CodexElicitationHandler = class {
     const meta3 = params._meta;
     const isToolApproval = isMcpToolCallApproval(meta3);
     const options = isToolApproval ? buildToolApprovalOptions(parsePersistOptions(meta3)) : ELICITATION_OPTIONS;
-    if (params.mode === "form") {
+    if (params.mode === "form" || params.mode === "openai/form") {
       const correlatedCallId = isToolApproval ? this.popPendingApproval(params.threadId, params.serverName) : void 0;
       if (correlatedCallId !== void 0) {
         return {
@@ -23259,6 +23498,8 @@ var CodexElicitationHandler = class {
 };
 
 // src/CodexAuthMethod.ts
+var CODEX_API_KEY_ENV_VAR = "CODEX_API_KEY";
+var OPENAI_API_KEY_ENV_VAR = "OPENAI_API_KEY";
 var ApiKeyAuthMethod = {
   id: "api-key",
   name: "API Key",
@@ -23285,8 +23526,11 @@ var GatewayAuthMethod = {
     }
   }
 };
-function getCodexAuthMethods(clientCapabilities) {
-  const authMethods = [ApiKeyAuthMethod, ChatGptAuthMethod];
+function getCodexAuthMethods(clientCapabilities, env = process.env) {
+  const authMethods = [ApiKeyAuthMethod];
+  if (!env["NO_BROWSER"]) {
+    authMethods.push(ChatGptAuthMethod);
+  }
   const supportsGatewayAuth = clientCapabilities?.auth?._meta?.["gateway"] === true;
   if (supportsGatewayAuth) {
     authMethods.push(GatewayAuthMethod);
@@ -24038,7 +24282,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.0.0",
+  version: "1.0.2",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -24096,8 +24340,8 @@ var package_default = {
     vitest: "^4.0.10"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^0.28.1",
-    "@openai/codex": "^0.141.0",
+    "@agentclientprotocol/sdk": "^1.0.0",
+    "@openai/codex": "^0.142.4",
     diff: "^8.0.3",
     open: "^11.0.0",
     "vscode-jsonrpc": "^8.2.1",
@@ -24142,17 +24386,15 @@ var CodexAcpClient = class {
     }
     switch (authRequest.methodId) {
       case "api-key": {
-        if (!authRequest._meta || !authRequest._meta["api-key"]) throw RequestError.invalidRequest();
-        const loginCompletedPromise = this.awaitNextLoginCompleted();
-        await this.codexClient.accountLogin({
-          type: "apiKey",
-          apiKey: authRequest._meta["api-key"].apiKey
-        });
-        this.gatewayConfig = null;
-        const result = await loginCompletedPromise;
-        return result.success;
+        const apiKey = authRequest._meta?.["api-key"]?.apiKey ?? this.readApiKeyFromEnv();
+        return await this.authenticateWithApiKey(apiKey);
       }
       case "chat-gpt": {
+        const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
+        if (accountResponse.account?.type === "chatgpt") {
+          this.gatewayConfig = null;
+          return true;
+        }
         const loginCompletedPromise = this.awaitNextLoginCompleted();
         const loginResponse = await this.codexClient.accountLogin({ type: "chatgpt" });
         if (loginResponse.type == "chatgpt") {
@@ -24186,6 +24428,28 @@ var CodexAcpClient = class {
     this.gatewayConfig = null;
     return false;
   }
+  async authenticateWithApiKey(apiKey) {
+    const loginCompletedPromise = this.awaitNextLoginCompleted();
+    await this.codexClient.accountLogin({
+      type: "apiKey",
+      apiKey
+    });
+    this.gatewayConfig = null;
+    const result = await loginCompletedPromise;
+    return result.success;
+  }
+  readApiKeyFromEnv() {
+    for (const envVar of [CODEX_API_KEY_ENV_VAR, OPENAI_API_KEY_ENV_VAR]) {
+      const value = process.env[envVar]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    throw RequestError.internalError(
+      { envVars: [CODEX_API_KEY_ENV_VAR, OPENAI_API_KEY_ENV_VAR] },
+      `${CODEX_API_KEY_ENV_VAR} or ${OPENAI_API_KEY_ENV_VAR} is not set`
+    );
+  }
   async getAuthenticationStatus() {
     const modelProvider = await this.getCurrentModelProvider();
     if (modelProvider) {
@@ -24208,7 +24472,7 @@ var CodexAcpClient = class {
       case "chatgpt":
         return {
           type: "chat-gpt",
-          email: account.email
+          email: account.email ?? ""
         };
       case "amazonBedrock":
         return {
@@ -24223,7 +24487,7 @@ var CodexAcpClient = class {
       return sessionModelProvider;
     }
     const settingsModelProvider = await this.codexClient.configRead({ includeLayers: false });
-    return settingsModelProvider.config.model_provider;
+    return settingsModelProvider?.config?.model_provider ?? null;
   }
   async logout() {
     const accountUpdatedPromise = this.awaitNextAccountUpdated();
@@ -24237,6 +24501,9 @@ var CodexAcpClient = class {
     const response = await this.codexClient.accountRead({ refreshToken: false });
     return response.requiresOpenaiAuth && !response.account;
   }
+  hasGatewayAuth() {
+    return this.gatewayConfig !== null;
+  }
   async getAccount() {
     return this.codexClient.accountRead({ refreshToken: false });
   }
@@ -24246,7 +24513,7 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadResume({
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
-      modelProvider: this.getResumeModelProvider(),
+      modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
     });
     onSubscribed?.();
@@ -24256,6 +24523,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
     };
@@ -24266,7 +24534,7 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadResume({
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
-      modelProvider: this.getResumeModelProvider(),
+      modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
     });
     onSubscribed?.();
@@ -24280,6 +24548,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       thread: historyResponse.thread,
       additionalDirectories
@@ -24302,6 +24571,7 @@ var CodexAcpClient = class {
       sessionId: response.thread.id,
       currentModelId,
       models: codexModels,
+      modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
     };
@@ -24326,6 +24596,28 @@ var CodexAcpClient = class {
   async runCompact(sessionId) {
     await this.codexClient.runCompact({ threadId: sessionId });
   }
+  async setGoal(sessionId, objective, onTurnStarted) {
+    return await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      objective,
+      status: "active"
+    }, onTurnStarted);
+  }
+  async setGoalStatus(sessionId, status) {
+    await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      status
+    });
+  }
+  async resumeGoal(sessionId, onTurnStarted) {
+    return await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      status: "active"
+    }, onTurnStarted);
+  }
+  async clearGoal(sessionId) {
+    await this.codexClient.runGoalClear({ threadId: sessionId });
+  }
   async awaitMcpServerStartup(serverNames, afterVersion) {
     return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
   }
@@ -24372,8 +24664,8 @@ var CodexAcpClient = class {
   getModelProvider() {
     return this.gatewayConfig?.modelProvider ?? this.modelProvider;
   }
-  getResumeModelProvider() {
-    return this.getModelProvider() ?? "openai";
+  async getResumeModelProvider() {
+    return await this.getCurrentModelProvider() ?? "openai";
   }
   async refreshSkills(cwd, additionalRoots) {
     if (!cwd) {
@@ -24417,11 +24709,18 @@ var CodexAcpClient = class {
    * Falls back to model defaults if parameters are missing or unsupported.
    */
   createModelId(availableModels, modelId, reasoningEffort) {
-    const selectedModel = availableModels.find((m) => m.id === modelId) ?? availableModels.find((m) => m.isDefault);
-    if (!selectedModel) {
+    const selectedModel = availableModels.find((m) => m.id === modelId);
+    if (selectedModel) {
+      return ModelId.create(selectedModel.id, reasoningEffort ?? selectedModel.defaultReasoningEffort);
+    }
+    if (modelId) {
+      return ModelId.create(modelId, reasoningEffort ?? "medium");
+    }
+    const defaultModel = availableModels.find((m) => m.isDefault);
+    if (!defaultModel) {
       throw new Error(`Model selection failed: No model found for ID "${modelId}" and no default model is defined.`);
     }
-    return ModelId.create(selectedModel.id, reasoningEffort ?? selectedModel.defaultReasoningEffort);
+    return ModelId.create(defaultModel.id, reasoningEffort ?? defaultModel.defaultReasoningEffort);
   }
   async subscribeToSessionEvents(sessionId, eventHandler, approvalHandler, elicitationHandler) {
     this.codexClient.onServerNotification(sessionId, (event) => {
@@ -24545,11 +24844,6 @@ var CodexAcpClient = class {
       "vscode",
       "exec",
       "appServer",
-      "subAgent",
-      "subAgentReview",
-      "subAgentCompact",
-      "subAgentThreadSpawn",
-      "subAgentOther",
       "unknown"
     ];
     const requestedCwd = request.cwd?.trim() ?? null;
@@ -24568,23 +24862,19 @@ var CodexAcpClient = class {
       modelProviders,
       sourceKinds
     });
-    if (listResponse.data.length === 0) {
-      const diagnostics = await this.runSessionListDiagnostics();
-      logger.log("Session list diagnostics", diagnostics);
-    }
-    let sessions = listResponse.data.map((thread) => ({
+    const mapThreadToSession = (thread) => ({
       sessionId: thread.id,
       cwd: thread.cwd,
       title: (thread.name ?? thread.preview) || null,
       updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
-    }));
+    });
+    if (listResponse.data.length === 0) {
+      const diagnostics = await this.runSessionListDiagnostics();
+      logger.log("Session list diagnostics", diagnostics);
+    }
+    let sessions = listResponse.data.map(mapThreadToSession);
     if (requestedCwd) {
-      const filtered = listResponse.data.filter(filterByCwd).map((thread) => ({
-        sessionId: thread.id,
-        cwd: thread.cwd,
-        title: (thread.name ?? thread.preview) || null,
-        updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
-      }));
+      const filtered = listResponse.data.filter(filterByCwd).map(mapThreadToSession);
       if (filtered.length > 0 || path4.isAbsolute(requestedCwd)) {
         sessions = filtered;
       } else {
@@ -24640,7 +24930,7 @@ function buildPromptItems(prompt) {
       case "text":
         return { type: "text", text: block.text, text_elements: [] };
       case "image": {
-        const url2 = block.uri ?? `data:${block.mimeType};base64,${block.data}`;
+        const url2 = isSupportedImageUrl(block.uri) ? block.uri : imageDataUrl(block);
         return { type: "image", url: url2 };
       }
       case "resource_link":
@@ -24671,9 +24961,23 @@ ${context}`, text_elements: [] };
     }
   }).filter((block) => block !== null);
 }
+function imageDataUrl(block) {
+  return `data:${block.mimeType};base64,${block.data}`;
+}
 function isImageMimeType(mimeType) {
   return mimeType?.startsWith("image/") ?? false;
 }
+function isSupportedImageUrl(uri) {
+  if (!uri) {
+    return false;
+  }
+  try {
+    const protocol = new URL(uri).protocol;
+    return protocol === "http:" || protocol === "https:" || protocol === "data:";
+  } catch {
+    return false;
+  }
+}
 function formatUriAsLink(name, uri) {
   if (name && name.length > 0) {
     return `[@${name}](${uri})`;
@@ -24778,6 +25082,18 @@ function findSupportedEffort(options, effort) {
   return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
 }
 function createModelConfigOption(availableModels, currentBaseModelId) {
+  const options = availableModels.map((model) => ({
+    value: model.id,
+    name: model.displayName,
+    description: model.description
+  }));
+  if (!availableModels.some((model) => model.id === currentBaseModelId)) {
+    options.unshift({
+      value: currentBaseModelId,
+      name: currentBaseModelId,
+      description: null
+    });
+  }
   return {
     id: MODEL_CONFIG_ID,
     name: "Model",
@@ -24785,11 +25101,7 @@ function createModelConfigOption(availableModels, currentBaseModelId) {
     category: "model",
     type: "select",
     currentValue: currentBaseModelId,
-    options: availableModels.map((model) => ({
-      value: model.id,
-      name: model.displayName,
-      description: model.description
-    }))
+    options
   };
 }
 function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
@@ -24813,27 +25125,35 @@ var CodexCommands = class {
   connection;
   codexAcpClient;
   runWithProcessCheck;
-  constructor(connection, codexAcpClient, runWithProcessCheck) {
+  onLogout;
+  constructor(connection, codexAcpClient, runWithProcessCheck, onLogout = () => {
+  }) {
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.runWithProcessCheck = runWithProcessCheck;
+    this.onLogout = onLogout;
   }
-  async publish(sessionId) {
+  async publish(sessionState) {
     try {
-      const skillsResponse = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills());
+      const skillsResponse = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills(this.createSkillsListParams(sessionState)));
       const availableCommands = this.buildAvailableCommands(skillsResponse?.data ?? []);
       if (availableCommands.length === 0) {
         return;
       }
-      const session = new ACPSessionConnection(this.connection, sessionId);
+      const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
       await session.update({
         sessionUpdate: "available_commands_update",
         availableCommands
       });
     } catch (err) {
-      logger.error(`Failed to publish available commands for session ${sessionId}`, err);
+      logger.error(`Failed to publish available commands for session ${sessionState.sessionId}`, err);
     }
   }
+  createSkillsListParams(sessionState) {
+    return {
+      cwds: [sessionState.cwd, ...sessionState.additionalDirectories]
+    };
+  }
   buildAvailableCommands(skillsEntries) {
     const commands = /* @__PURE__ */ new Map();
     for (const builtin of this.getBuiltinCommands()) {
@@ -24893,6 +25213,11 @@ var CodexCommands = class {
         description: "Summarize conversation to avoid hitting the context limit.",
         input: null
       },
+      {
+        name: "goal",
+        description: "Set, pause, resume, or clear a task goal.",
+        input: { hint: "[<objective>|clear|pause|resume]" }
+      },
       {
         name: "logout",
         description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
@@ -24914,7 +25239,7 @@ var CodexCommands = class {
       rest: commandText.slice(name.length).trim()
     };
   }
-  async tryHandleCommand(prompt, sessionState) {
+  async tryHandleCommand(prompt, sessionState, options = {}) {
     const command = this.parseCommand(prompt);
     if (command === null) return { handled: false };
     const commandName = command.name;
@@ -24925,9 +25250,12 @@ var CodexCommands = class {
         await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
         return { handled: true };
       }
+      case "goal": {
+        return await this.runGoalCommand(sessionState, command.rest, options);
+      }
       case "review": {
         const target = this.buildReviewTarget(command.rest);
-        const turnCompleted = await this.runReviewCommand(sessionState, target);
+        const turnCompleted = await this.runReviewCommand(sessionState, target, options);
         return { handled: true, turnCompleted };
       }
       case "review-branch": {
@@ -24938,7 +25266,7 @@ var CodexCommands = class {
         const turnCompleted = await this.runReviewCommand(sessionState, {
           type: "baseBranch",
           branch: command.rest
-        });
+        }, options);
         return { handled: true, turnCompleted };
       }
       case "review-commit": {
@@ -24950,7 +25278,7 @@ var CodexCommands = class {
           type: "commit",
           sha: command.rest,
           title: null
-        });
+        }, options);
         return { handled: true, turnCompleted };
       }
       case "status": {
@@ -24964,6 +25292,7 @@ var CodexCommands = class {
       }
       case "logout": {
         await this.runWithProcessCheck(() => this.codexAcpClient.logout());
+        await this.onLogout();
         const session = new ACPSessionConnection(this.connection, sessionId);
         await session.update({
           sessionUpdate: "agent_message_chunk",
@@ -24972,7 +25301,7 @@ var CodexCommands = class {
         return { handled: true };
       }
       case "skills": {
-        const response = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills());
+        const response = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills(this.createSkillsListParams(sessionState)));
         const skills = (response?.data ?? []).flatMap((entry) => entry.skills);
         const lines = skills.map((skill) => {
           const description = skill.shortDescription ?? skill.description ?? "";
@@ -25008,15 +25337,75 @@ var CodexCommands = class {
         return { handled: true };
     }
   }
-  async runReviewCommand(sessionState, target) {
+  async runReviewCommand(sessionState, target, options) {
+    options.onTurnStartPending?.();
     return await this.runWithProcessCheck(() => this.codexAcpClient.runReview(
       sessionState.sessionId,
       target,
-      (turnId) => {
-        sessionState.currentTurnId = turnId;
+      (turnId, threadId) => {
+        this.handleCommandTurnStarted(sessionState, options, turnId, threadId);
       }
     ));
   }
+  async runGoalCommand(sessionState, rest, options) {
+    const sessionId = sessionState.sessionId;
+    const argument = rest.trim();
+    if (argument.length === 0) {
+      await this.sendCommandUsageMessage("goal", "[<objective>|clear|pause|resume]", sessionId);
+      return { handled: true };
+    }
+    switch (argument.toLowerCase()) {
+      case "pause":
+        await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionId, "paused"));
+        return { handled: true };
+      case "resume":
+        options.onTurnStartPending?.();
+        return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.resumeGoal(
+          sessionId,
+          (turnId) => {
+            this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
+          }
+        )));
+      case "clear":
+        await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionId));
+        return { handled: true };
+    }
+    if (argument.length > 4e3) {
+      const session = new ACPSessionConnection(this.connection, sessionId);
+      await session.update({
+        sessionUpdate: "agent_message_chunk",
+        content: {
+          type: "text",
+          text: 'Command "/goal" requires goal text of at most 4000 characters.'
+        }
+      });
+      return { handled: true };
+    }
+    options.onTurnStartPending?.();
+    return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.setGoal(
+      sessionId,
+      argument,
+      (turnId) => {
+        this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
+      }
+    )));
+  }
+  handleCommandTurnStarted(sessionState, options, turnId, threadId) {
+    if (options.onTurnStarted) {
+      options.onTurnStarted(turnId, threadId);
+    } else {
+      sessionState.currentTurnId = turnId;
+    }
+  }
+  createGoalCommandResult(turnCompleted) {
+    if (turnCompleted === null) {
+      return { handled: true };
+    }
+    return {
+      handled: true,
+      turnCompleted
+    };
+  }
   buildReviewTarget(instructions) {
     if (instructions.length === 0) {
       return { type: "uncommittedChanges" };
@@ -25484,15 +25873,16 @@ function createFunctionCallUpdate(item) {
   if (!toolCallId || !name) {
     return null;
   }
+  const isExecCommand = name === "exec_command";
   const args = parseFunctionArguments(item["arguments"]);
-  const command = name === "exec_command" ? commandFromFunctionArguments(args) : null;
-  const cwd = name === "exec_command" ? cwdFromFunctionArguments(args) : "";
+  const command = isExecCommand ? commandFromFunctionArguments(args) : null;
+  const cwd = isExecCommand ? cwdFromFunctionArguments(args) : "";
   const commandAction = command ? inferCommandAction(command, cwd) : null;
   if (commandAction) {
     return {
       update: createCommandActionEvent(toolCallId, "inProgress", cwd, commandAction),
       usesTerminal: false,
-      isExecCommand: true
+      isExecCommand
     };
   }
   const update = {
@@ -25504,12 +25894,12 @@ function createFunctionCallUpdate(item) {
     rawInput: rawInputForFunctionCall(name, args)
   };
   if (!functionCallUsesTerminal(item)) {
-    return { update, usesTerminal: false, isExecCommand: false };
+    return { update, usesTerminal: false, isExecCommand };
   }
   return {
     update: withTerminalContent(update, toolCallId, cwd),
     usesTerminal: true,
-    isExecCommand: true
+    isExecCommand
   };
 }
 function createFunctionCallOutputUpdate(item, terminalOutputMode, terminalToolCallIds, execToolCallIds) {
@@ -26023,7 +26413,7 @@ function sedFileArguments(args) {
   return files;
 }
 function looksLikeSedRangeScript(arg) {
-  return /^(\d+|\$)?(,(\d+|\$))?[pd]$/.test(arg) || /^(\d+|\$)?(,(\d+|\$))?p$/.test(arg);
+  return /^(\d+|\$)?(,(\d+|\$))?[pd]$/.test(arg);
 }
 function headTailFileArguments(args) {
   const files = [];
@@ -26238,7 +26628,8 @@ var CodexAcpServer = class _CodexAcpServer {
     this.availableCommands = new CodexCommands(
       connection,
       codexAcpClient,
-      (operation) => this.runWithProcessCheck(operation)
+      (operation) => this.runWithProcessCheck(operation),
+      () => this.refreshSessionsAuthState(null)
     );
   }
   async initialize(_params) {
@@ -26322,6 +26713,7 @@ var CodexAcpServer = class _CodexAcpServer {
   async handleError(e) {
     if (e.message.includes("log out") || e.message.includes("cloud requirements")) {
       await this.runWithProcessCheck(() => this.codexAcpClient.logout());
+      await this.refreshSessionsAuthState(null);
       throw RequestError.internalError(`${e.message}
 
 You have been logged out. Please try again.`);
@@ -26407,9 +26799,10 @@ You have been logged out. Please try again.`);
       sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.newSession(request));
     }
     const { sessionId, currentModelId, models } = sessionMetadata;
-    let account;
+    const authProvider = sessionMetadata.modelProvider ?? this.codexAcpClient.getModelProvider();
+    let authState;
     try {
-      account = await this.getActiveAccount();
+      authState = await this.getAuthStateForProvider(authProvider);
     } catch (err) {
       if (resumeSubscribed && requestedSessionGeneration !== null) {
         await this.cleanupStaleSessionOpen(sessionId, requestedSessionGeneration);
@@ -26436,7 +26829,9 @@ You have been logged out. Please try again.`);
       totalTokenUsage: null,
       modelContextWindow: null,
       rateLimits: null,
-      account,
+      account: authState.account,
+      authConfigured: authState.authConfigured,
+      authProvider,
       cwd: request.cwd,
       additionalDirectories: sessionMetadata.additionalDirectories,
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
@@ -26453,17 +26848,38 @@ You have been logged out. Please try again.`);
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    this.publishAvailableCommandsAsync(sessionId);
+    this.publishAvailableCommandsAsync(sessionState);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return [sessionId, sessionModelState, sessionModeState];
   }
-  async getActiveAccount() {
-    if (this.codexAcpClient.getModelProvider()) {
-      return null;
+  async getAuthStateForProvider(authProvider) {
+    if (!this.authProviderUsesOpenAiAccount(authProvider)) {
+      return {
+        account: null,
+        authConfigured: true
+      };
     }
     const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
-    return accountResponse.account;
+    return {
+      account: accountResponse.account,
+      authConfigured: accountResponse.account !== null || !accountResponse.requiresOpenaiAuth
+    };
+  }
+  authProviderUsesOpenAiAccount(authProvider) {
+    return authProvider === null || authProvider === "openai";
+  }
+  authProvidersMatch(a, b) {
+    if (this.authProviderUsesOpenAiAccount(a) && this.authProviderUsesOpenAiAccount(b)) {
+      return true;
+    }
+    return a === b;
+  }
+  getAuthProviderForAuthenticateRequest(request) {
+    if (isCodexAuthRequest(request) && request.methodId === "gateway") {
+      return "custom-gateway";
+    }
+    return null;
   }
   async loadSession(params) {
     logger.log("Loading session...", { sessionId: params.sessionId });
@@ -26592,14 +27008,26 @@ You have been logged out. Please try again.`);
       logger.log("Authenticate request failed");
       throw RequestError.invalidParams();
     }
+    await this.refreshSessionsAuthState(this.getAuthProviderForAuthenticateRequest(_params));
     logger.log("Authenticate request completed");
     return {};
   }
   async logout(_params) {
     logger.log("Logout request received");
     await this.runWithProcessCheck(() => this.codexAcpClient.logout());
+    await this.refreshSessionsAuthState(null);
     logger.log("Logout request completed");
   }
+  async refreshSessionsAuthState(authProvider) {
+    if (this.sessions.size === 0) return;
+    const sessionsToRefresh = [...this.sessions.values()].filter((sessionState) => this.authProvidersMatch(sessionState.authProvider, authProvider));
+    if (sessionsToRefresh.length === 0) return;
+    const authState = await this.getAuthStateForProvider(authProvider);
+    for (const sessionState of sessionsToRefresh) {
+      sessionState.account = authState.account;
+      sessionState.authConfigured = authState.authConfigured;
+    }
+  }
   async setSessionMode(_params) {
     logger.log("Set session mode requested", {
       sessionId: _params.sessionId,
@@ -26657,6 +27085,10 @@ You have been logged out. Please try again.`);
   applyModelChange(sessionState, value) {
     const model = sessionState.availableModels.find((m) => m.id === value);
     if (!model) {
+      const currentModel = ModelId.fromString(sessionState.currentModelId).model;
+      if (value === currentModel) {
+        return;
+      }
       throw RequestError.invalidParams();
     }
     const currentEffort = ModelId.fromString(sessionState.currentModelId).effort;
@@ -26715,12 +27147,19 @@ You have been logged out. Please try again.`);
   }
   createSessionConfigOptions(sessionState) {
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
-    return [
+    const configOptions = [
       sessionState.agentMode.toConfigOption(),
-      createModelConfigOption(sessionState.availableModels, currentModelId.model),
-      createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort),
-      createFastModeConfigOption(sessionState.fastModeEnabled)
+      createModelConfigOption(sessionState.availableModels, currentModelId.model)
     ];
+    if (sessionState.supportedReasoningEfforts.length > 0) {
+      configOptions.push(
+        createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort)
+      );
+    }
+    if (sessionState.currentModelSupportsFast) {
+      configOptions.push(createFastModeConfigOption(sessionState.fastModeEnabled));
+    }
+    return configOptions;
   }
   createSessionConfigOptionsResponse(sessionState) {
     if (!this.isSessionConfigEnabled()) {
@@ -26733,8 +27172,8 @@ You have been logged out. Please try again.`);
   isSessionConfigEnabled() {
     return !isJetBrains2026_1Client(this.clientInfo);
   }
-  publishAvailableCommandsAsync(sessionId) {
-    void this.availableCommands.publish(sessionId);
+  publishAvailableCommandsAsync(sessionState) {
+    void this.availableCommands.publish(sessionState);
   }
   findCurrentModel(models, currentModelId) {
     const modelId = ModelId.fromString(currentModelId);
@@ -26777,9 +27216,10 @@ You have been logged out. Please try again.`);
       throw err;
     }
     const { sessionId, currentModelId, models, thread } = sessionMetadata;
-    let account;
+    const authProvider = sessionMetadata.modelProvider ?? this.codexAcpClient.getModelProvider();
+    let authState;
     try {
-      account = await this.getActiveAccount();
+      authState = await this.getAuthStateForProvider(authProvider);
     } catch (err) {
       if (subscribed) {
         await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
@@ -26805,7 +27245,9 @@ You have been logged out. Please try again.`);
       totalTokenUsage: null,
       modelContextWindow: null,
       rateLimits: null,
-      account,
+      account: authState.account,
+      authConfigured: authState.authConfigured,
+      authProvider,
       cwd: request.cwd,
       additionalDirectories: sessionMetadata.additionalDirectories,
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
@@ -26822,7 +27264,7 @@ You have been logged out. Please try again.`);
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    await this.availableCommands.publish(sessionId);
+    await this.availableCommands.publish(sessionState);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return {
@@ -26881,7 +27323,7 @@ You have been logged out. Please try again.`);
       case "dynamicToolCall":
         return [await createDynamicToolCallUpdate(item)];
       case "collabAgentToolCall":
-        return [this.createCollabAgentToolCallUpdate(item)];
+        return [createCollabAgentToolCallUpdate(item)];
       case "webSearch":
         return [this.createWebSearchUpdate(item)];
       case "imageView":
@@ -26918,22 +27360,6 @@ You have been logged out. Please try again.`);
       content: { type: "text", text }
     }));
   }
-  createCollabAgentToolCallUpdate(item) {
-    return {
-      sessionUpdate: "tool_call",
-      toolCallId: item.id,
-      kind: "other",
-      title: `collab.${item.tool}`,
-      status: this.toAcpToolCallStatus(item.status),
-      rawInput: {
-        prompt: item.prompt,
-        senderThreadId: item.senderThreadId,
-        receiverThreadIds: item.receiverThreadIds,
-        agentsStates: item.agentsStates,
-        status: item.status
-      }
-    };
-  }
   createWebSearchUpdate(item) {
     return {
       sessionUpdate: "tool_call",
@@ -26975,16 +27401,6 @@ ${item.text}`
       }
     };
   }
-  toAcpToolCallStatus(status) {
-    switch (status) {
-      case "inProgress":
-        return "in_progress";
-      case "completed":
-        return "completed";
-      case "failed":
-        return "failed";
-    }
-  }
   userInputToContentBlocks(input) {
     switch (input.type) {
       case "text":
@@ -27080,16 +27496,33 @@ ${item.text}`
     const closeSignal = new Promise((resolve) => {
       resolveCloseSignal = resolve;
     });
+    let resolveCancelSignal = () => {
+    };
+    const cancelSignal = new Promise((resolve) => {
+      resolveCancelSignal = resolve;
+    });
+    const abortController = new AbortController();
     let completed = false;
     let closeRequested = false;
     const activePrompt = {
       completion,
       closeSignal,
+      cancelSignal,
+      signal: abortController.signal,
+      currentTurn: null,
+      requestCancel: () => {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        abortController.abort();
+        resolveCancelSignal(null);
+      },
       requestClose: () => {
         if (closeRequested) {
           return;
         }
         closeRequested = true;
+        activePrompt.requestCancel();
         resolveCloseSignal(null);
       },
       complete: () => {
@@ -27106,6 +27539,40 @@ ${item.text}`
     this.activePrompts.set(sessionId, activePrompt);
     return activePrompt;
   }
+  cancelBeforeTurnStarted(activePrompt) {
+    return activePrompt.cancelSignal.then(() => {
+      if (activePrompt.currentTurn === null) {
+        return null;
+      }
+      return new Promise(() => {
+      });
+    });
+  }
+  observePromptRequestCancellation(signal, sessionState, activePrompt) {
+    if (!signal) {
+      return () => {
+      };
+    }
+    const onAbort = () => {
+      if (this.activePrompts.get(sessionState.sessionId) !== activePrompt) {
+        return;
+      }
+      logger.log("Prompt request cancelled", { sessionId: sessionState.sessionId });
+      activePrompt.requestCancel();
+      const turn = activePrompt.currentTurn;
+      if (!turn) {
+        return;
+      }
+      void this.requestTurnInterrupt(turn, "Cancel");
+    };
+    if (signal.aborted) {
+      onAbort();
+      return () => {
+      };
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+  }
   createPendingTurnStart() {
     let resolve = () => {
     };
@@ -27114,25 +27581,39 @@ ${item.text}`
     });
     return { promise: promise2, resolve };
   }
-  interruptLateStartedTurn(sessionId, turnId) {
+  async interruptPromptTurn(turn, requestName) {
     this.codexAcpClient.markTurnStale({
-      threadId: sessionId,
-      turnId
+      threadId: turn.threadId,
+      turnId: turn.turnId
     });
-    void this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
-      threadId: sessionId,
-      turnId
-    })).catch((err) => {
-      logger.error(`Close - late turnInterrupt failed`, err);
-    }).finally(() => {
+    try {
+      await this.requestTurnInterrupt(turn, requestName);
+    } finally {
       this.codexAcpClient.resolveTurnInterrupted({
-        threadId: sessionId,
-        turnId
+        threadId: turn.threadId,
+        turnId: turn.turnId
       });
-    });
+    }
+  }
+  async requestTurnInterrupt(turn, requestName) {
+    try {
+      await this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
+        threadId: turn.threadId,
+        turnId: turn.turnId
+      }));
+      logger.log(`${requestName} - turnInterrupt succeeded`, {
+        sessionId: turn.threadId,
+        currentTurnId: turn.turnId
+      });
+    } catch (err) {
+      logger.error(`${requestName} - turnInterrupt failed`, err);
+    }
   }
-  promptIsClosedOrStale(sessionId, activePrompt) {
-    return this.activePrompts.get(sessionId) !== activePrompt || this.sessionIsClosing(sessionId);
+  interruptLateStartedTurn(turn) {
+    void this.interruptPromptTurn(turn, "Close");
+  }
+  promptShouldStop(sessionId, activePrompt) {
+    return activePrompt.signal.aborted || this.activePrompts.get(sessionId) !== activePrompt || this.sessionIsClosing(sessionId);
   }
   async interruptSessionTurn(sessionState, requestName, resolveInterruptedTurn) {
     const turnId = await this.getInterruptibleTurnId(sessionState, requestName);
@@ -27188,7 +27669,7 @@ ${item.text}`
     }
     return turnId;
   }
-  async prompt(params) {
+  async prompt(params, signal) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
       prompt: params.prompt
@@ -27198,10 +27679,18 @@ ${item.text}`
     sessionState.lastTokenUsage = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
     let pendingTurnStart = null;
+    const ensurePendingTurnStart = () => {
+      if (pendingTurnStart === null) {
+        pendingTurnStart = this.createPendingTurnStart();
+        this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      }
+      return pendingTurnStart;
+    };
+    const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     try {
       const eventHandler = new CodexEventHandler(this.connection, sessionState);
-      const approvalHandler = new CodexApprovalHandler(this.connection, sessionState);
-      const elicitationHandler = new CodexElicitationHandler(this.connection, sessionState);
+      const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
+      const elicitationHandler = new CodexElicitationHandler(this.connection, sessionState, activePrompt.signal);
       await this.codexAcpClient.subscribeToSessionEvents(
         params.sessionId,
         (event) => {
@@ -27211,28 +27700,43 @@ ${item.text}`
         approvalHandler,
         elicitationHandler
       );
-      const commandResult = await this.availableCommands.tryHandleCommand(params.prompt, sessionState);
+      if (activePrompt.signal.aborted) {
+        return this.cancelledPromptResponse(sessionState);
+      }
+      const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+        onTurnStartPending: () => {
+          ensurePendingTurnStart();
+        },
+        onTurnStarted: (turnId, threadId) => {
+          const turn = { threadId, turnId };
+          activePrompt.currentTurn = turn;
+          if (this.promptShouldStop(params.sessionId, activePrompt)) {
+            this.interruptLateStartedTurn(turn);
+            return;
+          }
+          sessionState.currentTurnId = turnId;
+          pendingTurnStart?.resolve(turnId);
+        }
+      });
+      void commandPromise.catch((err) => {
+        if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+          logger.error(`Command for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
+        }
+      });
+      const commandResult = await Promise.race([
+        commandPromise,
+        activePrompt.closeSignal,
+        this.cancelBeforeTurnStarted(activePrompt)
+      ]);
+      if (commandResult === null) {
+        return this.cancelledPromptResponse(sessionState);
+      }
       if (commandResult.handled) {
         logger.log("Prompt handled by a command");
         await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
         if (commandResult.turnCompleted?.turn.status === "interrupted") {
-          if (!this.sessionIsClosing(params.sessionId) && this.sessions.has(params.sessionId)) {
-            await this.connection.notify(methods.client.session.update, {
-              sessionId: params.sessionId,
-              update: {
-                sessionUpdate: "agent_message_chunk",
-                content: {
-                  type: "text",
-                  text: "*Conversation interrupted*"
-                }
-              }
-            });
-          }
-          return {
-            stopReason: "cancelled",
-            usage: this.buildPromptUsage(sessionState.lastTokenUsage),
-            _meta: this.buildQuotaMeta(sessionState)
-          };
+          await this.notifyConversationInterrupted(params.sessionId);
+          return this.cancelledPromptResponse(sessionState);
         }
         const error52 = eventHandler.getFailure();
         if (error52) {
@@ -27245,11 +27749,7 @@ ${item.text}`
         };
       }
       if (this.sessionIsClosing(params.sessionId)) {
-        return {
-          stopReason: "cancelled",
-          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
-          _meta: this.buildQuotaMeta(sessionState)
-        };
+        return this.cancelledPromptResponse(sessionState);
       }
       const modelId = ModelId.fromString(sessionState.currentModelId);
       const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0 && sessionState.supportedReasoningEfforts.every((e) => e.reasoningEffort === "none");
@@ -27268,8 +27768,7 @@ ${item.text}`
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
       );
-      pendingTurnStart = this.createPendingTurnStart();
-      this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           params,
@@ -27280,51 +27779,35 @@ ${item.text}`
           sessionState.cwd,
           sessionState.additionalDirectories,
           (turnId) => {
-            if (this.promptIsClosedOrStale(params.sessionId, activePrompt)) {
-              this.interruptLateStartedTurn(params.sessionId, turnId);
+            const turn = { threadId: params.sessionId, turnId };
+            activePrompt.currentTurn = turn;
+            if (this.promptShouldStop(params.sessionId, activePrompt)) {
+              this.interruptLateStartedTurn(turn);
               return;
             }
             sessionState.currentTurnId = turnId;
             pendingTurnStart?.resolve(turnId);
           },
-          () => this.promptIsClosedOrStale(params.sessionId, activePrompt)
+          () => this.promptShouldStop(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);
+          logger.error(`Prompt for cancelled session ${params.sessionId} failed after prompt returned`, err);
         }
       });
       const turnCompleted = await Promise.race([
         sendPromptPromise,
-        activePrompt.closeSignal
+        activePrompt.closeSignal,
+        this.cancelBeforeTurnStarted(activePrompt)
       ]);
       if (turnCompleted === null) {
-        return {
-          stopReason: "cancelled",
-          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
-          _meta: this.buildQuotaMeta(sessionState)
-        };
+        return this.cancelledPromptResponse(sessionState);
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
-        if (!this.sessionIsClosing(params.sessionId) && this.sessions.has(params.sessionId)) {
-          await this.connection.notify(methods.client.session.update, {
-            sessionId: params.sessionId,
-            update: {
-              sessionUpdate: "agent_message_chunk",
-              content: {
-                type: "text",
-                text: "*Conversation interrupted*"
-              }
-            }
-          });
-        }
-        return {
-          stopReason: "cancelled",
-          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
-          _meta: this.buildQuotaMeta(sessionState)
-        };
+        await this.notifyConversationInterrupted(params.sessionId);
+        return this.cancelledPromptResponse(sessionState);
       }
       const error51 = eventHandler.getFailure();
       if (error51) {
@@ -27340,14 +27823,38 @@ ${item.text}`
       throw err;
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
+      disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
-      if (pendingTurnStart !== null && this.pendingTurnStarts.get(params.sessionId) === pendingTurnStart) {
+      const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
+      if (registeredPendingTurnStart !== void 0) {
         this.pendingTurnStarts.delete(params.sessionId);
+        registeredPendingTurnStart.resolve(null);
       }
-      pendingTurnStart?.resolve(null);
       activePrompt.complete();
     }
   }
+  cancelledPromptResponse(sessionState) {
+    return {
+      stopReason: "cancelled",
+      usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+      _meta: this.buildQuotaMeta(sessionState)
+    };
+  }
+  async notifyConversationInterrupted(sessionId) {
+    if (this.sessionIsClosing(sessionId) || !this.sessions.has(sessionId)) {
+      return;
+    }
+    await this.connection.notify(methods.client.session.update, {
+      sessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: {
+          type: "text",
+          text: "*Conversation interrupted*"
+        }
+      }
+    });
+  }
   buildQuotaMeta(sessionState) {
     const lastTokenUsage = sessionState.lastTokenUsage;
     const modelName = sessionState.currentModelId.replace(/\[.*?]$/, "");
@@ -27454,6 +27961,7 @@ var CommandExecutionApprovalRequest = new import_node2.RequestType("item/command
 var FileChangeApprovalRequest = new import_node2.RequestType("item/fileChange/requestApproval");
 var PermissionsApprovalRequest = new import_node2.RequestType("item/permissions/requestApproval");
 var McpServerElicitationRequest = new import_node2.RequestType("mcpServer/elicitation/request");
+var GOAL_RUNTIME_EFFECTS_GRACE_MS = 1e3;
 var CodexAppServerClient = class {
   connection;
   approvalHandlers = /* @__PURE__ */ new Map();
@@ -27464,6 +27972,10 @@ var CodexAppServerClient = class {
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   pendingCompactionCompletionResolvers = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
+  turnRoutingCaptures = /* @__PURE__ */ new Map();
+  threadStatusCaptures = /* @__PURE__ */ new Map();
+  threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
+  threadGoalClearedCaptures = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
@@ -27484,15 +27996,21 @@ var CodexAppServerClient = class {
       if (isCompactionCompletedNotification(serverNotification)) {
         this.recordCompactionCompleted(serverNotification);
       }
+      if (isThreadStatusChangedNotification(serverNotification)) {
+        this.recordThreadStatusChanged(serverNotification.params);
+      }
+      if (isThreadGoalUpdatedNotification(serverNotification)) {
+        this.recordThreadGoalUpdated(serverNotification.params);
+      }
+      if (isThreadGoalClearedNotification(serverNotification)) {
+        this.recordThreadGoalCleared(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 });
-        }
+      if (this.handleStaleTurnNotification(serverNotification, routing)) {
+        return;
+      }
+      this.recordTurnRouting(routing);
+      if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
       }
       this.notify(serverNotification);
@@ -27583,7 +28101,7 @@ var CodexAppServerClient = class {
     });
     try {
       const reviewStarted = await this.reviewStart(params);
-      onTurnStarted?.(reviewStarted.turn.id);
+      onTurnStarted?.(reviewStarted.turn.id, reviewStarted.reviewThreadId);
       const earlyCompletion = capturedCompletions.find((event) => event.turn.id === reviewStarted.turn.id);
       releaseCapture();
       if (earlyCompletion) {
@@ -27594,6 +28112,174 @@ var CodexAppServerClient = class {
       releaseCapture();
     }
   }
+  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS) {
+    let goalTurnId = null;
+    const capturedCompletions = [];
+    let resolveGoalTurnCompleted = () => {
+    };
+    const goalTurnCompleted = new Promise((resolve) => {
+      resolveGoalTurnCompleted = resolve;
+    });
+    const releaseCompletionCapture = this.captureTurnCompletions(params.threadId, (event) => {
+      capturedCompletions.push(event);
+      if (goalTurnId === event.turn.id) {
+        resolveGoalTurnCompleted(event);
+      }
+    });
+    let resolveGoalTurnStarted = () => {
+    };
+    const goalTurnStarted = new Promise((resolve) => {
+      resolveGoalTurnStarted = resolve;
+    });
+    let resolveGoalUpdateHandled = () => {
+    };
+    const matchingGoalUpdateHandled = new Promise((resolve) => {
+      resolveGoalUpdateHandled = () => resolve(null);
+    });
+    let goalUpdateHandled = false;
+    let expectedGoal = null;
+    const noGoalTurnStarted = this.createNoGoalTurnStartedPromise(runtimeEffectsGraceMs);
+    const capturedGoalUpdates = [];
+    const releaseRoutingCapture = this.captureTurnRoutings(params.threadId, (turnId) => {
+      if (!goalUpdateHandled || goalTurnId !== null) {
+        return;
+      }
+      goalTurnId = turnId;
+      onTurnStarted?.(turnId);
+      resolveGoalTurnStarted(turnId);
+    });
+    const releaseGoalUpdateCapture = this.captureThreadGoalUpdates(params.threadId, (event) => {
+      capturedGoalUpdates.push(event);
+      if (expectedGoal !== null && goalsMatch(event.goal, expectedGoal)) {
+        goalUpdateHandled = true;
+        resolveGoalUpdateHandled();
+        noGoalTurnStarted.goalUpdated();
+      }
+    });
+    const releaseStatusCapture = this.captureThreadStatuses(params.threadId, (status) => {
+      if (!goalUpdateHandled || goalTurnId !== null) {
+        return;
+      }
+      noGoalTurnStarted.threadStatusChanged(status);
+    });
+    try {
+      const goalSetResponse = await this.threadGoalSet(params);
+      expectedGoal = goalSetResponse.goal;
+      if (capturedGoalUpdates.some((event) => goalsMatch(event.goal, expectedGoal))) {
+        goalUpdateHandled = true;
+        resolveGoalUpdateHandled();
+        noGoalTurnStarted.goalUpdated();
+      }
+      if (expectedGoal.status !== "active") {
+        await matchingGoalUpdateHandled;
+        return null;
+      }
+      const turnId = goalTurnId ?? await Promise.race([goalTurnStarted, noGoalTurnStarted.promise]);
+      noGoalTurnStarted.release();
+      releaseRoutingCapture();
+      releaseStatusCapture();
+      releaseGoalUpdateCapture();
+      if (turnId === null) {
+        return null;
+      }
+      const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnId);
+      if (earlyCompletion) {
+        return earlyCompletion;
+      }
+      return await goalTurnCompleted;
+    } finally {
+      noGoalTurnStarted.release();
+      releaseCompletionCapture();
+      releaseRoutingCapture();
+      releaseStatusCapture();
+      releaseGoalUpdateCapture();
+    }
+  }
+  async runGoalClear(params) {
+    let goalClearedHandled = false;
+    let resolveGoalClearedHandled = () => {
+    };
+    const matchingGoalClearedHandled = new Promise((resolve) => {
+      resolveGoalClearedHandled = () => resolve();
+    });
+    const releaseGoalClearedCapture = this.captureThreadGoalClears(params.threadId, () => {
+      goalClearedHandled = true;
+      resolveGoalClearedHandled();
+    });
+    try {
+      const response = await this.threadGoalClear(params);
+      if (!response.cleared || goalClearedHandled) {
+        return;
+      }
+      await matchingGoalClearedHandled;
+    } finally {
+      releaseGoalClearedCapture();
+    }
+  }
+  createNoGoalTurnStartedPromise(runtimeEffectsGraceMs) {
+    let released = false;
+    let resolved = false;
+    let goalUpdated = false;
+    let activeAfterGoalUpdate = false;
+    let timeout = null;
+    let resolveNoGoalTurnStarted = () => {
+    };
+    const clearTimer = () => {
+      if (timeout !== null) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+    const resolveNoTurn = () => {
+      if (released || resolved) {
+        return;
+      }
+      resolved = true;
+      clearTimer();
+      resolveNoGoalTurnStarted();
+    };
+    const scheduleNoTurnTimer = () => {
+      if (released || resolved || !goalUpdated || activeAfterGoalUpdate || timeout !== null) {
+        return;
+      }
+      timeout = setTimeout(resolveNoTurn, runtimeEffectsGraceMs);
+    };
+    const release = () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      clearTimer();
+    };
+    const promise2 = new Promise((resolve) => {
+      resolveNoGoalTurnStarted = () => {
+        resolve(null);
+      };
+    });
+    const handleGoalUpdated = () => {
+      goalUpdated = true;
+      scheduleNoTurnTimer();
+    };
+    const handleThreadStatusChanged = (status) => {
+      if (!goalUpdated || released || resolved) {
+        return;
+      }
+      if (status.type === "active") {
+        activeAfterGoalUpdate = true;
+        clearTimer();
+        return;
+      }
+      if (activeAfterGoalUpdate) {
+        resolveNoTurn();
+      }
+    };
+    return {
+      promise: promise2,
+      release,
+      goalUpdated: handleGoalUpdated,
+      threadStatusChanged: handleThreadStatusChanged
+    };
+  }
   async runCompact(params) {
     const compactionCompleted = this.awaitCompactionCompleted(params.threadId);
     await this.threadCompactStart(params);
@@ -27634,6 +28320,12 @@ var CodexAppServerClient = class {
   async threadCompactStart(params) {
     return await this.sendRequest({ method: "thread/compact/start", params });
   }
+  async threadGoalSet(params) {
+    return await this.sendRequest({ method: "thread/goal/set", params });
+  }
+  async threadGoalClear(params) {
+    return await this.sendRequest({ method: "thread/goal/clear", params });
+  }
   async listMcpServerStatus(params) {
     return await this.sendRequest({ method: "mcpServerStatus/list", params });
   }
@@ -27765,6 +28457,57 @@ var CodexAppServerClient = class {
       resolve(event);
     }
   }
+  recordThreadStatusChanged(event) {
+    const captures = this.threadStatusCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(event.status);
+    }
+  }
+  recordThreadGoalUpdated(event) {
+    const captures = this.threadGoalUpdateCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(event);
+    }
+  }
+  recordThreadGoalCleared(event) {
+    const captures = this.threadGoalClearedCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture();
+    }
+  }
+  recordTurnRouting(routing) {
+    if (routing.threadId === null || routing.turnId === null) {
+      return;
+    }
+    const captures = this.turnRoutingCaptures.get(routing.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(routing.turnId);
+    }
+  }
+  handleStaleTurnNotification(notification, routing) {
+    if (!this.isStaleTurn(routing.threadId, routing.turnId)) {
+      return false;
+    }
+    if (isTurnCompletedNotification(notification) && routing.threadId !== null && routing.turnId !== null) {
+      this.clearStaleTurn(routing.threadId, routing.turnId);
+    }
+    for (const callback of this.codexEventHandlers) {
+      callback({ eventType: "notification", ...notification });
+    }
+    return true;
+  }
   isStaleTurn(threadId, turnId) {
     if (threadId === null || turnId === null) {
       return false;
@@ -27806,6 +28549,70 @@ var CodexAppServerClient = class {
       }
     };
   }
+  captureTurnRoutings(threadId, capture) {
+    const captures = this.turnRoutingCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.turnRoutingCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.turnRoutingCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadStatuses(threadId, capture) {
+    const captures = this.threadStatusCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadStatusCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadStatusCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadGoalUpdates(threadId, capture) {
+    const captures = this.threadGoalUpdateCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadGoalUpdateCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadGoalUpdateCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadGoalClears(threadId, capture) {
+    const captures = this.threadGoalClearedCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadGoalClearedCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadGoalClearedCaptures.delete(threadId);
+      }
+    };
+  }
   resolveMcpServerStartupResolvers() {
     const pendingResolvers = [];
     for (const resolver of this.mcpServerStartupResolvers) {
@@ -27868,12 +28675,24 @@ function isMcpServerStatusUpdatedNotification(notification) {
 function isTurnCompletedNotification(notification) {
   return notification.method === "turn/completed";
 }
+function isThreadStatusChangedNotification(notification) {
+  return notification.method === "thread/status/changed";
+}
+function isThreadGoalUpdatedNotification(notification) {
+  return notification.method === "thread/goal/updated";
+}
+function isThreadGoalClearedNotification(notification) {
+  return notification.method === "thread/goal/cleared";
+}
 function isCompactionCompletedNotification(notification) {
   if (notification.method === "thread/compacted") {
     return true;
   }
   return notification.method === "item/completed" && notification.params.item.type === "contextCompaction";
 }
+function goalsMatch(left, right) {
+  return left.threadId === right.threadId && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.updatedAt === right.updatedAt;
+}
 function extractThreadId(notification) {
   const params = notification.params;
   if (params && typeof params.threadId === "string") {
@@ -28075,7 +28894,7 @@ function startAcpServer() {
   codexConnection.process.stderr.addListener("data", (data) => {
     stderr = (stderr + data.toString()).slice(-maxStderrTailChars);
   });
-  process.stdin.on("close", (chunk) => {
+  process.stdin.on("close", () => {
     codexConnection.process.stdin.end();
     setTimeout(() => {
       if (!codexConnection.process.killed) {
@@ -28105,5 +28924,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.session.prompt, (ctx) => getAgent().prompt(ctx.params)).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)).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.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)).connect(acpJsonStream);
 }