lody 0.69.0 → 0.70.0

package/dist/chunks/{index-DjSKImM-.js → index-DgU7G-DU.js}

@@ -20801,6 +20801,22 @@ var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
 var ACP_EXT_SESSION_USAGE_UPDATE_METHOD = "_acp_ext:session_usage_update";
 var ACP_EXT_SESSION_RATE_LIMITS_METHOD = "_acp_ext:session_rate_limits";
 var ACP_EXT_CODEX_PROPOSED_PLAN_METHOD = "_acp_ext:codex_proposed_plan";
+var CODEX_STEER_APPLIED_METHOD = "_codex/steerApplied";
+var CODEX_STEER_CAPABILITY = {
+  version: 1,
+  appliedNotification: CODEX_STEER_APPLIED_METHOD,
+  upstreamTurn: "same",
+  configPolicy: "active"
+};
+function getCodexSteerId(meta3) {
+  if (typeof meta3 !== "object" || meta3 === null) return null;
+  const codex = meta3["codex"];
+  if (typeof codex !== "object" || codex === null) return null;
+  const steer = codex["steer"];
+  if (typeof steer !== "object" || steer === null) return null;
+  const id = steer["id"];
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
 function isExtMethodRequest(request) {
   return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD;
 }
@@ -21442,6 +21458,7 @@ function createTerminalOutputMeta(mode, terminalId, data) {
       };
   }
 }
+var CONTEXT_COMPACTION_META = { contextCompaction: true };
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -21584,6 +21601,35 @@ function createImageGenerationUpdate(item, options) {
     rawOutput: imageGenerationRawOutput(item)
   };
 }
