@agentclientprotocol/codex-acp 1.1.2 → 1.1.5

package/dist/index.js

@@ -22592,6 +22592,7 @@ function createTerminalOutputMeta(mode, terminalId, data) {
 }
 
 // src/CodexToolCallMapper.ts
+var CONTEXT_COMPACTION_META = { contextCompaction: true };
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22734,6 +22735,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",
@@ -22847,7 +22877,8 @@ function createCollabAgentToolCallUpdate(item) {
     kind: "other",
     title: item.tool,
     status: toAcpStatus(item.status),
-    rawInput: createCollabAgentToolCallRawInput(item)
+    rawInput: createCollabAgentToolCallRawInput(item),
+    _meta: createCollabAgentToolCallMeta(item)
   };
 }
 function createCollabAgentToolCallCompleteUpdate(item) {
@@ -22856,7 +22887,8 @@ function createCollabAgentToolCallCompleteUpdate(item) {
     toolCallId: item.id,
     title: item.tool,
     status: toAcpStatus(item.status),
-    rawInput: createCollabAgentToolCallRawInput(item)
+    rawInput: createCollabAgentToolCallRawInput(item),
+    _meta: createCollabAgentToolCallMeta(item)
   };
 }
 function createCollabAgentToolCallRawInput(item) {
@@ -22865,9 +22897,66 @@ function createCollabAgentToolCallRawInput(item) {
     senderThreadId: item.senderThreadId,
     receiverThreadIds: item.receiverThreadIds,
     agentsStates: item.agentsStates,
+    model: item.model,
+    reasoningEffort: item.reasoningEffort,
     status: item.status
   };
 }
+function createCollabAgentToolCallMeta(item) {
+  return {
+    codex: {
+      collaboration: {
+        tool: item.tool,
+        senderThreadId: item.senderThreadId,
+        receiverThreadIds: item.receiverThreadIds
+      }
+    }
+  };
+}
+function createSubAgentActivityUpdate(item, status, sessionUpdate) {
+  const name = item.agentPath.split("/").filter(Boolean).at(-1) ?? "subagent";
+  const title = formatSubAgentActivityTitle(item.kind, name);
+  const common = {
+    toolCallId: item.id,
+    status,
+    rawInput: {
+      agentThreadId: item.agentThreadId,
+      agentPath: item.agentPath,
+      activityKind: item.kind
+    },
+    _meta: {
+      codex: {
+        subagent: {
+          threadId: item.agentThreadId,
+          path: item.agentPath,
+          activity: item.kind
+        }
+      }
+    }
+  };
+  if (sessionUpdate === "tool_call") {
+    return {
+      sessionUpdate,
+      title,
+      kind: "other",
+      ...common
+    };
+  }
+  return {
+    sessionUpdate,
+    ...common
+  };
+}
+function formatSubAgentActivityTitle(kind, name) {
+  switch (kind) {
+    case "started":
+      return `Start subagent ${name}`;
+    case "interacted":
+      return `Interact with subagent ${name}`;
+    case "interrupted":
+      return `Interrupt subagent ${name}`;
+  }
+}
 function formatWebSearchTitle(item) {
   const action = item.action;
   if (!action) {
@@ -23273,6 +23362,30 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
   return createAgentThoughtChunk({ type: "text", text }, messageId, meta3);
 }
 
+// src/AcpExtensions.ts
+var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
+var GOAL_CONTROL_METHOD = "_codex/session/goal_control";
+function isExtMethodRequest(request) {
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD;
+}
+
+// src/ThreadGoalSnapshot.ts
+function toThreadGoalSnapshot(goal) {
+  return {
+    objective: goal.objective.trim(),
+    status: goal.status,
+    tokenBudget: goal.tokenBudget,
+    timeUsedSeconds: goal.timeUsedSeconds,
+    createdAt: goal.createdAt,
+    controlMethod: GOAL_CONTROL_METHOD
+  };
+}
+function sameThreadGoalSnapshot(left, right) {
+  if (left === void 0) return false;
+  if (left === null || right === null) return left === right;
+  return left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.createdAt === right.createdAt;
+}
+
 // src/CodexEventHandler.ts
 var CodexEventHandler = class {
   connection;
@@ -23286,6 +23399,7 @@ var CodexEventHandler = class {
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
+  activeSubAgentActivities = /* @__PURE__ */ new Set();
   constructor(connection, sessionState) {
     this.connection = connection;
     this.sessionState = sessionState;
@@ -23321,6 +23435,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
@@ -23451,8 +23567,9 @@ ${event.details}` : "";
 `);
   }
   createThreadGoalUpdatedEvent(event) {
-    const goalSnapshot = this.createThreadGoalSnapshot(event);
-    if (this.sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
+    this.sessionState.goalRevision += 1;
+    const goalSnapshot = toThreadGoalSnapshot(event.goal);
+    if (sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
       return null;
     }
     this.sessionState.currentGoal = goalSnapshot;
@@ -23461,6 +23578,7 @@ ${event.details}` : "";
     });
   }
   createThreadGoalClearedEvent(_event) {
+    this.sessionState.goalRevision += 1;
     if (this.sessionState.currentGoal === null) {
       return null;
     }
@@ -23469,16 +23587,6 @@ ${event.details}` : "";
       goal: null
     });
   }
-  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, event.itemId);
@@ -23520,14 +23628,17 @@ ${event.details}` : "";
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
+      case "contextCompaction":
+        return createContextCompactionStartUpdate(event.item);
       case "subAgentActivity":
+        this.activeSubAgentActivities.add(event.item.id);
+        return createSubAgentActivityUpdate(event.item, "in_progress", "tool_call");
       case "sleep":
       case "userMessage":
       case "hookPrompt":
       case "reasoning":
       case "enteredReviewMode":
       case "exitedReviewMode":
-      case "contextCompaction":
       case "plan":
         return null;
     }
@@ -23576,9 +23687,12 @@ ${event.details}` : "";
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
-        return this.createContextCompactedEvent();
+        return createContextCompactionCompleteUpdate(event.item);
       //ignored types
