@agentconnect.md/codex-acp 1.10.0-agentconnect.1 → 1.11.0-agentconnect.1

package/README.md

@@ -10,6 +10,7 @@ Use [OpenAI Codex](https://github.com/openai/codex) from [Agent Client Protocol]
 
 - ChatGPT, API key, and client-provided custom gateway authentication.
 - Model, reasoning effort, fast mode, approval, and sandbox mode configuration.
+- Concrete recommended model and reasoning-effort values through the opt-in [AIR recommended config values](docs/recommended-config-values-extension.md) capability.
 - Text prompts, embedded context, images, resource links, and additional workspace directories.
 - Shell command, file change, [permission request](docs/permission-extension.md), MCP tool call, terminal output, reasoning, plan, web search, image generation, image view, token usage, and review events.
 - [Native ACP subagent sessions](docs/subagent-sessions.md) (after capability negotiation) with separate child histories and root-routed permissions; a legacy tool-call fallback otherwise.
@@ -40,6 +41,16 @@ The npm package includes a compatible `@openai/codex` dependency. Set `CODEX_PAT
 CODEX_PATH=/path/to/codex npx -y @agentclientprotocol/codex-acp
 ```
 
+To try changes that have landed on `main` but are not released yet, install from the
+`preview` channel. Pushes to `main` trigger preview publishing without waiting
+for CI or release-please; release commits are excluded, and newer pushes can
+replace queued previews. See
+[docs/RELEASES.md](docs/RELEASES.md#preview-releases).
+
+```bash
+npx -y @agentclientprotocol/codex-acp@preview
+```
+
 ## Authentication
 
 The adapter advertises ACP auth methods during initialization. Clients can authenticate with:

package/dist/index.js

@@ -23670,16 +23670,37 @@ var AIR_SESSION_FAILURE_KEY = "sessionFailure";
 var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
 var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
 var AIR_ASYNC_TASKS_KEY = "asyncTasks";
+var AIR_RECOMMENDED_CONFIG_VALUE_KEY = "recommendedValue";
 var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
 var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
 var AIR_EXTENSION_VERSION = 1;
+function withAirMeta(meta3, key, value) {
+  const root = asRecord(meta3);
+  const jetbrains = asRecord(root[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains[AIR_META_KEY]);
+  return {
+    ...root,
+    [JETBRAINS_META_KEY]: {
+      ...jetbrains,
+      [AIR_META_KEY]: {
+        ...air,
+        [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+        [key]: value
+      }
+    }
+  };
+}
 function clientSupportsAirCapability(capabilities, capability) {
-  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
-  const air = jetbrains?.[AIR_META_KEY];
-  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
-  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+  const meta3 = asRecord(capabilities?._meta);
+  const jetbrains = asRecord(meta3[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains[AIR_META_KEY]);
+  const version2 = air[AIR_EXTENSION_VERSION_KEY];
+  const supported = air[AIR_EXTENSION_CAPABILITIES_KEY];
   return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
 }
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 
 // src/subagents/CodexAgentPath.ts
 function normalizeAgentPath(path9) {
@@ -25641,14 +25662,16 @@ function unique(values) {
 
 // src/permissions/CodexApprovalHandler.ts
 var CodexApprovalHandler = class {
-  constructor(connection, permissionContext, cancellationSignal) {
+  constructor(connection, permissionContext, cancellationSignal, denyRequests) {
     this.connection = connection;
     this.permissionContext = permissionContext;
     this.cancellationSignal = cancellationSignal;
+    this.denyRequests = denyRequests;
   }
   connection;
   permissionContext;
   cancellationSignal;
+  denyRequests;
   async handleCommandExecution(params) {
     const authoritativeParams = params;
     const decisions = commandDecisionOptions(authoritativeParams);
@@ -25707,6 +25730,7 @@ var CodexApprovalHandler = class {
     }
   }
   requestPermission(request) {
+    if (this.denyRequests?.()) return Promise.resolve({ outcome: { outcome: "cancelled" } });
     return this.connection.request(
       methods.client.session.requestPermission,
       request,
@@ -25966,8 +25990,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
           toolCallId: nextStandaloneToolCallId(),
           kind: context.isToolApproval ? "execute" : "other",
           status: "pending",
+          title: context.isToolApproval ? "MCP tool call approval" : "Question from MCP server",
           content: [messageContent],
-          rawInput: { serverName: params.serverName, schema: params.requestedSchema }
+          rawInput: { serverName: params.serverName, description: params.message, schema: params.requestedSchema }
         },
         ...context.isToolApproval ? { _meta: { is_mcp_tool_approval: true } } : {},
         options
@@ -25985,8 +26010,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
         toolCallId: `elicitation-${params.elicitationId}`,
         kind: "fetch",
         status: "pending",
+        title: "MCP server requests to open a URL",
         content: [messageContent],
-        rawInput: { serverName: params.serverName, url: params.url }
+        rawInput: { serverName: params.serverName, description: params.message, url: params.url }
       },
       options
     },
@@ -26099,31 +26125,20 @@ function userInputResponseValue(content, fieldId) {
   return value;
 }
 var CodexElicitationHandler = class {
-  connection;
-  permissionContext;
-  clientCapabilities;
-  cancellationSignal;
-  // In Rust, the MCP elicitation handler receives ElicitationRequestEvent directly from the MCP
-  // protocol layer, where id is set to "mcp_tool_call_approval_<call_id>" — the call ID is extracted
-  // by stripping that prefix.
-  //
-  // In TypeScript, Codex speaks the app-server JSON-RPC protocol (v2), where
-  // McpServerElicitationRequestParams omits elicitationId for form mode, so the MCP-level ID never
-  // reaches the client.
-  //
-  // Workaround: before requesting approval, Codex emits an item/started notification with an
-  // mcpToolCall item carrying the call id and server name. The shared permission lifecycle stores
-  // (threadId, serverName) → callId so this request can correlate to the rendered tool call item.
-  //
-  // The app-server handler exposes URL elicitationId, while serverRequest/resolved only exposes
-  // threadId here, so accepted URL elicitations are completed at thread scope.
-  pendingUrlElicitations = /* @__PURE__ */ new Map();
-  constructor(connection, permissionContext, clientCapabilities = null, cancellationSignal) {
+  constructor(connection, permissionContext, clientCapabilities = null, cancellationSignal, fullAccessHttpServers) {
+    this.fullAccessHttpServers = fullAccessHttpServers;
     this.connection = connection;
     this.permissionContext = permissionContext;
     this.clientCapabilities = clientCapabilities;
     this.cancellationSignal = cancellationSignal;
   }
+  fullAccessHttpServers;
+  connection;
+  permissionContext;
+  clientCapabilities;
+  cancellationSignal;
+  // App-server omits form elicitation IDs, so item/started correlates MCP approvals to tool calls.
+  pendingUrlElicitations = /* @__PURE__ */ new Map();
   async handleNotification(notification) {
     switch (notification.method) {
       case "serverRequest/resolved":
@@ -26136,6 +26151,12 @@ var CodexElicitationHandler = class {
   async handleElicitation(params) {
     try {
       const context = this.createMcpElicitationContext(params);
+      const httpServers = this.fullAccessHttpServers?.(params);
+      if (httpServers !== void 0) {
+        const accepted = !this.cancellationSignal?.aborted && params.mode === "form" && context.isToolApproval && context.persistOptions.has("session") && httpServers.has(params.serverName);
+        await this.publishAcceptedMcpToolApproval(params.threadId, context, accepted);
+        return { action: accepted ? "accept" : "cancel", content: accepted ? {} : null, _meta: null };
+      }
       if (this.shouldUseAcpElicitation(params)) {
         const response2 = await this.connection.request(
           methods.client.elicitation.create,
@@ -26168,11 +26189,29 @@ var CodexElicitationHandler = class {
         context.isToolApproval,
         context.persistOptions
       );
-      if (correlatedCallId !== void 0 && result.action === "accept") {
-        await this.connection.notify(methods.client.session.update, {
-          sessionId: params.threadId,
-          update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
-        });
+      if (correlatedCallId !== void 0) {
+        if (result.action === "accept") {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
+          });
+        }
+      } else {
+        try {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: {
+              sessionUpdate: "tool_call_update",
+              toolCallId: request.toolCall.toolCallId,
+              status: "completed",
+              title: request.toolCall.title,
+              content: request.toolCall.content,
+              rawOutput: { action: result.action }
+            }
+          });
+        } catch (error51) {
+          logger.error("Failed to finalize standalone MCP elicitation tool call", error51);
+        }
       }
       return result;
     } catch (error51) {
@@ -26181,6 +26220,9 @@ var CodexElicitationHandler = class {
     }
   }
   async handleUserInput(params) {
+    if (this.fullAccessHttpServers?.(params) !== void 0 && params.itemId === `mcp-deps-${params.turnId}` && params.questions.some((question) => question.id === "skill_mcp_dependency_install")) {
+      return { answers: {} };
+    }
     if (!clientSupportsFormElicitation(this.clientCapabilities)) {
       return { answers: {} };
     }
@@ -27329,7 +27371,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.10.0-agentconnect.1",
+  version: "1.11.0-agentconnect.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27391,7 +27433,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.3",
+    "@openai/codex": "^0.153.4",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -27524,9 +27566,9 @@ Working directory: ${JSON.stringify(workspace.cwd)}
 Additional allowed directories: ${JSON.stringify(workspace.additionalDirectories)}`;
 }
 function parseAgentFileChangeReportRequest(meta3) {
-  const jetbrains = asRecord(meta3?.[JETBRAINS_META_KEY]);
-  const air = asRecord(jetbrains?.[AIR_META_KEY]);
-  const request = asRecord(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
+  const jetbrains = asRecord2(meta3?.[JETBRAINS_META_KEY]);
+  const air = asRecord2(jetbrains?.[AIR_META_KEY]);
+  const request = asRecord2(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
   if (request === null || !hasOnlyKeys(request, ["version", "requestId"]) || request["version"] !== AGENT_FILE_CHANGE_REPORT_VERSION) {
     return null;
   }
@@ -27593,7 +27635,7 @@ function parseModelFileChangeReport(turn) {
   } catch {
     throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid JSON");
   }
-  const report = asRecord(value);
+  const report = asRecord2(value);
   if (report === null || !hasOnlyKeys(report, ["paths", "complete", "uncertainty"])) {
     throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned an invalid object");
   }
@@ -27770,7 +27812,7 @@ function isWindowsAbsolutePath2(value) {
 function isValidPathText(value) {
   return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
 }
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function hasOnlyKeys(value, allowed) {
@@ -27897,12 +27939,10 @@ import { createHash } from "node:crypto";
 async function forkSession(request, additionalDirectories, dependencies) {
   await dependencies.refreshSkills(request.cwd, additionalDirectories);
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
+  const prepared = await dependencies.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
   const response = await dependencies.codexClient.threadFork({
-    config: await dependencies.createSessionConfig(
-      request.cwd,
-      additionalDirectories,
-      request.mcpServers ?? []
-    ),
+    excludeTurns: true,
+    config: prepared.config,
     cwd: request.cwd,
     ...lastTurnId !== void 0 && { lastTurnId },
     modelProvider: await dependencies.getResumeModelProvider(),
@@ -27917,16 +27957,14 @@ async function forkSession(request, additionalDirectories, dependencies) {
     collaborationMode: dependencies.getCollaborationMode(response.thread.id),
     modelProvider: response.modelProvider,
     currentServiceTier: response.serviceTier ?? null,
-    additionalDirectories
+    additionalDirectories,
+    fullAccessHttpMcpServers: prepared.fullAccessHttpMcpServers
   };
 }
 async function resolveForkTurnId(request, codexClient) {
   const forkPoint = readAirForkPoint(request._meta);
   if (!forkPoint) return void 0;
-  const history = await codexClient.threadRead({
-    threadId: request.sessionId,
-    includeTurns: true
-  });
+  const history = await codexClient.threadReadWithHistory(request.sessionId);
   const candidateIds = airForkMessageIdCandidates(forkPoint.messageId);
   const itemTurnId = candidateIds.map((candidateId) => history.thread.turns.find((turn) => turn.items.some((item) => item.id === candidateId))?.id).find((turnId) => turnId !== void 0);
   if (itemTurnId) return itemTurnId;
@@ -28378,8 +28416,11 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     const initialAgentMode = AgentMode.getInitialAgentMode();
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const prepared = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
+    await this.restrictResumedHttpMcpServers(request.sessionId, prepared);
     const response = await this.codexClient.threadResume({
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
+      excludeTurns: true,
+      config: prepared.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId,
@@ -28395,7 +28436,8 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      additionalDirectories
+      additionalDirectories,
+      fullAccessHttpMcpServers: prepared.fullAccessHttpMcpServers
     };
   }
   async forkSession(request) {
@@ -28414,18 +28456,21 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     const initialAgentMode = AgentMode.getInitialAgentMode();
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const prepared = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
+    await this.restrictResumedHttpMcpServers(request.sessionId, prepared);
     const response = await this.codexClient.threadResume({
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
+      excludeTurns: true,
+      config: prepared.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId,
       ...this.permissionProfileSelection(initialAgentMode, request.cwd, additionalDirectories)
     });
     onSubscribed?.();
-    const historyResponse = await this.codexClient.threadRead({
-      threadId: response.thread.id,
-      includeTurns: true
-    });
+    const thread = response.thread.historyMode === "paginated" ? {
+      ...response.thread,
+      turns: response.turnsBackwardsCursor === null ? [] : await this.codexClient.threadReadHistory(response.thread.id, response.turnsBackwardsCursor)
+    } : (await this.codexClient.threadReadWithHistory(response.thread.id)).thread;
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -28435,22 +28480,21 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      thread: historyResponse.thread,
-      additionalDirectories
+      thread,
+      additionalDirectories,
+      fullAccessHttpMcpServers: prepared.fullAccessHttpMcpServers
     };
   }
   async readSessionThread(sessionId) {
-    return (await this.codexClient.threadRead({
-      threadId: sessionId,
-      includeTurns: true
-    })).thread;
+    return (await this.codexClient.threadReadWithHistory(sessionId)).thread;
   }
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     const initialAgentMode = AgentMode.getInitialAgentMode();
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const prepared = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers);
     const response = await this.codexClient.threadStart({
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers),
+      config: prepared.config,
       modelProvider: this.getModelProvider(),
       cwd: request.cwd,
       ...this.permissionProfileSelection(initialAgentMode, request.cwd, additionalDirectories)
@@ -28467,7 +28511,8 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      additionalDirectories
+      additionalDirectories,
+      fullAccessHttpMcpServers: prepared.fullAccessHttpMcpServers
     };
   }
   async closeSession(sessionId) {
@@ -28482,11 +28527,23 @@ var CodexAcpClient = class {
     const config2 = this.permissionProfileConfig;
     if (!config2) return {};
     return {
-      approvalPolicy: agentMode.approvalPolicy,
+      approvalPolicy: this.approvalPolicyForMode(agentMode),
       permissions: permissionProfileForMode(config2, agentMode.id),
       runtimeWorkspaceRoots: sessionRoots(cwd, additionalDirectories)
     };
   }
+  isProtectedFullAccess(agentMode) {
+    return this.permissionProfileConfig !== void 0 && agentMode.kind === "full_access";
+  }
+  approvalPolicyForMode(agentMode) {
+    if (!this.isProtectedFullAccess(agentMode)) return agentMode.approvalPolicy;
+    return { granular: { sandbox_approval: false, rules: false, skill_approval: false, request_permissions: false, mcp_elicitations: false } };
+  }
+  async restrictResumedHttpMcpServers(sessionId, prepared) {
+    if (prepared.fullAccessHttpMcpServers.length === 0) return;
+    const loaded = await this.codexClient.threadLoadedList({});
+    if (loaded.data.includes(sessionId) || loaded.nextCursor !== null) prepared.fullAccessHttpMcpServers = [];
+  }
   async deleteSession(sessionId) {
     await this.codexClient.threadArchive({ threadId: sessionId });
   }
@@ -28571,23 +28628,25 @@ var CodexAcpClient = class {
     };
     const configWithWorkspaceRoots = mergeSandboxWorkspaceWriteRoots(mergedConfig, additionalDirectories);
     if (mcpServers.length === 0) {
-      return configWithWorkspaceRoots;
+      return { config: configWithWorkspaceRoots, fullAccessHttpMcpServers: [] };
     }
     const requestedServers = mcpServers.map((mcp) => ({
       name: sanitizeMcpServerName(mcp.name),
       server: mcp
     }));
     let serversToConfigure = requestedServers;
+    const existingNames = shouldDeduplicateMcpConflicts() || this.permissionProfileConfig ? await this.getConfigMcpServerNames(projectPath) : /* @__PURE__ */ new Set();
     if (shouldDeduplicateMcpConflicts()) {
-      const existingNames = await this.getConfigMcpServerNames(projectPath);
       serversToConfigure = requestedServers.filter((mcp) => !existingNames.has(mcp.name));
     }
     if (serversToConfigure.length === 0) {
-      return configWithWorkspaceRoots;
+      return { config: configWithWorkspaceRoots, fullAccessHttpMcpServers: [] };
     }
+    const configuredServers = Object.fromEntries(serversToConfigure.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]));
+    const inheritedServers = isJsonObject(this.config["mcp_servers"]) ? this.config["mcp_servers"] : {};
     return {
-      ...configWithWorkspaceRoots,
-      "mcp_servers": Object.fromEntries(serversToConfigure.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]))
+      config: { ...configWithWorkspaceRoots, mcp_servers: configuredServers },
+      fullAccessHttpMcpServers: this.permissionProfileConfig ? Object.entries(configuredServers).filter(([name, server]) => typeof server["url"] === "string" && !existingNames.has(name) && !Object.hasOwn(inheritedServers, name)).map(([name]) => name) : []
     };
   }
   async getConfigMcpServerNames(projectPath) {
@@ -28720,7 +28779,7 @@ var CodexAcpClient = class {
     return await this.codexClient.runTurn({
       threadId: request.sessionId,
       input,
-      approvalPolicy: agentMode.approvalPolicy,
+      approvalPolicy: this.approvalPolicyForMode(agentMode),
       approvalsReviewer: agentMode.approvalsReviewer,
       ...sandboxSelection,
       summary: disableSummary ? "none" : "auto",
@@ -28740,6 +28799,7 @@ var CodexAcpClient = class {
     let lateStopReason = null;
     try {
       const forkPromise = this.codexClient.threadFork({
+        excludeTurns: true,
         threadId: params.sessionId,
         lastTurnId: params.turnId,
         cwd: params.workspace.cwd,
@@ -28828,7 +28888,7 @@ var CodexAcpClient = class {
     if (!config2) return;
     await this.codexClient.threadSettingsUpdate({
       threadId: sessionId,
-      approvalPolicy: agentMode.approvalPolicy,
+      approvalPolicy: this.approvalPolicyForMode(agentMode),
       permissions: permissionProfileForMode(config2, agentMode.id)
     });
   }
@@ -29586,6 +29646,41 @@ var CodexAppServerClient = class {
   async threadRead(params) {
     return await this.sendRequest({ method: "thread/read", params });
   }
+  async threadTurnsList(params) {
+    return await this.sendRequest({ method: "thread/turns/list", params });
+  }
+  async threadReadWithHistory(threadId) {
+    const response = await this.threadRead({ threadId });
+    if (response.thread.historyMode === "legacy") {
+      return await this.threadRead({ threadId, includeTurns: true });
+    }
+    const turns = await this.threadReadHistory(threadId);
+    return { ...response, thread: { ...response.thread, turns } };
+  }
+  async threadReadHistory(threadId, initialCursor = null) {
+    const turns = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    if (initialCursor !== null) seenCursors.add(initialCursor);
+    let cursor = initialCursor;
+    do {
+      const page = await this.threadTurnsList({
+        threadId,
+        cursor,
+        limit: 50,
+        sortDirection: "desc",
+        itemsView: "full"
+      });
+      turns.push(...page.data);
+      cursor = page.nextCursor;
+      if (cursor !== null) {
+        if (seenCursors.has(cursor)) {
+          throw new Error("Codex returned a repeated thread history cursor");
+        }
+        seenCursors.add(cursor);
+      }
+    } while (cursor !== null);
+    return turns.reverse();
+  }
   async threadArchive(params) {
     return await this.sendRequest({ method: "thread/archive", params });
   }
@@ -30024,6 +30119,10 @@ function extractTurnRouting(notification) {
 // src/ModelConfigOption.ts
 var MODEL_CONFIG_ID = "model";
 var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function formatModelDisplayName(displayName) {
+  if (!/^gpt-/i.test(displayName)) return displayName;
+  return displayName.replace(/^gpt-/i, "").split(/[-/]+/).filter(Boolean).map(capitalize).join(" ");
+}
 function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -30031,19 +30130,20 @@ function findSupportedEffort(options, effort) {
   if (!effort) return void 0;
   return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
 }
-function createModelConfigOption(availableModels, currentBaseModelId) {
+function createModelConfigOption(availableModels, currentBaseModelId, recommendedModelId) {
   const options = availableModels.map((model) => ({
     value: model.id,
-    name: model.displayName,
+    name: formatModelDisplayName(model.displayName),
     description: model.description
   }));
   if (!availableModels.some((model) => model.id === currentBaseModelId)) {
     options.unshift({
       value: currentBaseModelId,
-      name: currentBaseModelId,
+      name: formatModelDisplayName(currentBaseModelId),
       description: null
     });
   }
+  const recommendation = recommendedModelId && options.some((option) => option.value === recommendedModelId) ? recommendedModelId : void 0;
   return {
     id: MODEL_CONFIG_ID,
     name: "Model",
@@ -30051,10 +30151,12 @@ function createModelConfigOption(availableModels, currentBaseModelId) {
     category: "model",
     type: "select",
     currentValue: currentBaseModelId,
-    options
+    options,
+    ...recommendation ? { _meta: withAirMeta(void 0, AIR_RECOMMENDED_CONFIG_VALUE_KEY, recommendation) } : {}
   };
 }
-function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
+function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort, recommendedEffort) {
+  const recommendation = findSupportedEffort(supportedReasoningEfforts, recommendedEffort);
   return {
     id: REASONING_EFFORT_CONFIG_ID,
     name: "Reasoning effort",
@@ -30066,7 +30168,8 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
       value: option.reasoningEffort,
       name: capitalize(option.reasoningEffort),
       description: option.description
-    }))
+    })),
+    ...recommendation ? { _meta: withAirMeta(void 0, AIR_RECOMMENDED_CONFIG_VALUE_KEY, recommendation) } : {}
   };
 }
 
@@ -30766,14 +30869,14 @@ function parseJsonRecord(line) {
   }
   try {
     const value = JSON.parse(line);
-    return asRecord2(value);
+    return asRecord3(value);
   } catch {
     return null;
   }
 }
 function extractResponseItem(record2) {
   if (record2["type"] === "response_item") {
-    return asRecord2(record2["payload"]);
+    return asRecord3(record2["payload"]);
   }
   const itemType = record2["type"];
   if (typeof itemType === "string" && isLegacyResponseItemType(itemType)) {
@@ -30807,7 +30910,7 @@ function createEventMsgUpdates(record2) {
   if (record2["type"] !== "event_msg") {
     return null;
   }
-  const payload = asRecord2(record2["payload"]);
+  const payload = asRecord3(record2["payload"]);
   if (!payload) {
     return [];
   }
@@ -30851,7 +30954,7 @@ function imageBlocks(images) {
     if (typeof image === "string") {
       return [{ type: "text", text: `[@image](${image})` }];
     }
-    const record2 = asRecord2(image);
+    const record2 = asRecord3(image);
     const path9 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
     return path9 ? [{ type: "text", text: `[@image](${path9})` }] : [];
   });
@@ -30861,7 +30964,7 @@ function contentBlocksFromResponseContent(content) {
     return [];
   }
   return content.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30894,7 +30997,7 @@ function textParts(value) {
     if (typeof entry === "string") {
       return entry.length > 0 ? [entry] : [];
     }
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30986,7 +31089,7 @@ function parseFunctionArguments(value) {
 }
 function rawInputForFunctionCall(name, args) {
   if (name === "exec_command") {
-    const record2 = asRecord2(args);
+    const record2 = asRecord3(args);
     if (record2) {
       return {
         command: stringValue(record2["cmd"]) ?? stringValue(record2["command"]),
@@ -31033,14 +31136,14 @@ function functionCallUsesTerminal(item) {
   return item["name"] === "exec_command";
 }
 function commandFromFunctionArguments(args) {
-  const record2 = asRecord2(args);
+  const record2 = asRecord3(args);
   if (!record2) {
     return null;
   }
   return stringValue(record2["cmd"]) ?? stringValue(record2["command"]);
 }
 function cwdFromFunctionArguments(args) {
-  const record2 = asRecord2(args);
+  const record2 = asRecord3(args);
   if (!record2) {
     return "";
   }
@@ -31512,7 +31615,7 @@ function outputText(output) {
     return "";
   }
   return output.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -31528,7 +31631,7 @@ function outputText(output) {
   }).join("\n");
 }
 function parseExitCode(rawOutput, output) {
-  const record2 = asRecord2(rawOutput);
+  const record2 = asRecord3(rawOutput);
   if (record2) {
     const exitCode2 = numberValue(record2["exit_code"]) ?? numberValue(record2["exitCode"]);
     if (exitCode2 !== null) {
@@ -31559,7 +31662,7 @@ function looksLikeCommandFailure(output) {
   }
   return /(^|\n)(Error|Failed|Command failed|Sandbox error|No such file or directory|Permission denied|Operation not permitted|ENOENT|EACCES)(:|\b)/i.test(trimmed);
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;
   }
@@ -32209,12 +32312,7 @@ function clientSupportsTypedSessionFailures(capabilities) {
 function clientSupportsAgentFileChangeReports(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_AGENT_FILE_CHANGE_REPORT_KEY);
 }
-var CodexAcpServer = class _CodexAcpServer {
-  static MODEL_NAME_TOKEN_OVERRIDES = {
-    gpt: "GPT",
-    mini: "Mini",
-    codex: "Codex"
-  };
+var CodexAcpServer = class {
   codexAcpClient;
   connection;
   defaultAuthRequest;
@@ -32341,7 +32439,8 @@ var CodexAcpServer = class _CodexAcpServer {
               AIR_SESSION_FAILURE_KEY,
               AIR_AGENT_FILE_CHANGE_REPORT_KEY,
               AIR_NATIVE_SUBAGENT_SESSIONS_KEY,
-              AIR_ASYNC_TASKS_KEY
+              AIR_ASYNC_TASKS_KEY,
+              AIR_RECOMMENDED_CONFIG_VALUE_KEY
             ]
           }
         }
@@ -32594,6 +32693,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      fullAccessHttpMcpServers: sessionMetadata.fullAccessHttpMcpServers ?? [],
       collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
@@ -32927,12 +33027,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
       for (const session of this.sessions.values()) {
         session.asyncTasks.setAppServer(replacement.appServerClient);
         try {
-          await replacement.resumeSession({
+          const metadata = await replacement.resumeSession({
             sessionId: session.sessionId,
             cwd: session.cwd,
             additionalDirectories: session.additionalDirectories,
             mcpServers: session.mcpServers ?? []
           });
+          session.fullAccessHttpMcpServers = metadata.fullAccessHttpMcpServers ?? [];
           session.authProvider = replacement.getModelProvider();
           session.asyncTasks.refresh();
           logger.log("Resumed session after provider restart", { sessionId: session.sessionId });
@@ -33220,6 +33321,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     if (!newMode) {
       throw RequestError.invalidParams();
     }
+    sessionState.permissionModeRevision = (sessionState.permissionModeRevision ?? 0) + 1;
     await this.codexAcpClient.setAgentMode(
       sessionState.sessionId,
       newMode
@@ -33511,14 +33613,24 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   createSessionConfigOptions(sessionState) {
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
+    const useRecommendedValue = clientSupportsAirCapability(
+      this.clientCapabilities,
+      AIR_RECOMMENDED_CONFIG_VALUE_KEY
+    );
+    const currentModel = this.findCurrentModel(sessionState.availableModels, sessionState.currentModelId);
+    const recommendedModelId = useRecommendedValue ? sessionState.availableModels.find((model) => model.isDefault)?.id : void 0;
     const configOptions = [
       sessionState.agentMode.toConfigOption(),
       createCollaborationModeConfigOption(sessionState.collaborationMode),
-      createModelConfigOption(sessionState.availableModels, currentModelId.model)
+      createModelConfigOption(sessionState.availableModels, currentModelId.model, recommendedModelId)
     ];
     if (sessionState.supportedReasoningEfforts.length > 0) {
       configOptions.push(
-        createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort)
+        createReasoningEffortConfigOption(
+          sessionState.supportedReasoningEfforts,
+          currentModelId.effort,
+          useRecommendedValue ? currentModel?.defaultReasoningEffort : void 0
+        )
       );
     }
     if (sessionState.currentModelSupportsFast) {
@@ -33595,14 +33707,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const modelId = ModelId.fromString(currentModelId);
     return models.find((m) => m.id === modelId.model);
   }
-  normalizeModelDisplayName(displayName) {
-    return displayName.split("-").map((token) => _CodexAcpServer.MODEL_NAME_TOKEN_OVERRIDES[token.toLowerCase()] ?? token).join("-");
-  }
   createModelState(availableModels, selectedModelId) {
     const allowedModels = availableModels.flatMap(
       (model) => model.supportedReasoningEfforts.map((effort) => ({
         modelId: ModelId.fromComponents(model, effort.reasoningEffort).toString(),
-        name: `${this.normalizeModelDisplayName(model.displayName)} (${effort.reasoningEffort})`,
+        name: `${formatModelDisplayName(model.displayName)} (${effort.reasoningEffort})`,
         description: `${model.description} ${effort.description}`
       }))
     );
@@ -33656,6 +33765,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      fullAccessHttpMcpServers: sessionMetadata.fullAccessHttpMcpServers ?? [],
       collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
@@ -34400,16 +34510,27 @@ Check ${configPath} and project .codex directories, especially their config.toml
       eventHandler = promptEventHandler;
       const permissionLifecycle = this.permissionLifecycleContext(sessionState);
       const permissionContext = permissionLifecycle.beginPrompt();
+      let promptAgentMode;
+      let permissionModeRevision;
+      const httpServers = new Set(sessionState.fullAccessHttpMcpServers);
+      const noHttpServers = /* @__PURE__ */ new Set();
+      let mcpApprovalTurnId = null;
+      const isProtectedFullAccess = () => this.codexAcpClient.isProtectedFullAccess(promptAgentMode ?? sessionState.agentMode);
       const approvalHandler = new CodexApprovalHandler(
         this.connection,
         permissionContext,
-        activePrompt.signal
+        activePrompt.signal,
+        isProtectedFullAccess
       );
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
         permissionContext,
         this.clientCapabilities,
-        activePrompt.signal
+        activePrompt.signal,
+        (request) => {
+          if (!isProtectedFullAccess()) return void 0;
+          return mcpApprovalTurnId !== null && request.turnId === mcpApprovalTurnId && sessionState.agentMode.kind === "full_access" && sessionState.permissionModeRevision === permissionModeRevision ? httpServers : noHttpServers;
+        }
       );
       const observeInteraction = async (event) => {
         permissionContext.handleNotification(event);
@@ -34534,6 +34655,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw RequestError.invalidRequest("The current model does not support image input");
       }
       const agentMode = sessionState.agentMode;
+      promptAgentMode = agentMode;
+      permissionModeRevision = sessionState.permissionModeRevision;
       const serviceTier = resolveFastServiceTier(
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
@@ -34550,6 +34673,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           sessionState.cwd,
           sessionState.additionalDirectories,
           (turnId) => {
+            mcpApprovalTurnId = turnId;
             const turn = { threadId: params.sessionId, turnId };
             activePrompt.currentTurn = turn;
             if (this.promptShouldStop(params.sessionId, activePrompt)) {
@@ -34560,7 +34684,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             pendingTurnStart?.resolve(turnId);
             onTurnStarted?.();
           },
-          () => this.promptShouldStop(params.sessionId, activePrompt)
+          () => this.promptShouldStop(params.sessionId, activePrompt) || sessionState.permissionModeRevision !== permissionModeRevision
         )
       );
       void sendPromptPromise.catch((err) => {
@@ -34640,6 +34764,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               sessionState.cwd,
               sessionState.additionalDirectories,
               (turnId) => {
+                mcpApprovalTurnId = turnId;
                 const turn = { threadId: params.sessionId, turnId };
                 activePrompt.currentTurn = turn;
                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
@@ -34650,7 +34775,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
                 recoverableSessionFailure = sessionState.sessionFailure;
                 promptNotificationsActive = true;
               },
-              () => this.promptShouldStop(params.sessionId, activePrompt)
+              () => this.promptShouldStop(params.sessionId, activePrompt) || sessionState.permissionModeRevision !== permissionModeRevision
             )
           );
           void implementationPromise.catch((err) => {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.10.0-agentconnect.1",
+  "version": "1.11.0-agentconnect.1",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -65,7 +65,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.3",
+    "@openai/codex": "^0.153.4",
     "diff": "^9.0.0",
     "open": "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",