+function createContextCompactionStartUpdate(item) {
+  return {
+    sessionUpdate: "tool_call",
+    toolCallId: item.id,
+    kind: "other",
+    title: "Context compacting",
+    status: "in_progress",
+    _meta: CONTEXT_COMPACTION_META
+  };
+}
+function createContextCompactionCompleteUpdate(item) {
+  return {
+    sessionUpdate: "tool_call_update",
+    toolCallId: item.id,
+    title: "Context compacted",
+    status: "completed",
+    _meta: CONTEXT_COMPACTION_META
+  };
+}
+function createCompletedContextCompactionUpdate(item) {
+  return {
+    sessionUpdate: "tool_call",
+    toolCallId: item.id,
+    kind: "other",
+    title: "Context compacted",
+    status: "completed",
+    _meta: CONTEXT_COMPACTION_META
+  };
+}
 async function createExecuteToolCallUpdate(item, title, rawInput, rawOutput) {
   return {
     sessionUpdate: "tool_call",
@@ -22063,6 +22109,69 @@ async function readFileContent(filePath) {
 function recoverCorruptedDiff(diff) {
   return diff.replace(/\n\nMoved to: .*$/, "");
 }
+var COMPLETE_EMPTY_COMMENT = /^<!--\s*(?:\*\/\s*)?-->\s*$/u;
+var PARTIAL_COMMENT_BODY = /^\s*(?:\*\/?\s*)?$/u;
+var PARTIAL_COMMENT_CLOSE = /^\s*(?:\*\/\s*)?-{1,2}$/u;
+var isHorizontalWhitespace = (char) => char === " " || char === "	";
+var canBecomeEmptyComment = (text) => {
+  if (text === "<" || text === "<!" || text === "<!-") {
+    return true;
+  }
+  if (!text.startsWith("<!--")) {
+    return false;
+  }
+  const tail = text.slice(4);
+  return COMPLETE_EMPTY_COMMENT.test(text) || PARTIAL_COMMENT_BODY.test(tail) || PARTIAL_COMMENT_CLOSE.test(tail);
+};
+var ReasoningSummaryFilter = class {
+  pending = "";
+  lineHasContent = false;
+  push(delta) {
+    let output = "";
+    const emit = (text) => {
+      output += text;
+      for (const char of text) {
+        if (char === "\n" || char === "\r") {
+          this.lineHasContent = false;
+        } else if (!isHorizontalWhitespace(char)) {
+          this.lineHasContent = true;
+        }
+      }
+    };
+    for (const char of delta) {
+      if (this.pending) {
+        this.pending += char;
+        if (canBecomeEmptyComment(this.pending)) {
+          continue;
+        }
+        emit(this.pending);
+        this.pending = "";
+        continue;
+      }
+      if (char === "<" && !this.lineHasContent) {
+        this.pending = char;
+      } else {
+        emit(char);
+      }
+    }
+    return output;
+  }
+  finish() {
+    const output = COMPLETE_EMPTY_COMMENT.test(this.pending) ? "" : this.pending;
+    this.pending = "";
+    this.lineHasContent = false;
+    return output;
+  }
+};
+function stripEmptyReasoningComments(text) {
+  const filter = new ReasoningSummaryFilter();
+  return filter.push(text) + filter.finish();
+}
+function sanitizeReasoningParts(summary, content) {
+  const useSummary = summary.length > 0;
+  const parts = useSummary ? summary : content;
+  return parts.map((part) => useSummary ? stripEmptyReasoningComments(part) : part).filter((part) => part.length > 0);
+}
 function createCodexMessagePhaseMeta(phase) {
   if (!phase) {
     return void 0;
@@ -22129,6 +22238,7 @@ var CodexEventHandler = class {
   activeImageGenerationItems = /* @__PURE__ */ new Set();
   emittedImageViewItems = /* @__PURE__ */ new Set();
   seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
+  reasoningSummaryFilters = /* @__PURE__ */ new Map();
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   proposedPlanMarkdown = "";
@@ -22142,6 +22252,10 @@ var CodexEventHandler = class {
     return this.failure;
   }
   async handleNotification(notification) {
+    if (notification.method === "account/rateLimits/updated") {
+      await this.handleRateLimitsSnapshot(notification.params.rateLimits, true);
+      return;
+    }
     const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
@@ -22170,6 +22284,8 @@ var CodexEventHandler = class {
       case "thread/tokenUsage/updated":
         return this.createUsageUpdate(notification.params);
       case "thread/name/updated":
+        this.sessionState.sessionTitle = notification.params.threadName ?? null;
+        this.sessionState.sessionTitleSource = notification.params.threadName == null ? "unset" : "explicit";
         return {
           sessionUpdate: "session_info_update",
           title: notification.params.threadName ?? null
@@ -22195,7 +22311,6 @@ var CodexEventHandler = class {
       case "item/mcpToolCall/progress":
         return this.createMcpToolProgressEvent(notification.params);
       case "account/rateLimits/updated":
-        this.handleRateLimitsUpdated(notification.params);
         return null;
       case "configWarning":
         return await this.createConfigWarningEvent(notification.params);
@@ -22210,9 +22325,9 @@ var CodexEventHandler = class {
       case "thread/compacted":
         return this.createContextCompactedEvent();
       case "item/reasoning/summaryTextDelta":
-        return this.createReasoningDeltaEvent(notification.params);
+        return this.createReasoningSummaryDeltaEvent(notification.params);
       case "item/reasoning/textDelta":
-        return this.createReasoningDeltaEvent(notification.params);
+        return this.createRawReasoningDeltaEvent(notification.params);
       case "item/reasoning/summaryPartAdded":
         return this.createReasoningSectionBreakEvent(notification.params);
       case "model/rerouted":
@@ -22277,12 +22392,6 @@ var CodexEventHandler = class {
           this.createSessionUsageExtNotification(notification.params)
         );
         return;
-      case "account/rateLimits/updated":
-        await this.notifyExt(
-          ACP_EXT_SESSION_RATE_LIMITS_METHOD,
-          this.createSessionRateLimitsExtNotification(notification.params)
-        );
-        return;
       case "item/plan/delta":
         await this.emitCodexProposedPlanDelta(notification.params);
         return;
@@ -22344,16 +22453,26 @@ var CodexEventHandler = class {
       isLatest: true
     };
   }
-  createSessionRateLimitsExtNotification(params) {
-    const rateLimits = params.rateLimits;
+  createSessionRateLimitsExtNotification(rateLimits) {
+    const windows = [rateLimits.primary, rateLimits.secondary].filter(
+      (window) => window !== null
+    );
+    const fiveHour = windows.find((window) => window.windowDurationMins === 5 * 60) ?? null;
+    const sevenDay = windows.find((window) => window.windowDurationMins === 7 * 24 * 60) ?? null;
     return {
+      schemaVersion: 2,
       planName: rateLimits.planType,
       limitName: rateLimits.limitName,
       limitId: rateLimits.limitId,
-      fiveHour: rateLimits.primary?.usedPercent ?? null,
-      sevenDay: rateLimits.secondary?.usedPercent ?? null,
-      fiveHourResetAt: rateLimits.primary?.resetsAt ?? null,
-      sevenDayResetAt: rateLimits.secondary?.resetsAt ?? null
+      windows: windows.map((window) => ({
+        usedPercent: window.usedPercent,
+        windowDurationMins: window.windowDurationMins,
+        resetsAt: window.resetsAt
+      })),
+      fiveHour: fiveHour?.usedPercent ?? null,
+      sevenDay: sevenDay?.usedPercent ?? null,
+      fiveHourResetAt: fiveHour?.resetsAt ?? null,
+      sevenDayResetAt: sevenDay?.resetsAt ?? null
     };
   }
   createCodexSessionInfoUpdate(codexMetadata) {
@@ -22415,13 +22534,34 @@ ${event.details}` : "";
   sameThreadGoalSnapshot(left, right) {
     return left !== null && left !== void 0 && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget;
   }
-  createReasoningDeltaEvent(event) {
+  createReasoningSummaryDeltaEvent(event) {
+    this.seenReasoningDeltaItemIds.add(event.itemId);
+    let filter = this.reasoningSummaryFilters.get(event.itemId);
+    if (!filter) {
+      filter = new ReasoningSummaryFilter();
+      this.reasoningSummaryFilters.set(event.itemId, filter);
+    }
+    const text = filter.push(event.delta);
+    return text.length > 0 ? this.createAgentThoughtEvent(text, event.itemId) : null;
+  }
+  createRawReasoningDeltaEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent(event.delta, event.itemId);
   }
   createReasoningSectionBreakEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
-    return this.createAgentThoughtEvent("\n\n", event.itemId);
+    const trailingText = this.finishReasoningSummaryFilter(event.itemId);
+    return this.createAgentThoughtEvent(`${trailingText}
+
+`, event.itemId);
+  }
+  finishReasoningSummaryFilter(itemId) {
+    const filter = this.reasoningSummaryFilters.get(itemId);
+    if (!filter) {
+      return "";
+    }
+    this.reasoningSummaryFilters.delete(itemId);
+    return filter.finish();
   }
   createAgentThoughtEvent(text, messageId) {
     return createAgentTextThoughtChunk(text, messageId);
@@ -22456,6 +22596,8 @@ ${event.details}` : "";
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
+      case "contextCompaction":
+        return createContextCompactionStartUpdate(event.item);
       case "subAgentActivity":
       case "sleep":
       case "userMessage":
@@ -22463,7 +22605,6 @@ ${event.details}` : "";
       case "reasoning":
       case "enteredReviewMode":
       case "exitedReviewMode":
-      case "contextCompaction":
       case "plan":
         return null;
     }
@@ -22499,7 +22640,8 @@ ${event.details}` : "";
         return createImageGenerationUpdate(event.item, { terminalStatus: true });
       case "reasoning":
         if (this.seenReasoningDeltaItemIds.delete(event.item.id)) {
-          return null;
+          const trailingText = this.finishReasoningSummaryFilter(event.item.id);
+          return trailingText.length > 0 ? this.createAgentThoughtEvent(trailingText, event.item.id) : null;
         }
         return this.createCompletedReasoningEvent(event.item);
       case "webSearch":
@@ -22512,7 +22654,7 @@ ${event.details}` : "";
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
-        return this.createContextCompactedEvent();
+        return createContextCompactionCompleteUpdate(event.item);
       //ignored types
       case "subAgentActivity":
       case "sleep":
@@ -22527,8 +22669,7 @@ ${event.details}` : "";
     this.agentMessagePhases.set(item.id, item.phase);
   }
   createCompletedReasoningEvent(item) {
-    const parts = item.summary.length > 0 ? item.summary : item.content;
-    const text = parts.filter((part) => part.length > 0).join("\n\n");
+    const text = sanitizeReasoningParts(item.summary, item.content).join("\n\n");
     if (text.length === 0) {
       return null;
     }
@@ -22662,7 +22803,15 @@ ${event.stdin}
   }
   async createErrorEvent(params) {
     const error48 = params.error.codexErrorInfo;
-    if (error48 === "usageLimitExceeded") {
+    if (params.willRetry) {
+      return this.createCodexSessionInfoUpdate({
+        error: {
+          ...params.error,
+          turnId: params.turnId,
+          willRetry: true
+        }
+      });
+    } else if (error48 === "usageLimitExceeded") {
       this.failure = RequestError.internalError(
         this.createTurnErrorData(params.error)
       );
@@ -22720,16 +22869,36 @@ ${event.stdin}
       size
     };
   }
-  handleRateLimitsUpdated(params) {
+  async handleRateLimitsSnapshot(rateLimits, sparse = false) {
+    const merged = this.storeRateLimitsSnapshot(rateLimits, sparse);
+    await this.notifyExt(
+      ACP_EXT_SESSION_RATE_LIMITS_METHOD,
+      this.createSessionRateLimitsExtNotification(merged)
+    );
+  }
+  storeRateLimitsSnapshot(rateLimits, sparse) {
     if (!this.sessionState.rateLimits) {
       this.sessionState.rateLimits = /* @__PURE__ */ new Map();
     }
-    const limitId = params.rateLimits.limitId ?? params.rateLimits.limitName ?? "unknown";
+    const fallbackLimitId = this.sessionState.rateLimits.size === 1 ? this.sessionState.rateLimits.keys().next().value : null;
+    const limitId = rateLimits.limitId ?? rateLimits.limitName ?? fallbackLimitId ?? "unknown";
+    const existing = this.sessionState.rateLimits.get(limitId)?.snapshot;
+    const snapshot = sparse && existing ? {
+      limitId: rateLimits.limitId ?? existing.limitId,
+      limitName: rateLimits.limitName ?? existing.limitName,
+      primary: rateLimits.primary ?? existing.primary,
+      secondary: rateLimits.secondary ?? existing.secondary,
+      credits: rateLimits.credits ?? existing.credits,
+      individualLimit: rateLimits.individualLimit ?? existing.individualLimit,
+      planType: rateLimits.planType ?? existing.planType,
+      rateLimitReachedType: rateLimits.rateLimitReachedType ?? existing.rateLimitReachedType
+    } : rateLimits;
     this.sessionState.rateLimits.set(limitId, {
       limitId,
-      limitName: params.rateLimits.limitName ?? limitId,
-      snapshot: params.rateLimits
+      limitName: snapshot.limitName ?? limitId,
+      snapshot
     });
+    return snapshot;
   }
   handleFuzzyFileSearchSessionUpdated(params) {
     const toolCallId = fuzzyFileSearchToolCallId(params.sessionId);
@@ -23084,6 +23253,7 @@ var ELICITATION_OPTIONS = [
   { optionId: "accept", name: "Accept", kind: "allow_once" },
   { optionId: "decline", name: "Decline", kind: "reject_once" }
 ];
+var USER_INPUT_OTHER_FIELD_SUFFIX = "__other";
 function parsePersistOptions(meta3) {
   const result = /* @__PURE__ */ new Set();
   if (!meta3 || typeof meta3 !== "object") return result;
@@ -23219,6 +23389,27 @@ function elicitationResponseMeta(response, context, persist = void 0) {
   }
   return Object.keys(meta3).length === 0 ? null : meta3;
 }
+function userInputOtherFieldId(questionId, questionIds) {
+  const base = `${questionId}${USER_INPUT_OTHER_FIELD_SUFFIX}`;
+  if (!questionIds.has(base)) {
+    return base;
+  }
+  let index = 1;
+  while (questionIds.has(`${base}${index}`)) {
+    index += 1;
+  }
+  return `${base}${index}`;
+}
+function userInputResponseValue(content, fieldId) {
+  const value = content[fieldId];
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return void 0;
+  }
+  return value;
+}
 function buildToolApprovalOptions(persistOptions) {
   const options = [
     { optionId: McpApprovalOptionId.AllowOnce, name: "Allow", kind: "allow_once" }
@@ -23315,8 +23506,68 @@ var CodexElicitationHandler = class {
       return { action: "cancel", content: null, _meta: null };
     }
   }
-  requestOptions() {
-    return this.cancellationSignal ? { cancellationSignal: this.cancellationSignal } : void 0;
+  async handleUserInput(params) {
+    if (!clientSupportsFormElicitation(this.clientCapabilities)) {
+      return { answers: {} };
+    }
+    try {
+      const response = await this.requestUserInputElicitation(params);
+      if (response === null) {
+        return { answers: {} };
+      }
+      return this.convertUserInputResponse(response, params);
+    } catch (error48) {
+      logger.error("Error handling Codex user input request", error48);
+      return { answers: {} };
+    }
+  }
+  requestOptions(cancellationSignal = this.cancellationSignal) {
+    return cancellationSignal ? { cancellationSignal } : void 0;
+  }
+  async requestUserInputElicitation(params) {
+    const request = this.buildUserInputRequest(params);
+    if (params.autoResolutionMs === null) {
+      return await this.connection.request(
+        methods.client.elicitation.create,
+        request,
+        this.requestOptions()
+      );
+    }
+    const abortController = new AbortController();
+    let timeout;
+    let removeAbortListener;
+    const timeoutPromise = new Promise((resolve) => {
+      const resolveWithoutInput = () => {
+        abortController.abort();
+        resolve(null);
+      };
+      timeout = setTimeout(resolveWithoutInput, Math.max(0, params.autoResolutionMs ?? 0));
+      if (this.cancellationSignal?.aborted) {
+        resolveWithoutInput();
+        return;
+      }
+      if (this.cancellationSignal) {
+        this.cancellationSignal.addEventListener("abort", resolveWithoutInput, { once: true });
+        removeAbortListener = () => {
+          this.cancellationSignal?.removeEventListener("abort", resolveWithoutInput);
+        };
+      }
+    });
+    const requestPromise = Promise.resolve(this.connection.request(
+      methods.client.elicitation.create,
+      request,
+      this.requestOptions(abortController.signal)
+    ));
+    void requestPromise.catch(() => {
+    });
+    try {
+      return await Promise.race([requestPromise, timeoutPromise]);
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      removeAbortListener?.();
+    }
   }
   createMcpElicitationContext(params) {
     const isToolApproval = isMcpToolCallApproval(params._meta);
@@ -23362,6 +23613,72 @@ var CodexElicitationHandler = class {
         };
     }
   }
+  buildUserInputRequest(params) {
+    const properties = {};
+    const required2 = [];
+    const questionIds = new Set(params.questions.map((question) => question.id));
+    for (const question of params.questions) {
+      const options = question.options ?? [];
+      const hasOptions = options.length > 0;
+      const hasOtherAnswer = question.isOther && hasOptions;
+      const base = {
+        title: question.header || question.id,
+        description: question.question,
+        _meta: {
+          codex: {
+            isOther: question.isOther,
+            isSecret: question.isSecret
+          }
+        }
+      };
+      if (!hasOtherAnswer) {
+        required2.push(question.id);
+      }
+      properties[question.id] = hasOptions ? {
+        ...base,
+        type: "string",
+        oneOf: options.map((option) => ({
+          const: option.label,
+          title: option.label,
+          description: option.description
+        }))
+      } : {
+        ...base,
+        type: "string"
+      };
+      if (hasOtherAnswer) {
+        properties[userInputOtherFieldId(question.id, questionIds)] = {
+          type: "string",
+          title: "Other",
+          description: "Type your own answer instead of choosing an option above.",
+          _meta: {
+            codex: {
+              questionId: question.id,
+              isOtherAnswer: true,
+              isSecret: question.isSecret
+            }
+          }
+        };
+      }
+    }
+    const firstQuestion = params.questions[0];
+    return {
+      sessionId: this.sessionState.sessionId,
+      toolCallId: params.itemId,
+      mode: "form",
+      message: params.questions.length === 1 && firstQuestion ? firstQuestion.question : "Input requested",
+      requestedSchema: {
+        type: "object",
+        properties,
+        required: required2
+      },
+      _meta: {
+        codex: {
+          autoResolutionMs: params.autoResolutionMs
+        }
+      }
+    };
+  }
   buildPermissionRequest(params, context) {
     const sessionId = this.sessionState.sessionId;
     const messageContent = {
@@ -23459,6 +23776,24 @@ var CodexElicitationHandler = class {
     }
     return { action: "cancel", content: null, _meta: null };
   }
+  convertUserInputResponse(response, params) {
+    if (!CreateElicitationResponse.isAccept(response)) {
+      return { answers: {} };
+    }
+    const answers = {};
+    const content = contentRecord(response.content);
+    const questionIds = new Set(params.questions.map((question) => question.id));
+    for (const question of params.questions) {
+      const value = question.isOther && question.options != null && question.options.length > 0 ? userInputResponseValue(content, userInputOtherFieldId(question.id, questionIds)) ?? userInputResponseValue(content, question.id) : userInputResponseValue(content, question.id);
+      if (value === void 0) {
+        continue;
+      }
+      answers[question.id] = {
+        answers: Array.isArray(value) ? value.map(String) : [String(value)]
+      };
+    }
+    return { answers };
+  }
   async publishAcceptedMcpToolApproval(context, accepted) {
     if (!accepted || context.correlatedCallId === void 0) {
       return;
@@ -24245,7 +24580,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.2",
+  version: "1.2.1",
   description: "An ACP-compatible coding agent powered by Codex",
   main: "dist/index.js",
   bin: {
@@ -24311,13 +24646,17 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.2.1",
-    "@openai/codex": "^0.144.0",
+    "@openai/codex": "^0.144.4",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
     zod: "^4.0.0"
   }
 };
+var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
+var SUPPORTED_GATEWAY_PROTOCOLS = {
+  openai: "responses"
+};
 var CodexAcpClient = class {
   codexClient;
   config;
@@ -24355,6 +24694,7 @@ var CodexAcpClient = class {
     if (!isCodexAuthRequest(authRequest)) {
       throw RequestError.invalidRequest();
     }
+    this.gatewayConfig = null;
     switch (authRequest.methodId) {
       case "api-key": {
         const apiKey = authRequest._meta?.["api-key"]?.apiKey ?? this.readApiKeyFromEnv();
@@ -24363,7 +24703,6 @@ var CodexAcpClient = class {
       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();
@@ -24371,7 +24710,6 @@ var CodexAcpClient = class {
         if (loginResponse.type == "chatgpt") {
           await open_default(loginResponse.authUrl);
         }
-        this.gatewayConfig = null;
         const result = await loginCompletedPromise;
         return result.success;
       }
@@ -24379,25 +24717,14 @@ var CodexAcpClient = class {
         if (!authRequest._meta) throw RequestError.invalidRequest();
         const gatewaySettings = authRequest._meta["gateway"];
         if (!gatewaySettings) throw RequestError.invalidRequest();
-        const baseUrl = gatewaySettings.baseUrl;
-        const providerName = typeof gatewaySettings.providerName === "string" && gatewaySettings.providerName.trim().length > 0 ? gatewaySettings.providerName : "User-provided gateway";
-        const headers = {
-          "X-Client-Feature-ID": "codex",
-          ...gatewaySettings.headers
-        };
-        this.gatewayConfig = {
-          modelProvider: "custom-gateway",
-          config: {
-            name: providerName,
-            base_url: baseUrl,
-            http_headers: headers,
-            wire_api: "responses"
-          }
-        };
+        this.applyGatewayConfig({
+          baseUrl: gatewaySettings.baseUrl,
+          apiType: GatewayAuthMethod._meta.gateway.protocol,
+          headers: gatewaySettings.headers,
+          providerName: gatewaySettings.providerName
+        });
         return true;
     }
-    this.gatewayConfig = null;
-    return false;
   }
   async authenticateWithApiKey(apiKey) {
     const loginCompletedPromise = this.awaitNextLoginCompleted();
@@ -24405,7 +24732,6 @@ var CodexAcpClient = class {
       type: "apiKey",
       apiKey
     });
-    this.gatewayConfig = null;
     const result = await loginCompletedPromise;
     return result.success;
   }
@@ -24472,12 +24798,90 @@ var CodexAcpClient = class {
     const response = await this.codexClient.accountRead({ refreshToken: false });
     return response.requiresOpenaiAuth && !response.account;
   }
-  hasGatewayAuth() {
-    return this.gatewayConfig !== null;
+  /**
+   * Validates and stores custom gateway routing. Shared by the `gateway` auth
+   * method and the ACP `providers/set` method. Throws `invalid_params` for an
+   * unsupported protocol or a malformed base URL.
+   */
+  applyGatewayConfig(params) {
+    const apiType = params.apiType;
+    const wireApi = SUPPORTED_GATEWAY_PROTOCOLS[apiType];
+    if (!wireApi) {
+      throw RequestError.invalidParams(
+        { apiType },
+        `Unsupported provider apiType "${apiType}"; supported: ${Object.keys(SUPPORTED_GATEWAY_PROTOCOLS).join(", ")}`
+      );
+    }
+    if (typeof params.baseUrl !== "string" || params.baseUrl.trim().length === 0) {
+      throw RequestError.invalidParams(void 0, "baseUrl must be a non-empty string");
+    }
+    const providerName = typeof params.providerName === "string" && params.providerName.trim().length > 0 ? params.providerName : "User-provided gateway";
+    const headers = {
+      "X-Client-Feature-ID": "codex",
+      ...params.headers
+    };
+    this.gatewayConfig = {
+      modelProvider: CUSTOM_GATEWAY_PROVIDER_ID,
+      config: {
+        name: providerName,
+        base_url: params.baseUrl,
+        http_headers: headers,
+        wire_api: wireApi
+      }
+    };
+  }
+  /**
+   * `providers/list`: returns the single client-configurable custom gateway
+   * provider. `current` carries only non-secret routing (never headers), and is
+   * `null` when the provider is not configured/disabled.
+   */
+  listProviders() {
+    const gatewayConfig = this.gatewayConfig;
+    const current = gatewayConfig ? {
+      apiType: gatewayApiTypeFromConfig(gatewayConfig),
+      baseUrl: gatewayConfig.config.base_url
+    } : null;
+    return [
+      {
+        providerId: CUSTOM_GATEWAY_PROVIDER_ID,
+        supported: Object.keys(SUPPORTED_GATEWAY_PROTOCOLS),
+        required: false,
+        current
+      }
+    ];
+  }
+  /**
+   * `providers/set`: replaces the full configuration for the custom gateway
+   * provider. Rejects unknown provider ids with `invalid_params`.
+   */
+  setProvider(request) {
+    if (request.providerId !== CUSTOM_GATEWAY_PROVIDER_ID) {
+      throw RequestError.invalidParams(
+        { providerId: request.providerId },
+        `Unknown providerId "${request.providerId}"; only "${CUSTOM_GATEWAY_PROVIDER_ID}" is configurable`
+      );
+    }
+    this.applyGatewayConfig({
+      apiType: request.apiType,
+      baseUrl: request.baseUrl,
+      headers: request.headers
+    });
+  }
+  /**
+   * `providers/disable`: disables the custom gateway provider. Disabling an
+   * unknown provider id is idempotent success (RFD behavior §7).
+   */
+  disableProvider(request) {
+    if (request.providerId === CUSTOM_GATEWAY_PROVIDER_ID) {
+      this.gatewayConfig = null;
+    }
   }
   async getAccount() {
     return this.codexClient.accountRead({ refreshToken: false });
   }
+  async getRateLimits() {
+    return this.codexClient.accountRateLimitsRead();
+  }
   async resumeSession(request, onSubscribed) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
@@ -24715,6 +25119,10 @@ var CodexAcpClient = class {
       handleElicitation: async (params) => {
         await this.waitForSessionNotifications(sessionId);
         return await elicitationHandler.handleElicitation(params);
+      },
+      handleUserInput: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await elicitationHandler.handleUserInput(params);
       }
     });
   }
@@ -24764,6 +25172,15 @@ var CodexAcpClient = class {
     }
     return await this.codexClient.runTurn(params, onTurnStarted);
   }
+  async sendSteer(request, expectedTurnId, steerId) {
+    const response = await this.codexClient.turnSteer({
+      threadId: request.sessionId,
+      input: buildPromptItems(request.prompt),
+      expectedTurnId,
+      clientUserMessageId: steerId
+    });
+    return response.turnId;
+  }
   resolveTurnInterrupted(params) {
     this.codexClient.resolveTurnInterrupted(params.threadId, params.turnId);
   }
@@ -24881,7 +25298,7 @@ var CodexAcpClient = class {
     const [allProviders, archivedAllProviders, customGateway] = await Promise.all([
       this.codexClient.threadList({}),
       this.codexClient.threadList({ archived: true }),
-      this.codexClient.threadList({ modelProviders: ["custom-gateway"] })
+      this.codexClient.threadList({ modelProviders: [CUSTOM_GATEWAY_PROVIDER_ID] })
     ]);
     return {
       allProviders: {
@@ -25034,6 +25451,11 @@ function arraysEqual(left, right) {
 function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function gatewayApiTypeFromConfig(gatewayConfig) {
+  const wireApi = gatewayConfig.config.wire_api;
+  const match = Object.entries(SUPPORTED_GATEWAY_PROTOCOLS).find(([, wire]) => wire === wireApi);
+  return match?.[0] ?? "openai";
+}
 function mergeGatewayConfig(config2, gatewayConfig) {
   if (gatewayConfig !== null) {
     const newConfig = { ...config2 };
@@ -25050,6 +25472,9 @@ function mergeGatewayConfig(config2, gatewayConfig) {
 }
 var MODEL_CONFIG_ID = "model";
 var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
 function findSupportedEffort(options, effort) {
   if (!effort) return void 0;
   return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
@@ -25087,7 +25512,7 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
     currentValue: currentEffort,
     options: supportedReasoningEfforts.map((option) => ({
       value: option.reasoningEffort,
-      name: option.reasoningEffort,
+      name: capitalize(option.reasoningEffort),
       description: option.description
     }))
   };
@@ -25288,8 +25713,7 @@ var CodexCommands = class {
         return { handled: true };
       }
       default:
-        await this.sendUnknownCommandMessage(commandName, sessionId);
-        return { handled: true };
+        return { handled: false };
     }
   }
   async runReviewCommand(sessionState, target, options) {
@@ -25371,17 +25795,6 @@ var CodexCommands = class {
     const session = new ACPSessionConnection(this.connection, sessionId);
     await session.update(createAgentTextMessageChunk(text));
   }
-  async sendUnknownCommandMessage(name, sessionId) {
-    const lines = this.getBuiltinCommands().map((command) => `- /${command.name}: ${command.description}`);
-    const text = [
-      `Unknown command "/${name}".`,
-      "Available commands:"
-    ];
-    if (lines.length > 0) {
-      text.push(...lines);
-    }
-    await this.sendCommandMessage(text.join("\n"), sessionId);
-  }
   buildStatusMessage(sessionState) {
     const agentMode = sessionState.agentMode;
     const accountText = this.formatAccountInfo(sessionState.account);
@@ -25645,6 +26058,7 @@ function toolCallIdFromThreadItem(item) {
     case "webSearch":
     case "imageView":
     case "imageGeneration":
+    case "contextCompaction":
       return item.id;
     case "userMessage":
     case "hookPrompt":
@@ -25654,7 +26068,6 @@ function toolCallIdFromThreadItem(item) {
     case "subAgentActivity":
     case "enteredReviewMode":
     case "exitedReviewMode":
-    case "contextCompaction":
     case "sleep":
       return null;
   }
@@ -25737,9 +26150,13 @@ function createAgentReasoningEventUpdates(payload) {
   if (text === null || text.length === 0) {
     return [];
   }
+  const sanitizedText = stripEmptyReasoningComments(text);
+  if (sanitizedText.length === 0) {
+    return [];
+  }
   return [{
     sessionUpdate: "agent_thought_chunk",
-    content: { type: "text", text }
+    content: { type: "text", text: sanitizedText }
   }];
 }
 function imageBlocks(images) {
@@ -25776,11 +26193,7 @@ function contentBlocksFromResponseContent(content) {
   });
 }
 function createReasoningUpdates(item) {
-  const parts = textParts(item["summary"]);
-  if (parts.length === 0) {
-    parts.push(...textParts(item["content"]));
-  }
-  return parts.map((text) => ({
+  return sanitizeReasoningParts(textParts(item["summary"]), textParts(item["content"])).map((text) => ({
     sessionUpdate: "agent_thought_chunk",
     content: { type: "text", text }
   }));
@@ -26571,6 +26984,7 @@ var CodexAcpServer = class _CodexAcpServer {
   pendingMcpStartupSessions;
   pendingTurnStarts;
   activePrompts;
+  pendingSteers;
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
@@ -26579,6 +26993,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
     this.pendingTurnStarts = /* @__PURE__ */ new Map();
     this.activePrompts = /* @__PURE__ */ new Map();
+    this.pendingSteers = /* @__PURE__ */ new Map();
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
@@ -26616,6 +27031,7 @@ var CodexAcpServer = class _CodexAcpServer {
         auth: {
           logout: {}
         },
+        providers: {},
         loadSession: true,
         promptCapabilities: {
           embeddedContext: true,
@@ -26632,6 +27048,11 @@ var CodexAcpServer = class _CodexAcpServer {
           acp: false,
           http: true,
           sse: false
+        },
+        _meta: {
+          codex: {
+            steer: CODEX_STEER_CAPABILITY
+          }
         }
       },
       authMethods: getCodexAuthMethods(_params.clientCapabilities)
@@ -26807,9 +27228,12 @@ You have been logged out. Please try again.`);
       planModeEnabled: false,
       planModeExplicitlySet: false,
       sessionMcpServers,
-      terminalOutputMode: this.terminalOutputMode
+      terminalOutputMode: this.terminalOutputMode,
+      sessionTitle: null,
+      sessionTitleSource: "sessionId" in request ? "unknown" : "unset"
     };
     this.sessions.set(sessionId, sessionState);
+    this.publishRateLimitsAsync(sessionState);
     resumeSubscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
@@ -26845,6 +27269,27 @@ You have been logged out. Please try again.`);
     }
     return a === b;
   }
+  publishRateLimitsAsync(sessionState) {
+    if (!sessionState.authConfigured || !this.authProviderUsesOpenAiAccount(sessionState.authProvider)) {
+      return;
+    }
+    void this.codexAcpClient.getRateLimits().then(async (response) => {
+      if (this.sessions.get(sessionState.sessionId) !== sessionState) {
+        return;
+      }
+      if (!response?.rateLimits) {
+        return;
+      }
+      const rateLimitsById = Object.values(response.rateLimitsByLimitId ?? {}).filter((snapshot) => snapshot !== void 0);
+      const snapshots = rateLimitsById.length > 0 ? rateLimitsById : [response.rateLimits];
+      const handler = new CodexEventHandler(this.connection, sessionState);
+      for (const snapshot of snapshots) {
+        await handler.handleRateLimitsSnapshot(snapshot);
+      }
+    }).catch((err) => {
+      logger.error(`Failed to read rate limits for session ${sessionState.sessionId}`, err);
+    });
+  }
   getAuthProviderForAuthenticateRequest(request) {
     if (isCodexAuthRequest(request) && request.methodId === "gateway") {
       return "custom-gateway";
@@ -26988,6 +27433,17 @@ You have been logged out. Please try again.`);
     await this.refreshSessionsAuthState(null);
     logger.log("Logout request completed");
   }
+  listProviders(_params) {
+    return { providers: this.codexAcpClient.listProviders() };
+  }
+  setProvider(params) {
+    this.codexAcpClient.setProvider(params);
+    return {};
+  }
+  disableProvider(params) {
+    this.codexAcpClient.disableProvider(params);
+    return {};
+  }
   async refreshSessionsAuthState(authProvider) {
     if (this.sessions.size === 0) return;
     const sessionsToRefresh = [...this.sessions.values()].filter((sessionState) => this.authProvidersMatch(sessionState.authProvider, authProvider));
@@ -26996,6 +27452,7 @@ You have been logged out. Please try again.`);
     for (const sessionState of sessionsToRefresh) {
       sessionState.account = authState.account;
       sessionState.authConfigured = authState.authConfigured;
+      this.publishRateLimitsAsync(sessionState);
     }
   }
   async setSessionMode(_params) {
@@ -27259,9 +27716,12 @@ You have been logged out. Please try again.`);
       planModeEnabled: false,
       planModeExplicitlySet: false,
       sessionMcpServers,
-      terminalOutputMode: this.terminalOutputMode
+      terminalOutputMode: this.terminalOutputMode,
+      sessionTitle: null,
+      sessionTitleSource: "unset"
     };
     this.sessions.set(sessionId, sessionState);
+    this.publishRateLimitsAsync(sessionState);
     subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
@@ -27283,6 +27743,7 @@ You have been logged out. Please try again.`);
   async streamThreadHistory(sessionId, thread) {
     const session = new ACPSessionConnection(this.connection, sessionId);
     const sessionState = this.getSessionState(sessionId);
+    await this.publishThreadHistoryTitle(session, sessionState, thread);
     const responseItemFallbackUpdates = await createResponseItemHistoryFallbackUpdates(
       thread,
       sessionState.terminalOutputMode
@@ -27299,6 +27760,47 @@ You have been logged out. Please try again.`);
       await session.update(update);
     }
   }
+  async publishThreadHistoryTitle(session, sessionState, thread) {
+    const explicitTitle = this.normalizeSessionTitle(thread.name);
+    if (explicitTitle) {
+      sessionState.sessionTitle = explicitTitle;
+      sessionState.sessionTitleSource = "explicit";
+      await session.update({
+        sessionUpdate: "session_info_update",
+        title: explicitTitle
+      });
+      return;
+    }
+    const historyTitle = this.findFirstUserMessageTitle(thread) ?? this.normalizeSessionTitle(thread.preview);
+    await this.publishFallbackSessionTitle(sessionState, historyTitle);
+  }
+  findFirstUserMessageTitle(thread) {
+    for (const turn of thread.turns) {
+      for (const item of turn.items) {
+        if (item.type !== "userMessage") continue;
+        const title = this.normalizeSessionTitle(item.content.filter((input) => input.type === "text").map((input) => input.text).join(" "));
+        if (title) return title;
+      }
+    }
+    return null;
+  }
+  async publishFallbackSessionTitle(sessionState, title) {
+    if (sessionState.sessionTitleSource !== "unset" || !title) return;
+    sessionState.sessionTitle = title;
+    sessionState.sessionTitleSource = "fallback";
+    const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+    await session.update({
+      sessionUpdate: "session_info_update",
+      title
+    });
+  }
+  createPromptFallbackTitle(prompt) {
+    return this.normalizeSessionTitle(prompt.filter((block) => block.type === "text").map((block) => block.text).join(" "));
+  }
+  normalizeSessionTitle(title) {
+    const normalized = title?.replace(/\s+/g, " ").trim() ?? "";
+    return normalized.length > 0 ? normalized : null;
+  }
   async createHistoryUpdates(item, sessionState) {
     switch (item.type) {
       case "userMessage":
@@ -27345,7 +27847,7 @@ You have been logged out. Please try again.`);
       case "exitedReviewMode":
         return [this.createReviewModeUpdate(item, false)];
       case "contextCompaction":
-        return [this.createContextCompactionUpdate()];
+        return [createCompletedContextCompactionUpdate(item)];
       case "plan":
         return [this.createPlanUpdate(item)];
     }
@@ -27362,9 +27864,8 @@ You have been logged out. Please try again.`);
     return updates;
   }
   createReasoningUpdates(item) {
-    const parts = item.summary.length > 0 ? item.summary : item.content;
     const messageId = item.id;
-    return parts.map((text) => createAgentTextThoughtChunk(text, messageId));
+    return sanitizeReasoningParts(item.summary, item.content).map((text) => createAgentTextThoughtChunk(text, messageId));
   }
   createWebSearchUpdate(item) {
     return {
@@ -27388,15 +27889,6 @@ You have been logged out. Please try again.`);
       }
     };
   }
-  createContextCompactionUpdate() {
-    return {
-      sessionUpdate: "agent_message_chunk",
-      content: {
-        type: "text",
-        text: "Context compacted."
-      }
-    };
-  }
   createPlanUpdate(item) {
     return {
       sessionUpdate: "agent_message_chunk",
@@ -27516,6 +28008,7 @@ ${item.text}`
       cancelSignal,
       signal: abortController.signal,
       currentTurn: null,
+      outcome: null,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -27539,12 +28032,78 @@ ${item.text}`
         if (this.activePrompts.get(sessionId) === activePrompt) {
           this.activePrompts.delete(sessionId);
         }
+        this.clearPendingSteers(sessionId, activePrompt);
         resolveCompletion();
       }
     };
     this.activePrompts.set(sessionId, activePrompt);
     return activePrompt;
   }
+  clearPendingSteers(sessionId, activePrompt) {
+    const pending = this.pendingSteers.get(sessionId);
+    if (!pending) return;
+    for (const [steerId, steer] of pending) {
+      if (steer.activePrompt === activePrompt) pending.delete(steerId);
+    }
+    if (pending.size === 0) this.pendingSteers.delete(sessionId);
+  }
+  async handleSteerAppliedNotification(sessionId, event, activePrompt) {
+    if (event.method !== "item/completed" || event.params.item.type !== "userMessage") return;
+    const steerId = event.params.item.clientId;
+    if (!steerId) return;
+    const pending = this.pendingSteers.get(sessionId);
+    if (!pending) return;
+    const steer = pending.get(steerId);
+    if (!steer || steer.activePrompt !== activePrompt || steer.turnId !== event.params.turnId) return;
+    pending.delete(steerId);
+    if (pending.size === 0) this.pendingSteers.delete(sessionId);
+    await this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId });
+  }
+  async steerPrompt(params) {
+    const steerId = getCodexSteerId(params._meta);
+    if (!steerId) throw RequestError.invalidRequest("Missing Codex steer id");
+    const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
+    if (firstText.startsWith("/")) {
+      throw RequestError.invalidRequest("Slash commands cannot steer an active Codex turn");
+    }
+    let activePrompt = this.activePrompts.get(params.sessionId);
+    if (!activePrompt) throw RequestError.invalidRequest("No active Codex turn to steer");
+    if (!activePrompt.currentTurn) {
+      await this.pendingTurnStarts.get(params.sessionId)?.promise;
+      activePrompt = this.activePrompts.get(params.sessionId);
+    }
+    const turn = activePrompt?.currentTurn;
+    if (!activePrompt || !turn || activePrompt.signal.aborted) {
+      throw RequestError.invalidRequest("No active Codex turn to steer");
+    }
+    const pending = this.pendingSteers.get(params.sessionId) ?? /* @__PURE__ */ new Map();
+    if (pending.has(steerId)) {
+      throw RequestError.invalidRequest(`Duplicate Codex steer id: ${steerId}`);
+    }
+    pending.set(steerId, { activePrompt, turnId: turn.turnId });
+    this.pendingSteers.set(params.sessionId, pending);
+    try {
+      const steeredTurnId = await this.runWithProcessCheck(
+        () => this.codexAcpClient.sendSteer(params, turn.turnId, steerId)
+      );
+      if (steeredTurnId !== turn.turnId) {
+        throw RequestError.internalError(
+          void 0,
+          `Codex steered unexpected turn ${steeredTurnId}; expected ${turn.turnId}`
+        );
+      }
+    } catch (error48) {
+      if (pending.get(steerId)?.activePrompt === activePrompt) {
+        pending.delete(steerId);
+        if (pending.size === 0) this.pendingSteers.delete(params.sessionId);
+      }
+      throw error48;
+    }
+    if (!activePrompt.outcome) {
+      throw RequestError.internalError(void 0, "Active Codex prompt has no tracked outcome");
+    }
+    return await activePrompt.outcome;
+  }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
       if (activePrompt.currentTurn === null) {
@@ -27676,6 +28235,22 @@ ${item.text}`
     return turnId;
   }
   async prompt(params, signal) {
+    if (getCodexSteerId(params._meta)) {
+      return await this.steerPrompt(params);
+    }
+    if (this.activePrompts.has(params.sessionId)) {
+      throw RequestError.invalidRequest(
+        "A Codex prompt is already active; use the advertised steer extension"
+      );
+    }
+    const outcome = this.runPrompt(params, signal);
+    const activePrompt = this.activePrompts.get(params.sessionId);
+    if (activePrompt) {
+      activePrompt.outcome = outcome;
+    }
+    return await outcome;
+  }
+  async runPrompt(params, signal) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
       prompt: params.prompt
@@ -27684,14 +28259,8 @@ ${item.text}`
     sessionState.currentTurnId = null;
     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 pendingTurnStart = this.createPendingTurnStart();
+    this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     try {
       const eventHandler = new CodexEventHandler(this.connection, sessionState);
@@ -27705,6 +28274,7 @@ ${item.text}`
       await this.codexAcpClient.subscribeToSessionEvents(
         params.sessionId,
         async (event) => {
+          await this.handleSteerAppliedNotification(params.sessionId, event, activePrompt);
           await elicitationHandler.handleNotification(event);
           return eventHandler.handleNotification(event);
         },
@@ -27715,9 +28285,6 @@ ${item.text}`
         return this.cancelledPromptResponse(sessionState);
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
-        onTurnStartPending: () => {
-          ensurePendingTurnStart();
-        },
         onTurnStarted: (turnId, threadId) => {
           const turn = { threadId, turnId };
           activePrompt.currentTurn = turn;
@@ -27726,7 +28293,7 @@ ${item.text}`
             return;
           }
           sessionState.currentTurnId = turnId;
-          pendingTurnStart?.resolve(turnId);
+          pendingTurnStart.resolve(turnId);
         }
       });
       void commandPromise.catch((err) => {
@@ -27780,7 +28347,6 @@ ${item.text}`
         sessionState.currentModelSupportsFast
       );
       const collaborationMode = this.createPlanModeCollaborationMode(sessionState, modelId);
-      ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           params,
@@ -27799,7 +28365,7 @@ ${item.text}`
               return;
             }
             sessionState.currentTurnId = turnId;
-            pendingTurnStart?.resolve(turnId);
+            pendingTurnStart.resolve(turnId);
           },
           () => this.promptShouldStop(params.sessionId, activePrompt)
         )
@@ -27826,6 +28392,10 @@ ${item.text}`
       if (error48) {
         throw error48;
       }
+      await this.publishFallbackSessionTitle(
+        sessionState,
+        this.createPromptFallbackTitle(params.prompt)
+      );
       return {
         stopReason: "end_turn",
         usage: this.buildPromptUsage(sessionState.lastTokenUsage),
@@ -27978,6 +28548,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 ToolRequestUserInputRequest = new import_node2.RequestType("item/tool/requestUserInput");
 var GOAL_RUNTIME_EFFECTS_GRACE_MS = 1e3;
 var CodexAppServerClient = class {
   connection;
@@ -28075,6 +28646,16 @@ var CodexAppServerClient = class {
       }
       return await handler.handleElicitation(params);
     });
+    this.connection.onRequest(ToolRequestUserInputRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { answers: {} };
+      }
+      const handler = this.elicitationHandlers.get(params.threadId);
+      if (!handler) {
+        return { answers: {} };
+      }
+      return await handler.handleUserInput(params);
+    });
   }
   onApprovalRequest(threadId, handler) {
     this.approvalHandlers.set(threadId, handler);
@@ -28093,6 +28674,9 @@ var CodexAppServerClient = class {
   async turnStart(params) {
     return await this.sendRequest({ method: "turn/start", params });
   }
+  async turnSteer(params) {
+    return await this.sendRequest({ method: "turn/steer", params });
+  }
   async runTurn(params, onTurnStarted) {
     const capturedCompletions = [];
     const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
@@ -28378,6 +28962,9 @@ var CodexAppServerClient = class {
   async accountRead(params) {
     return await this.sendRequest({ method: "account/read", params });
   }
+  async accountRateLimitsRead() {
+    return await this.sendRequest({ method: "account/rateLimits/read", params: void 0 });
+  }
   //TODO create type-safe helper
   async awaitTurnCompleted(threadId, turnId) {
     return await new Promise((resolve) => {
@@ -28932,5 +29519,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, 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);
+  }).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)).connect(acpJsonStream);
 }