-      case "subAgentActivity":
+      case "subAgentActivity": {
+        const sessionUpdate = this.activeSubAgentActivities.delete(event.item.id) ? "tool_call_update" : "tool_call";
+        return createSubAgentActivityUpdate(event.item, "completed", sessionUpdate);
+      }
       case "sleep":
       case "userMessage":
       case "hookPrompt":
@@ -23726,7 +23840,15 @@ ${event.stdin}
   }
   async createErrorEvent(params) {
     const error51 = params.error.codexErrorInfo;
-    if (error51 === "usageLimitExceeded") {
+    if (params.willRetry) {
+      return this.createCodexSessionInfoUpdate({
+        error: {
+          ...params.error,
+          turnId: params.turnId,
+          willRetry: true
+        }
+      });
+    } else if (error51 === "usageLimitExceeded") {
       this.failure = RequestError.internalError(
         this.createTurnErrorData(params.error)
       );
@@ -24158,6 +24280,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;
@@ -24293,6 +24416,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" }
@@ -24389,8 +24533,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 (error51) {
+      logger.error("Error handling Codex user input request", error51);
+      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);
@@ -24436,6 +24640,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 = {
@@ -24533,6 +24803,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;
@@ -25399,7 +25687,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.2",
+  version: "1.1.5",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -25458,7 +25746,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.2.1",
-    "@openai/codex": "^0.144.0",
+    "@openai/codex": "^0.144.6",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
@@ -25466,7 +25754,46 @@ var package_default = {
   }
 };
 
+// src/CollaborationModeConfig.ts
+var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
+var DEFAULT_COLLABORATION_MODE = "default";
+var PLAN_COLLABORATION_MODE = "plan";
+function createCollaborationModeConfigOption(currentValue) {
+  return {
+    id: COLLABORATION_MODE_CONFIG_ID,
+    name: "Collaboration mode",
+    description: "How Codex collaborates for subsequent turns",
+    category: "collaboration_mode",
+    type: "select",
+    currentValue,
+    options: [
+      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
+      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
+    ]
+  };
+}
+function parseCollaborationMode(value) {
+  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
+  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
+  return null;
+}
+function createCodexCollaborationMode(mode, currentModelId) {
+  const modelId = ModelId.fromString(currentModelId);
+  return {
+    mode,
+    settings: {
+      model: modelId.model,
+      reasoning_effort: modelId.effort,
+      developer_instructions: null
+    }
+  };
+}
+
 // src/CodexAcpClient.ts
+var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
+var SUPPORTED_GATEWAY_PROTOCOLS = {
+  openai: "responses"
+};
 var CodexAcpClient = class {
   codexClient;
   config;
@@ -25476,6 +25803,7 @@ var CodexAcpClient = class {
   pendingAccountUpdated = null;
   sessionNotificationQueues = /* @__PURE__ */ new Map();
   skillExtraRoots = [];
+  configPath = null;
   constructor(codexClient, codexConfig, modelProvider) {
     this.codexClient = codexClient;
     this.config = codexConfig ?? {};
@@ -25488,19 +25816,27 @@ var CodexAcpClient = class {
     version: `${package_default.version}`
   };
   async initialize(request) {
-    await this.codexClient.initialize({
-      capabilities: null,
+    const response = await this.codexClient.initialize({
+      capabilities: {
+        experimentalApi: true,
+        requestAttestation: false
+      },
       clientInfo: {
         name: request.clientInfo?.name ?? this.defaultClientInfo.name,
         version: request.clientInfo?.version ?? this.defaultClientInfo.version,
         title: request.clientInfo?.title ?? this.defaultClientInfo.title
       }
     });
+    this.configPath = response?.codexHome ?? null;
+  }
+  getHomePath() {
+    return this.configPath;
   }
   async authenticate(authRequest) {
     if (!isCodexAuthRequest(authRequest)) {
       throw RequestError.invalidRequest();
     }
+    this.gatewayConfig = null;
     switch (authRequest.methodId) {
       case "api-key": {
         const apiKey = authRequest._meta?.["api-key"]?.apiKey ?? this.readApiKeyFromEnv();
@@ -25509,7 +25845,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();
@@ -25517,7 +25852,6 @@ var CodexAcpClient = class {
         if (loginResponse.type == "chatgpt") {
           await open_default(loginResponse.authUrl);
         }
-        this.gatewayConfig = null;
         const result = await loginCompletedPromise;
         return result.success;
       }
@@ -25525,25 +25859,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();
@@ -25551,7 +25874,6 @@ var CodexAcpClient = class {
       type: "apiKey",
       apiKey
     });
-    this.gatewayConfig = null;
     const result = await loginCompletedPromise;
     return result.success;
   }
@@ -25618,8 +25940,83 @@ 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 });
@@ -25640,6 +26037,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
@@ -25665,6 +26063,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       thread: historyResponse.thread,
@@ -25688,6 +26087,7 @@ var CodexAcpClient = class {
       sessionId: response.thread.id,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
@@ -25713,6 +26113,10 @@ var CodexAcpClient = class {
   async runCompact(sessionId) {
     await this.codexClient.runCompact({ threadId: sessionId });
   }
+  async getGoal(sessionId) {
+    const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
+    return response?.goal ?? null;
+  }
   async setGoal(sessionId, objective, onTurnStarted) {
     return await this.codexClient.runGoalSet({
       threadId: sessionId,
@@ -25721,10 +26125,17 @@ var CodexAcpClient = class {
     }, onTurnStarted);
   }
   async setGoalStatus(sessionId, status) {
+    let updatedGoal = null;
     await this.codexClient.runGoalSet({
       threadId: sessionId,
       status
+    }, void 0, void 0, (goal) => {
+      updatedGoal = goal;
     });
+    if (updatedGoal === null) {
+      throw new Error(`Goal update for session ${sessionId} returned no goal`);
+    }
+    return updatedGoal;
   }
   async resumeGoal(sessionId, onTurnStarted) {
     return await this.codexClient.runGoalSet({
@@ -25772,11 +26183,16 @@ var CodexAcpClient = class {
   }
   async getConfigMcpServerNames(projectPath) {
     const response = await this.codexClient.configRead({ includeLayers: true, cwd: projectPath });
-    const mcpServers = response?.config?.["mcp_servers"];
-    if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    const effectiveMcpServers = response?.config?.["mcp_servers"];
+    const configLayers = response?.layers ?? [];
+    const layerMcpServers = configLayers.map((layer) => {
+      return isJsonObject(layer.config) ? layer.config["mcp_servers"] : void 0;
+    });
+    const configuredMcpServers = [effectiveMcpServers, ...layerMcpServers].filter(isJsonObject);
+    if (configuredMcpServers.length === 0) {
       return /* @__PURE__ */ new Set();
     }
-    return new Set(Object.keys(mcpServers));
+    return new Set(configuredMcpServers.flatMap((server) => Object.keys(server)));
   }
   getModelProvider() {
     return this.gatewayConfig?.modelProvider ?? this.modelProvider;
@@ -25861,6 +26277,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);
       }
     });
   }
@@ -25906,6 +26326,15 @@ var CodexAcpClient = class {
       serviceTier
     }, onTurnStarted);
   }
+  async setCollaborationMode(sessionId, mode, currentModelId) {
+    await this.codexClient.threadSettingsUpdate({
+      threadId: sessionId,
+      collaborationMode: createCodexCollaborationMode(mode, currentModelId)
+    });
+  }
+  getCollaborationMode(sessionId) {
+    return this.codexClient.getThreadSettings(sessionId)?.collaborationMode.mode ?? "default";
+  }
   resolveTurnInterrupted(params) {
     this.codexClient.resolveTurnInterrupted(params.threadId, params.turnId);
   }
@@ -26023,7 +26452,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: {
@@ -26176,6 +26605,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 };
@@ -26194,6 +26628,9 @@ function mergeGatewayConfig(config2, gatewayConfig) {
 // src/ModelConfigOption.ts
 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;
@@ -26231,7 +26668,7 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
     currentValue: currentEffort,
     options: supportedReasoningEfforts.map((option) => ({
       value: option.reasoningEffort,
-      name: option.reasoningEffort,
+      name: capitalize(option.reasoningEffort),
       description: option.description
     }))
   };
@@ -26295,6 +26732,20 @@ var CodexCommands = class {
    */
   getBuiltinCommands() {
     return [
+      {
+        name: "plan",
+        description: "Turn plan mode on.",
+        input: null,
+        _meta: {
+          commandAction: {
+            kind: "setConfigOption",
+            configId: COLLABORATION_MODE_CONFIG_ID,
+            value: PLAN_COLLABORATION_MODE,
+            resetValue: DEFAULT_COLLABORATION_MODE,
+            presentation: "state"
+          }
+        }
+      },
       {
         name: "mcp",
         description: "List configured Model Context Protocol (MCP) tools.",
@@ -26332,8 +26783,14 @@ var CodexCommands = class {
       },
       {
         name: "goal",
-        description: "Set, pause, resume, or clear a task goal.",
-        input: { hint: "[<objective>|clear|pause|resume]" }
+        description: "Set a goal to keep pursuing.",
+        input: { hint: "[<objective>|clear|pause|resume]" },
+        _meta: {
+          commandAction: {
+            kind: "prefixPrompt",
+            presentation: "state"
+          }
+        }
       },
       {
         name: "logout",
@@ -26363,6 +26820,15 @@ var CodexCommands = class {
     if (commandName.startsWith("$")) return { handled: false };
     const sessionId = sessionState.sessionId;
     switch (commandName) {
+      case "plan": {
+        if (command.rest.length > 0) {
+          await this.sendCommandUsageMessage(commandName, "no arguments", sessionId);
+          return { handled: true };
+        }
+        const mode = sessionState.collaborationMode === PLAN_COLLABORATION_MODE ? DEFAULT_COLLABORATION_MODE : PLAN_COLLABORATION_MODE;
+        await options.setConfigOption?.(COLLABORATION_MODE_CONFIG_ID, mode);
+        return { handled: options.setConfigOption !== void 0 };
+      }
       case "compact": {
         await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
         return { handled: true };
@@ -26438,8 +26904,7 @@ var CodexCommands = class {
         return { handled: true };
       }
       default:
-        await this.sendUnknownCommandMessage(commandName, sessionId);
-        return { handled: true };
+        return { handled: false };
     }
   }
   async runReviewCommand(sessionState, target, options) {
@@ -26518,18 +26983,6 @@ var CodexCommands = class {
     const session = new ACPSessionConnection(this.connection, sessionId);
     await session.update(createAgentTextMessageChunk(`Command "/${name}" requires ${inputHint}.`));
   }
-  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);
-    }
-    const session = new ACPSessionConnection(this.connection, sessionId);
-    await session.update(createAgentTextMessageChunk(text.join("\n")));
-  }
   buildStatusMessage(sessionState) {
     const agentMode = sessionState.agentMode;
     const accountText = this.formatAccountInfo(sessionState.account);
@@ -26799,6 +27252,7 @@ function toolCallIdFromThreadItem(item) {
     case "webSearch":
     case "imageView":
     case "imageGeneration":
+    case "contextCompaction":
       return item.id;
     case "userMessage":
     case "hookPrompt":
@@ -26808,7 +27262,6 @@ function toolCallIdFromThreadItem(item) {
     case "subAgentActivity":
     case "enteredReviewMode":
     case "exitedReviewMode":
-    case "contextCompaction":
     case "sleep":
       return null;
   }
@@ -27625,12 +28078,6 @@ function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
-// src/AcpExtensions.ts
-var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
-function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD;
-}
-
 // src/FastModeConfig.ts
 var FAST_MODE_CONFIG_ID = "fast-mode";
 var FAST_MODE_CATEGORY = "model_config";
@@ -27756,6 +28203,7 @@ var CodexAcpServer = class _CodexAcpServer {
         auth: {
           logout: {}
         },
+        providers: {},
         loadSession: true,
         promptCapabilities: {
           embeddedContext: true,
@@ -27791,6 +28239,25 @@ var CodexAcpServer = class _CodexAcpServer {
       }
       case LEGACY_SET_SESSION_MODEL_METHOD:
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
+      case GOAL_CONTROL_METHOD: {
+        const sessionState = this.sessions.get(methodRequest.params.sessionId);
+        if (!sessionState) {
+          throw RequestError.invalidParams(void 0, `Unknown session: ${methodRequest.params.sessionId}`);
+        }
+        const sessionGeneration = this.getSessionGeneration(sessionState.sessionId);
+        if (methodRequest.params.action === "pause") {
+          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, "paused"));
+          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
+          }
+        } else if (methodRequest.params.action === "clear") {
+          await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionState.sessionId));
+          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, null, false);
+          }
+        }
+        return {};
+      }
     }
   }
   async checkAuthorization() {
@@ -27826,6 +28293,12 @@ var CodexAcpServer = class _CodexAcpServer {
 
 You have been logged out. Please try again.`);
     }
+    const configPath = this.codexAcpClient.getHomePath() ?? "global";
+    if (e.message.includes("load config")) {
+      throw RequestError.internalError(`${e.message}
+
+Check ${configPath} and project .codex directories, especially their config.toml files, or any CODEX_CONFIG override.`);
+    }
   }
   beginSessionOpen(sessionId) {
     const generation = this.getSessionGeneration(sessionId);
@@ -27932,6 +28405,7 @@ You have been logged out. Please try again.`);
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
       totalTokenUsage: null,
@@ -27945,7 +28419,10 @@ You have been logged out. Please try again.`);
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
       currentModelSupportsFast,
       sessionMcpServers,
-      terminalOutputMode: this.terminalOutputMode
+      terminalOutputMode: this.terminalOutputMode,
+      goalRevision: 0,
+      sessionTitle: null,
+      sessionTitleSource: "sessionId" in request ? "unknown" : "unset"
     };
     this.sessions.set(sessionId, sessionState);
     resumeSubscribed = false;
@@ -27957,6 +28434,9 @@ You have been logged out. Please try again.`);
       this.publishMcpStartupStatusAsync(sessionId);
     }
     this.publishAvailableCommandsAsync(sessionState);
+    if ("sessionId" in request) {
+      this.publishCurrentGoalAsync(sessionState, sessionGeneration);
+    }
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return [sessionId, sessionModelState, sessionModeState];
@@ -28126,6 +28606,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));
@@ -28153,6 +28644,12 @@ You have been logged out. Please try again.`);
     });
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
+    await this.applySessionConfigOption(sessionState, params);
+    return {
+      configOptions: this.createSessionConfigOptions(sessionState)
+    };
+  }
+  async applySessionConfigOption(sessionState, params) {
     switch (params.configId) {
       case FAST_MODE_CONFIG_ID:
         this.applyFastModeChange(sessionState, params);
@@ -28160,6 +28657,9 @@ You have been logged out. Please try again.`);
       case MODE_CONFIG_ID:
         this.applyModeChange(sessionState, this.stringConfigValue(params));
         break;
+      case COLLABORATION_MODE_CONFIG_ID:
+        await this.applyCollaborationModeChange(sessionState, this.stringConfigValue(params));
+        break;
       case MODEL_CONFIG_ID:
         this.applyModelChange(sessionState, this.stringConfigValue(params));
         break;
@@ -28169,9 +28669,6 @@ You have been logged out. Please try again.`);
       default:
         throw RequestError.invalidParams();
     }
-    return {
-      configOptions: this.createSessionConfigOptions(sessionState)
-    };
   }
   applyFastModeChange(sessionState, params) {
     const value = params.value;
@@ -28197,6 +28694,14 @@ You have been logged out. Please try again.`);
     }
     sessionState.agentMode = newMode;
   }
+  async applyCollaborationModeChange(sessionState, value) {
+    const mode = parseCollaborationMode(value);
+    if (mode === null) {
+      throw RequestError.invalidParams();
+    }
+    await this.codexAcpClient.setCollaborationMode(sessionState.sessionId, mode, sessionState.currentModelId);
+    sessionState.collaborationMode = mode;
+  }
   applyModelChange(sessionState, value) {
     const model = sessionState.availableModels.find((m) => m.id === value);
     if (!model) {
@@ -28264,6 +28769,7 @@ You have been logged out. Please try again.`);
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
     const configOptions = [
       sessionState.agentMode.toConfigOption(),
+      createCollaborationModeConfigOption(sessionState.collaborationMode),
       createModelConfigOption(sessionState.availableModels, currentModelId.model)
     ];
     if (sessionState.supportedReasoningEfforts.length > 0) {
@@ -28293,6 +28799,46 @@ You have been logged out. Please try again.`);
   publishAvailableCommandsAsync(sessionState) {
     void this.availableCommands.publish(sessionState);
   }
+  publishCurrentGoalAsync(sessionState, sessionGeneration) {
+    void this.publishCurrentGoalBestEffort(sessionState, sessionGeneration, true);
+  }
+  async publishCurrentGoalBestEffort(sessionState, sessionGeneration, force) {
+    try {
+      await this.publishCurrentGoal(sessionState, sessionGeneration, force);
+    } catch (err) {
+      logger.error(`Failed to publish current goal for session ${sessionState.sessionId}`, err);
+    }
+  }
+  async publishCurrentGoal(sessionState, sessionGeneration, force) {
+    const requestRevision = ++sessionState.goalRevision;
+    const goal = await this.runWithProcessCheck(() => this.codexAcpClient.getGoal(sessionState.sessionId));
+    const snapshot = goal === null ? null : toThreadGoalSnapshot(goal);
+    if (!this.goalPublishIsCurrent(sessionState, sessionGeneration) || sessionState.goalRevision !== requestRevision) {
+      return;
+    }
+    await this.publishGoalSnapshot(sessionState, snapshot, force, false);
+  }
+  goalPublishIsCurrent(sessionState, sessionGeneration) {
+    return this.sessions.get(sessionState.sessionId) === sessionState && this.getSessionGeneration(sessionState.sessionId) === sessionGeneration && !this.sessionIsClosing(sessionState.sessionId);
+  }
+  async publishGoalSnapshot(sessionState, snapshot, force, incrementRevision = true) {
+    if (incrementRevision) {
+      sessionState.goalRevision += 1;
+    }
+    if (!force && sameThreadGoalSnapshot(sessionState.currentGoal, snapshot)) {
+      return;
+    }
+    sessionState.currentGoal = snapshot;
+    const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+    await session.update({
+      sessionUpdate: "session_info_update",
+      _meta: {
+        codex: {
+          goal: snapshot
+        }
+      }
+    });
+  }
   findCurrentModel(models, currentModelId) {
     const modelId = ModelId.fromString(currentModelId);
     return models.find((m) => m.id === modelId.model);
@@ -28358,6 +28904,7 @@ You have been logged out. Please try again.`);
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
       totalTokenUsage: null,
@@ -28371,7 +28918,10 @@ You have been logged out. Please try again.`);
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
       currentModelSupportsFast,
       sessionMcpServers,
-      terminalOutputMode: this.terminalOutputMode
+      terminalOutputMode: this.terminalOutputMode,
+      goalRevision: 0,
+      sessionTitle: null,
+      sessionTitleSource: "unset"
     };
     this.sessions.set(sessionId, sessionState);
     subscribed = false;
@@ -28383,6 +28933,7 @@ You have been logged out. Please try again.`);
       this.publishMcpStartupStatusAsync(sessionId);
     }
     await this.availableCommands.publish(sessionState);
+    await this.publishCurrentGoalBestEffort(sessionState, requestedSessionGeneration, true);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return {
@@ -28395,6 +28946,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
@@ -28411,14 +28963,56 @@ 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":
         return this.createUserMessageUpdates(item);
       case "hookPrompt":
-      case "subAgentActivity":
       case "sleep":
         return [];
+      case "subAgentActivity":
+        return [createSubAgentActivityUpdate(item, "completed", "tool_call")];
       case "agentMessage": {
         const meta3 = createCodexMessagePhaseMeta(item.phase);
         return [{
@@ -28457,7 +29051,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)];
     }
@@ -28500,15 +29094,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",
@@ -28839,6 +29424,18 @@ ${item.text}`
           }
           sessionState.currentTurnId = turnId;
           pendingTurnStart?.resolve(turnId);
+        },
+        setConfigOption: async (configId, value) => {
+          await this.applySessionConfigOption(sessionState, {
+            sessionId: sessionState.sessionId,
+            configId,
+            value
+          });
+          const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+          await session.update({
+            sessionUpdate: "config_option_update",
+            configOptions: this.createSessionConfigOptions(sessionState)
+          });
         }
       });
       void commandPromise.catch((err) => {
@@ -28936,6 +29533,10 @@ ${item.text}`
       if (error51) {
         throw error51;
       }
+      await this.publishFallbackSessionTitle(
+        sessionState,
+        this.createPromptFallbackTitle(params.prompt)
+      );
       return {
         stopReason: "end_turn",
         usage: this.buildPromptUsage(sessionState.lastTokenUsage),
@@ -29090,6 +29691,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;
@@ -29105,6 +29707,7 @@ var CodexAppServerClient = class {
   threadStatusCaptures = /* @__PURE__ */ new Map();
   threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
   threadGoalClearedCaptures = /* @__PURE__ */ new Map();
+  threadSettings = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
@@ -29134,6 +29737,9 @@ var CodexAppServerClient = class {
       if (isThreadGoalClearedNotification(serverNotification)) {
         this.recordThreadGoalCleared(serverNotification.params);
       }
+      if (serverNotification.method === "thread/settings/updated") {
+        this.threadSettings.set(serverNotification.params.threadId, serverNotification.params.threadSettings);
+      }
       const routing = extractTurnRouting(serverNotification);
       if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
@@ -29187,6 +29793,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);
@@ -29241,7 +29857,7 @@ var CodexAppServerClient = class {
       releaseCapture();
     }
   }
-  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS) {
+  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS, onGoalSet) {
     let goalTurnId = null;
     const capturedCompletions = [];
     let resolveGoalTurnCompleted = () => {
@@ -29294,6 +29910,7 @@ var CodexAppServerClient = class {
     try {
       const goalSetResponse = await this.threadGoalSet(params);
       expectedGoal = goalSetResponse.goal;
+      onGoalSet?.(expectedGoal);
       if (capturedGoalUpdates.some((event) => goalsMatch(event.goal, expectedGoal))) {
         goalUpdateHandled = true;
         resolveGoalUpdateHandled();
@@ -29431,6 +30048,12 @@ var CodexAppServerClient = class {
   async threadResume(params) {
     return await this.sendRequest({ method: "thread/resume", params });
   }
+  getThreadSettings(threadId) {
+    return this.threadSettings.get(threadId);
+  }
+  async threadSettingsUpdate(params) {
+    await this.connection.sendRequest("thread/settings/update", params);
+  }
   async threadList(params) {
     return await this.sendRequest({ method: "thread/list", params });
   }
@@ -29452,6 +30075,9 @@ var CodexAppServerClient = class {
   async threadGoalSet(params) {
     return await this.sendRequest({ method: "thread/goal/set", params });
   }
+  async threadGoalGet(params) {
+    return await this.sendRequest({ method: "thread/goal/get", params });
+  }
   async threadGoalClear(params) {
     return await this.sendRequest({ method: "thread/goal/clear", params });
   }
@@ -29981,6 +30607,10 @@ var legacySetSessionModelParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   modelId: external_exports.string()
 }).passthrough();
+var goalControlParamsParser = external_exports.object({
+  sessionId: external_exports.string(),
+  action: external_exports.enum(["pause", "clear"])
+}).passthrough();
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);
@@ -30053,5 +30683,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)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
 }