@nyssance/codex-acp-v2 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.7.1 — 2026-09-29
+
+### Changed
+
+- Generated against Codex 0.158.0 (`@openai/codex` `^0.158.0`); the version floor follows.
+- MCP `openai/userVerification` elicitations (signed device challenges) are declined with
+  `cancelled`: ACP has no surface for them and enrollment stays inside Codex.
+- `codexErrorInfo` `flexUnavailable` classifies as `flex_unavailable`, retryable.
+- Replayed `image` user input renders `image:<fileId>` when Codex stored an uploaded file
+  instead of a URL.
+
+## 0.7.0 — 2026-09-29
+
+### Changed
+
+- `session/prompt` returns `{messageId}` (ACP v2, sdk 1.5.1). The id is passed to Codex as
+  `clientUserMessageId`; `user_message` echoes and replays report it as `messageId`
+  (`userMessage.clientId ?? id`). Steering returns `{messageId, _meta.codex.steered}`.
+
 ## 0.6.0 — 2026-09-11
 
 ### Added

package/README.md

@@ -59,7 +59,7 @@ See [`docs/protocol.md`](docs/protocol.md) for the exact wire contract.
 
 ## Requirements
 
-- Codex CLI **0.153.0 or newer** — the app-server types under `src/app-server` are generated
+- Codex CLI **0.158.0 or newer** — the app-server types under `src/app-server` are generated
   from the `@openai/codex` release named in `optionalDependencies`, and the agent checks
   `codex --version` before starting the server; an older Codex fails at startup with an
   upgrade hint.

package/dist/index.js

@@ -3190,13 +3190,13 @@ var require_ril = __commonJS(function(exports) {
   var util_1 = __require("util");
   var api_1 = require_api();
 
-  class MessageBuffer extends api_1.AbstractMessageBuffer {
+  class MessageBuffer2 extends api_1.AbstractMessageBuffer {
     static emptyBuffer = Buffer.allocUnsafe(0);
     constructor(encoding = "utf-8") {
       super(encoding);
     }
     emptyBuffer() {
-      return MessageBuffer.emptyBuffer;
+      return MessageBuffer2.emptyBuffer;
     }
     fromString(value, encoding) {
       return Buffer.from(value, encoding);
@@ -3282,7 +3282,7 @@ var require_ril = __commonJS(function(exports) {
   }
   var _ril = Object.freeze({
     messageBuffer: Object.freeze({
-      create: (encoding) => new MessageBuffer(encoding)
+      create: (encoding) => new MessageBuffer2(encoding)
     }),
     applicationJson: Object.freeze({
       encoder: Object.freeze({
@@ -15886,7 +15886,9 @@ var zSetSessionConfigOptionResponse = object({
     return;
   })
 });
+var zMessageId = string2();
 var zPromptResponse = object({
+  messageId: zMessageId,
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
@@ -16044,7 +16046,6 @@ var zAgentResponse = union([
     error: zError
   })
 ]);
-var zMessageId = string2();
 var zContentChunk = object({
   messageId: zMessageId,
   content: zContentBlock,
@@ -16324,6 +16325,22 @@ var zUsageUpdate = object({
     return;
   })
 });
+var zNoticeSeverity = union([
+  literal("info"),
+  literal("warning"),
+  literal("error"),
+  string2()
+]);
+var zNotice = object({
+  severity: zNoticeSeverity,
+  title: string2().min(1),
+  description: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zCompactionId = string2();
 var zCompactionStatus = union([
   literal("in_progress"),
@@ -16404,6 +16421,9 @@ var zSessionUpdate = preserveCustomPayload(union([
   zUsageUpdate.and(object({
     sessionUpdate: literal("usage_update")
   })),
+  zNotice.and(object({
+    sessionUpdate: literal("notice")
+  })),
   zCompactionUpdate.and(object({
     sessionUpdate: literal("compaction_update")
   })),
@@ -16421,6 +16441,7 @@ var zSessionUpdate = preserveCustomPayload(union([
     "compaction_summary_chunk",
     "compaction_update",
     "config_option_update",
+    "notice",
     "plan_removed",
     "plan_update",
     "session_info_update",
@@ -16442,6 +16463,7 @@ var zSessionUpdate = preserveCustomPayload(union([
   "compaction_summary_chunk",
   "compaction_update",
   "config_option_update",
+  "notice",
   "plan_removed",
   "plan_update",
   "session_info_update",
@@ -17148,6 +17170,7 @@ var zGuardSessionUpdateAvailableCommandsUpdate = zAvailableCommandsUpdate.and(ob
 var zGuardSessionUpdateConfigOptionUpdate = zConfigOptionUpdate.and(object({ sessionUpdate: literal("config_option_update") }));
 var zGuardSessionUpdateSessionInfoUpdate = zSessionInfoUpdate.and(object({ sessionUpdate: literal("session_info_update") }));
 var zGuardSessionUpdateUsageUpdate = zUsageUpdate.and(object({ sessionUpdate: literal("usage_update") }));
+var zGuardSessionUpdateNotice = zNotice.and(object({ sessionUpdate: literal("notice") }));
 var zGuardSessionUpdateCompactionUpdate = zCompactionUpdate.and(object({ sessionUpdate: literal("compaction_update") }));
 var zGuardSessionUpdateCompactionSummaryChunk = zCompactionSummaryChunk.and(object({ sessionUpdate: literal("compaction_summary_chunk") }));
 var zGuardStateUpdateRunning = zRunningStateUpdate.and(object({ state: literal("running") }));
@@ -17258,6 +17281,9 @@ var SessionUpdate = {
   isUsageUpdate(value) {
     return tagOf(value, "sessionUpdate") === "usage_update" && zGuardSessionUpdateUsageUpdate.safeParse(value).success;
   },
+  isNotice(value) {
+    return tagOf(value, "sessionUpdate") === "notice" && zGuardSessionUpdateNotice.safeParse(value).success;
+  },
   isCompactionUpdate(value) {
     return tagOf(value, "sessionUpdate") === "compaction_update" && zGuardSessionUpdateCompactionUpdate.safeParse(value).success;
   },
@@ -17275,6 +17301,7 @@ var SessionUpdate = {
       "compaction_summary_chunk",
       "compaction_update",
       "config_option_update",
+      "notice",
       "plan_removed",
       "plan_update",
       "session_info_update",
@@ -18106,53 +18133,124 @@ function protocolErrorResponse(error40) {
   };
 }
 
+// node_modules/@agentclientprotocol/sdk/dist/stream-limits.js
+var DEFAULT_MAX_MESSAGE_BYTES = 32 * 1024 * 1024;
+
+class MessageTooLargeError extends Error {
+  maxMessageBytes;
+  constructor(maxMessageBytes) {
+    super(`Incoming ACP data exceeds the configured ${maxMessageBytes} byte limit`);
+    this.maxMessageBytes = maxMessageBytes;
+    this.name = "MessageTooLargeError";
+  }
+}
+function resolveMaxMessageBytes(value) {
+  const maxMessageBytes = value ?? DEFAULT_MAX_MESSAGE_BYTES;
+  if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes <= 0) {
+    throw new RangeError("maxMessageBytes must be a positive safe integer");
+  }
+  return maxMessageBytes;
+}
+
+class MessageBuffer {
+  #buffer = new Uint8Array(0);
+  #length = 0;
+  #maxMessageBytes;
+  constructor(maxMessageBytes) {
+    this.#maxMessageBytes = resolveMaxMessageBytes(maxMessageBytes);
+  }
+  get byteLength() {
+    return this.#length;
+  }
+  get lastByte() {
+    return this.#buffer[this.#length - 1];
+  }
+  #checkAppend(byteLength) {
+    if (byteLength > this.#maxMessageBytes - this.#length) {
+      this.clear();
+      throw new MessageTooLargeError(this.#maxMessageBytes);
+    }
+  }
+  append(bytes) {
+    this.#checkAppend(bytes.byteLength);
+    const length = this.#length + bytes.byteLength;
+    if (length > this.#buffer.byteLength) {
+      const capacity = Math.min(this.#maxMessageBytes, Math.max(length, this.#buffer.byteLength * 2, 1024));
+      const buffer = new Uint8Array(capacity);
+      buffer.set(this.#buffer.subarray(0, this.#length));
+      this.#buffer = buffer;
+    }
+    this.#buffer.set(bytes, this.#length);
+    this.#length = length;
+  }
+  take() {
+    const bytes = this.#buffer.subarray(0, this.#length);
+    this.clear();
+    return bytes;
+  }
+  clear() {
+    this.#buffer = new Uint8Array(0);
+    this.#length = 0;
+  }
+}
+
 // node_modules/@agentclientprotocol/sdk/dist/line-buffer.js
 var newline = 10;
 
 class LineBuffer {
-  #pending = [];
-  push(chunk) {
-    const lines = [];
+  #pending;
+  #maxMessageBytes;
+  constructor(maxMessageBytes) {
+    this.#maxMessageBytes = resolveMaxMessageBytes(maxMessageBytes);
+    this.#pending = new MessageBuffer(Math.min(Number.MAX_SAFE_INTEGER, this.#maxMessageBytes + 1));
+  }
+  *push(chunk) {
     let start = 0;
     let newlineIndex = chunk.indexOf(newline, start);
     while (newlineIndex !== -1) {
-      lines.push(this.#takeLine(chunk.subarray(start, newlineIndex)));
+      yield this.#takeLine(chunk.subarray(start, newlineIndex));
       start = newlineIndex + 1;
       newlineIndex = chunk.indexOf(newline, start);
     }
     if (start < chunk.byteLength) {
-      this.#pending.push(start === 0 ? chunk : new Uint8Array(chunk.subarray(start)));
+      const tail = chunk.subarray(start);
+      this.#checkLine(tail);
+      this.#pending.append(tail);
     }
-    return lines;
   }
   flush() {
-    if (this.#pending.length === 0) {
+    if (this.#pending.byteLength === 0) {
       return;
     }
-    return this.#takeLine(new Uint8Array(0));
+    return stripCarriageReturn(this.#pending.take());
+  }
+  clear() {
+    this.#pending.clear();
   }
   #takeLine(tail) {
-    if (this.#pending.length === 0) {
-      return tail;
+    this.#checkLine(tail);
+    if (this.#pending.byteLength === 0) {
+      return stripCarriageReturn(tail);
     }
-    let total = tail.byteLength;
-    for (const part of this.#pending) {
-      total += part.byteLength;
-    }
-    const line = new Uint8Array(total);
-    let offset = 0;
-    for (const part of this.#pending) {
-      line.set(part, offset);
-      offset += part.byteLength;
+    this.#pending.append(tail);
+    return stripCarriageReturn(this.#pending.take());
+  }
+  #checkLine(tail) {
+    const lastByte = tail.byteLength > 0 ? tail[tail.byteLength - 1] : this.#pending.lastByte;
+    const byteLength = this.#pending.byteLength + tail.byteLength - (lastByte === 13 ? 1 : 0);
+    if (byteLength > this.#maxMessageBytes) {
+      this.clear();
+      throw new MessageTooLargeError(this.#maxMessageBytes);
     }
-    line.set(tail, offset);
-    this.#pending = [];
-    return line;
   }
 }
+function stripCarriageReturn(line) {
+  return line[line.byteLength - 1] === 13 ? line.subarray(0, -1) : line;
+}
 
 // node_modules/@agentclientprotocol/sdk/dist/stream.js
-function ndJsonStream(output, input) {
+function ndJsonStream(output, input, options = {}) {
+  const maxMessageBytes = resolveMaxMessageBytes(options.maxMessageBytes);
   const textEncoder = new TextEncoder;
   const textDecoder = new TextDecoder;
   let cancelled = false;
@@ -18174,7 +18272,7 @@ function ndJsonStream(output, input) {
   };
   const readable = new ReadableStream({
     async start(controller) {
-      const lines = new LineBuffer;
+      const lines = new LineBuffer(maxMessageBytes);
       const enqueueLine = async (lineBytes) => {
         const trimmedLine = textDecoder.decode(lineBytes).trim();
         if (!trimmedLine) {
@@ -18226,8 +18324,10 @@ function ndJsonStream(output, input) {
           return;
         }
         controller.error(err);
+        reader.cancel(err).catch(() => {});
         return;
       } finally {
+        lines.clear();
         if (inputReader === reader) {
           inputReader = undefined;
         }
@@ -19711,6 +19811,22 @@ var zUsageUpdate2 = object({
     return;
   })
 });
+var zNoticeSeverity2 = union([
+  literal("info"),
+  literal("warning"),
+  literal("error"),
+  string2()
+]);
+var zNotice2 = object({
+  severity: zNoticeSeverity2,
+  title: string2().min(1),
+  description: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zCompactionId2 = string2();
 var zCompactionStatus2 = union([
   literal("in_progress"),
@@ -19779,6 +19895,9 @@ var zSessionUpdate2 = union([
   zUsageUpdate2.and(object({
     sessionUpdate: literal("usage_update")
   })),
+  zNotice2.and(object({
+    sessionUpdate: literal("notice")
+  })),
   zCompactionUpdate2.and(object({
     sessionUpdate: literal("compaction_update")
   })),
@@ -19840,6 +19959,7 @@ var zSessionConfigOptionsCapabilities = object({
     return;
   })
 });
+var zNoticeCapabilities = record(string2(), unknown());
 var zClientSessionCapabilities = object({
   compaction: defaultOnError(zCompactionCapabilities.nullish(), () => {
     return;
@@ -19847,6 +19967,9 @@ var zClientSessionCapabilities = object({
   configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => {
     return;
   }),
+  notices: defaultOnError(zNoticeCapabilities.nullish(), () => {
+    return;
+  }),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
@@ -20522,8 +20645,8 @@ var zCancelRequestNotification2 = object({
   })
 });
 // node_modules/@agentclientprotocol/sdk/dist/v2/acp.js
-function ndJsonStream2(output, input) {
-  return ndJsonStream(output, input);
+function ndJsonStream2(output, input, options) {
+  return ndJsonStream(output, input, options);
 }
 function emptyObjectResponse(response) {
   return response ?? {};
@@ -21367,7 +21490,7 @@ var agentRequestSpecs = {
   unstable_disableProvider: requestSpec(AGENT_METHODS.providers_disable, zDisableProviderRequest, zDisableProviderResponse, emptyObjectResponse),
   newSession: requestSpec(AGENT_METHODS.session_new, zNewSessionRequest, zNewSessionResponse),
   setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, zSetSessionConfigOptionRequest, zSetSessionConfigOptionResponse),
-  prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest, zPromptResponse, emptyObjectResponse),
+  prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest, zPromptResponse),
   unstable_messageMcp: requestSpec(AGENT_METHODS.mcp_message, zMessageMcpRequest, zMessageMcpResponse),
   listSessions: requestSpec(AGENT_METHODS.session_list, zListSessionsRequest, zListSessionsResponse),
   deleteSession: requestSpec(AGENT_METHODS.session_delete, zDeleteSessionRequest, zDeleteSessionResponse, emptyObjectResponse),
@@ -21721,7 +21844,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.6.0",
+  version: "0.7.1",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -21755,7 +21878,7 @@ var package_default = {
     "package:win-x64": "cd dist/bin && zip codex-acp-v2-x64-windows.zip codex-acp-v2-x64-windows.exe",
     "package:win-arm64": "cd dist/bin && zip codex-acp-v2-arm64-windows.zip codex-acp-v2-arm64-windows.exe",
     start: "bun src/index.ts",
-    "generate-types": "codex app-server generate-ts --out src/app-server",
+    "generate-types": "codex app-server generate-ts --experimental --out src/app-server",
     test: "vitest run --exclude src/__tests__/e2e.test.ts",
     "test:watch": "vitest",
     typecheck: "tsc --noEmit",
@@ -21787,53 +21910,194 @@ var package_default = {
     vitest: "^4.1.11"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^1.4.0",
+    "@agentclientprotocol/sdk": "^1.5.1",
     diff: "^9.0.0",
     open: "^11.0.2",
     "vscode-jsonrpc": "^9.0.2"
   },
   optionalDependencies: {
-    "@openai/codex": "^0.153.0"
+    "@openai/codex": "^0.158.0"
   }
 };
 
+// src/util/abort.ts
+function abortable(operation, signal) {
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    signal.addEventListener("abort", abort, { once: true });
+    operation.then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error40) => {
+      cleanup();
+      reject(error40);
+    });
+  });
+}
+
+// src/agent/clientTools.ts
+var PREFIX = "alwith_client_";
+var MAX_RESULT_BYTES = 16 * 1024 * 1024;
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function clientToolsOf(meta) {
+  if (!record2(meta) || !record2(meta["alwith"]) || meta["alwith"]["tools"] === undefined)
+    return;
+  const value = meta["alwith"]["tools"];
+  if (!record2(value) || value["version"] !== 1 || typeof value["revision"] !== "string" || !value["revision"].trim() || !Array.isArray(value["definitions"]) || value["definitions"].length > 128) {
+    throw RequestError.invalidParams(undefined, "Expected a version 1 client tool set with revision and definitions");
+  }
+  const names = new Set;
+  const definitions = value["definitions"].map((tool) => {
+    if (!record2(tool) || typeof tool["name"] !== "string" || !/^[a-zA-Z][a-zA-Z0-9_]{0,49}$/.test(tool["name"]) || names.has(tool["name"]) || typeof tool["description"] !== "string" || !record2(tool["inputSchema"]) || tool["inputSchema"]["type"] !== "object") {
+      throw RequestError.invalidParams(undefined, "Client tools require unique names, descriptions and object input schemas");
+    }
+    names.add(tool["name"]);
+    return { name: tool["name"], description: tool["description"], inputSchema: structuredClone(tool["inputSchema"]) };
+  });
+  return { version: 1, revision: value["revision"], definitions };
+}
+function dynamicTools(set2) {
+  return set2.definitions.map((tool) => ({ type: "function", ...tool, name: PREFIX + tool["name"], deferLoading: false }));
+}
+function failure(message) {
+  return { success: false, contentItems: [{ type: "inputText", text: message }] };
+}
+function toolResponse(value) {
+  if (!record2(value) || typeof value["success"] !== "boolean" || !Array.isArray(value["contentItems"]) || Buffer.byteLength(JSON.stringify(value)) > MAX_RESULT_BYTES) {
+    throw new Error("Invalid or oversized client tool result");
+  }
+  const contentItems = value["contentItems"].map((item) => {
+    if (!record2(item))
+      throw new Error("Invalid client tool content");
+    if (item["type"] === "text" && typeof item["text"] === "string")
+      return { type: "inputText", text: item["text"] };
+    if ((item["type"] === "image" || item["type"] === "audio") && typeof item["data"] === "string" && typeof item["mimeType"] === "string" && /^[A-Za-z0-9+/]*={0,2}$/.test(item["data"])) {
+      const supported = item["type"] === "image" ? /^image\/(png|jpeg|webp|gif)$/ : /^audio\/(wav|mpeg|mp3|ogg|flac|mp4)$/;
+      if (!supported.test(item["mimeType"]))
+        throw new Error("Unsupported client tool media type");
+      const url2 = `data:${item["mimeType"]};base64,${item["data"]}`;
+      return item["type"] === "image" ? { type: "inputImage", imageUrl: url2 } : { type: "inputAudio", audioUrl: url2 };
+    }
+    throw new Error("Client tool content must be text or bounded inline media");
+  });
+  return { success: value["success"], contentItems };
+}
+
+class ClientTools {
+  session;
+  client;
+  lifetime;
+  calls = new WeakMap;
+  constructor(session, client, lifetime) {
+    this.session = session;
+    this.client = client;
+    this.lifetime = lifetime;
+  }
+  call(params) {
+    const turn = this.session.activeTurn;
+    const set2 = this.session.clientTools;
+    if (!turn || !set2 || this.session.closed || this.lifetime.aborted || turn.abort.signal.aborted || params.threadId !== this.session.id || params.namespace !== null || turn.turnId !== null && params.turnId !== turn.turnId)
+      return Promise.resolve(failure("Client tool turn is no longer active"));
+    const tool = set2.definitions.find((tool2) => PREFIX + tool2["name"] === params.tool);
+    if (!tool)
+      return Promise.resolve(failure("Client tool was not declared for this session"));
+    let calls = this.calls.get(turn);
+    if (!calls) {
+      calls = new Map;
+      this.calls.set(turn, calls);
+    }
+    const fingerprint = JSON.stringify([params.tool, params.arguments, set2.revision]);
+    const previous = calls.get(params.callId);
+    if (previous)
+      return previous.fingerprint === fingerprint ? previous.response : Promise.resolve(failure("Client tool call ID was reused with different arguments"));
+    const response = this.execute(turn, set2, tool, params);
+    calls.set(params.callId, { fingerprint, response });
+    return response;
+  }
+  async execute(turn, set2, tool, params) {
+    const signal = AbortSignal.any([this.lifetime, this.client.signal, turn.abort.signal, turn.stop.signal]);
+    try {
+      signal.throwIfAborted();
+      const turnId = turn.turnId ?? await abortable(turn.started, signal);
+      if (turnId !== params.turnId || this.session.activeTurn !== turn)
+        return failure("Client tool turn is no longer active");
+      if (this.session.mode.approvalPolicy !== "never") {
+        const permission = await this.client.requestPermission({
+          title: `Run ${tool["name"]}?`,
+          subject: { type: "tool_call", toolCall: { toolCallId: params.callId, name: tool["name"], title: tool["description"], kind: "other", status: "pending" } },
+          options: [{ optionId: "allow_once", name: "Allow", kind: "allow_once" }, { optionId: "reject_once", name: "Reject", kind: "reject_once" }]
+        }, signal);
+        if (permission.outcome.outcome !== "selected" || permission.outcome.optionId !== "allow_once")
+          return failure("Client tool permission was denied");
+      }
+      signal.throwIfAborted();
+      const value = await abortable(this.client.requestTool({
+        sessionId: this.session.id,
+        turnId: params.turnId,
+        toolCallId: params.callId,
+        name: tool["name"],
+        arguments: params.arguments,
+        toolSetRevision: set2.revision
+      }, signal), signal);
+      if (this.session.activeTurn !== turn)
+        return failure("Client tool turn is no longer active");
+      signal.throwIfAborted();
+      return toolResponse(value);
+    } catch {
+      return failure(signal.aborted ? "Client tool call was cancelled" : "Client tool call failed");
+    }
+  }
+}
+
 // src/agent/turnErrors.ts
 function classifyTurnError(info) {
-  const failure = (category, retryable = false, stopReason = "_error") => ({ category, retryable, stopReason });
+  const failure2 = (category, retryable = false, stopReason = "_error") => ({ category, retryable, stopReason });
   if (info === null)
-    return failure("unknown");
+    return failure2("unknown");
   if (typeof info === "object") {
     if ("activeTurnNotSteerable" in info)
-      return failure("turn_not_steerable");
+      return failure2("turn_not_steerable");
     const status = "httpConnectionFailed" in info ? info.httpConnectionFailed.httpStatusCode : ("responseStreamConnectionFailed" in info) ? info.responseStreamConnectionFailed.httpStatusCode : ("responseStreamDisconnected" in info) ? info.responseStreamDisconnected.httpStatusCode : info.responseTooManyFailedAttempts.httpStatusCode;
-    return failure("connection", status === null || status === 408 || status === 429 || status >= 500);
+    return failure2("connection", status === null || status === 408 || status === 429 || status >= 500);
   }
   switch (info) {
     case "contextWindowExceeded":
-      return failure("context_window", false, "max_tokens");
+      return failure2("context_window", false, "max_tokens");
     case "cyberPolicy":
     case "misalignmentPolicyViolation":
-      return failure("policy", false, "refusal");
+      return failure2("policy", false, "refusal");
     case "sessionBudgetExceeded":
-      return failure("budget");
+      return failure2("budget");
     case "usageLimitExceeded":
-      return failure("usage_limit");
+      return failure2("usage_limit");
     case "rateLimitExceeded":
-      return failure("rate_limit", true);
+      return failure2("rate_limit", true);
     case "serverOverloaded":
-      return failure("overloaded", true);
+      return failure2("overloaded", true);
+    case "flexUnavailable":
+      return failure2("flex_unavailable", true);
     case "internalServerError":
-      return failure("internal", true);
+      return failure2("internal", true);
     case "unauthorized":
-      return failure("authentication");
+      return failure2("authentication");
     case "badRequest":
-      return failure("invalid_request");
+      return failure2("invalid_request");
     case "threadRollbackFailed":
-      return failure("rollback");
+      return failure2("rollback");
     case "sandboxError":
-      return failure("sandbox");
+      return failure2("sandbox");
     case "other":
-      return failure("unknown");
+      return failure2("unknown");
   }
 }
 
@@ -23294,7 +23558,7 @@ function fromUserInput(input) {
     case "text":
       return input.text.length > 0 ? [{ type: "text", text: input.text }] : [];
     case "image":
-      return [{ type: "text", text: formatUriAsLink("image", input.url) }];
+      return [{ type: "text", text: "url" in input ? formatUriAsLink("image", input.url) : `image:${input.fileId}` }];
     case "localImage":
       return [{ type: "text", text: formatUriAsLink(null, toFileUri(input.path)) }];
     case "skill":
@@ -23344,7 +23608,7 @@ function itemSnapshot(item) {
   switch (item.type) {
     case "userMessage": {
       const content = item.content.flatMap(fromUserInput);
-      return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.id, content }] : [];
+      return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.clientId ?? item.id, content }] : [];
     }
     case "agentMessage":
       return item.text.length > 0 ? [{
@@ -23642,6 +23906,8 @@ ${details}` : summary)];
       case "mcpServer/event/stream/notification":
       case "account/updated":
       case "account/login/completed":
+      case "account/gatewayOAuth/changed":
+      case "thread/attachment/updated":
       case "app/list/updated":
       case "remoteControl/status/changed":
       case "externalAgentConfig/import/progress":
@@ -23701,7 +23967,7 @@ ${details}` : summary)];
         return [compactionUpdate(item.id, "in_progress")];
       case "userMessage": {
         const content = item.content.flatMap(fromUserInput);
-        return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.id, content }] : [];
+        return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.clientId ?? item.id, content }] : [];
       }
       case "hookPrompt":
       case "functionCallOutput":
@@ -24630,6 +24896,10 @@ class CodexElicitationHandler {
   }
   async handleElicitation(params) {
     try {
+      if (params.mode === "openai/userVerification") {
+        logger.log("MCP user verification is not supported over ACP", { server: params.serverName });
+        return cancelled();
+      }
       const context = this.mcpContext(params);
       const messageOnly = isMessageOnlyForm(params);
       if (!messageOnly && this.useAcpElicitation(params)) {
@@ -24902,29 +25172,6 @@ class TurnContext {
   }
 }
 
-// src/util/abort.ts
-function abortable(operation, signal) {
-  if (signal.aborted) {
-    operation.catch(() => {});
-    return Promise.reject(signal.reason);
-  }
-  return new Promise((resolve, reject) => {
-    const abort = () => {
-      cleanup();
-      reject(signal.reason);
-    };
-    const cleanup = () => signal.removeEventListener("abort", abort);
-    signal.addEventListener("abort", abort, { once: true });
-    operation.then((value) => {
-      cleanup();
-      resolve(value);
-    }, (error40) => {
-      cleanup();
-      reject(error40);
-    });
-  });
-}
-
 // node_modules/open/index.js
 import process10 from "process";
 import path5 from "path";
@@ -25742,6 +25989,9 @@ class ClientSession {
       return signal ? abortable(pending, signal) : pending;
     }, signal);
   }
+  async requestTool(params, signal) {
+    return await this.link.request("_alwith/tool/call", params, { cancellationSignal: signal });
+  }
   async createElicitation(request, signal) {
     signal = signal ? AbortSignal.any([signal, this.output.signal]) : this.output.signal;
     signal.throwIfAborted();
@@ -26021,7 +26271,7 @@ async function applyConfigOption(session, codex, request) {
         threadId: session.id,
         collaborationMode: {
           mode,
-          settings: { model: session.model.model, reasoning_effort: session.model.effort, developer_instructions: null }
+          settings: { model: findModel(session.catalog, session.model.model)?.model ?? session.model.model, reasoning_effort: session.model.effort, developer_instructions: null }
         }
       });
       session.collaborationMode = mode;
@@ -26077,6 +26327,9 @@ var OPENAI_PROVIDER_ID = "openai";
 var GATEWAY_MODEL_PROVIDER = "custom-gateway";
 var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var GATEWAY_ID_PATTERN = /^[a-z0-9-]+$/;
+function gatewayModelId(connectionId, modelId) {
+  return `gateway:${encodeURIComponent(connectionId)}:${encodeURIComponent(modelId)}`;
+}
 
 class ProviderRouting {
   baseConfig;
@@ -26131,14 +26384,6 @@ class ProviderRouting {
     }
     if (hints.mode === "route" || this.mode !== hints.mode)
       this.gateways.clear();
-    for (const other of this.gateways.values()) {
-      if (other.id === hints.id)
-        continue;
-      const duplicate = hints.models.find((model) => other.models.some((candidate) => candidate.id === model.id));
-      if (duplicate) {
-        throw RequestError.invalidParams({ id: hints.id, model: duplicate.id }, `Model "${duplicate.id}" is already served by gateway "${other.id}"; model ids must be unique across gateways`);
-      }
-    }
     this.gateways.set(hints.id, {
       id: hints.id,
       baseUrl,
@@ -26157,7 +26402,7 @@ class ProviderRouting {
   }
   gatewayFor(modelId) {
     for (const gateway of this.gateways.values()) {
-      if (gateway.models.some((model) => model.id === modelId))
+      if (gateway.models.some((model) => (this.mode === "catalog" ? gatewayModelId(gateway.id, model.id) : model.id) === modelId))
         return gateway;
     }
     return null;
@@ -26171,7 +26416,19 @@ class ProviderRouting {
   gatewayGroups() {
     if (this.mode !== "catalog")
       return [];
-    return [...this.gateways.values()].filter((gateway) => gateway.models.length > 0).map((gateway) => ({ id: gateway.id, name: gateway.name, modelIds: gateway.models.map((model) => model.id) }));
+    return [...this.gateways.values()].filter((gateway) => gateway.models.length > 0).map((gateway) => ({ id: gateway.id, name: gateway.name, modelIds: gateway.models.map((model) => gatewayModelId(gateway.id, model.id)) }));
+  }
+  selectionId(modelId, provider) {
+    return modelId !== null && this.mode === "catalog" && this.hasGateway(provider) ? gatewayModelId(provider, modelId) : modelId;
+  }
+  upstreamModel(selectionId) {
+    if (selectionId === null || !selectionId.startsWith("gateway:"))
+      return selectionId;
+    const gateway = this.gatewayFor(selectionId);
+    const model = gateway?.models.find((model2) => gatewayModelId(gateway.id, model2.id) === selectionId);
+    if (!model)
+      throw RequestError.invalidParams({ model: selectionId }, "The selected provider connection or model is unavailable");
+    return model.id;
   }
   disable(request) {
     if (request.providerId !== OPENAI_PROVIDER_ID)
@@ -26250,7 +26507,7 @@ class ProviderRouting {
     const own = [];
     for (const gateway of this.gateways.values()) {
       for (const model of gateway.models)
-        own.push(gatewayModel(model, false, codexCatalog[0], gateway.catalogEntries.get(model.id)));
+        own.push({ ...gatewayModel(model, false, codexCatalog[0], gateway.catalogEntries.get(model.id)), id: gatewayModelId(gateway.id, model.id) });
     }
     return [...codexCatalog, ...own];
   }
@@ -26374,12 +26631,13 @@ function gatewayModel(model, isDefault, template, entry) {
     additionalSpeedTiers: [],
     serviceTiers: [],
     defaultServiceTier: null,
+    availableAccessPrograms: null,
     isDefault
   };
 }
 
 // src/agent/session.ts
-function createActiveTurn(threadId) {
+function createActiveTurn(threadId, clientUserMessageId = null) {
   let resolveStarted = () => {};
   let resolveFinished = () => {};
   let started = new Promise((resolve) => {
@@ -26393,6 +26651,7 @@ function createActiveTurn(threadId) {
   return {
     turnId: null,
     threadId,
+    clientUserMessageId,
     abort: new AbortController,
     stop: new AbortController,
     interrupts: new Map,
@@ -26517,7 +26776,7 @@ class CodexAgent {
           additionalDirectories: {}
         },
         providers: {},
-        _meta: { codex: { archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
+        _meta: { alwith: { tools: { version: 1 } }, codex: { archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
       },
       authMethods: authMethods(this.capabilities, this.env)
     };
@@ -26604,7 +26863,8 @@ class CodexAgent {
         const catalog = await this.withCodex(() => this.codex.allModels(true));
         const nativeProvider = await this.resolveModelProvider(candidate);
         const wholesale = this.providers.active !== null && this.providers.mode === "route" || candidate.active !== null && candidate.mode === "route";
-        const moving = [...this.sessions.values()].filter((runtime) => wholesale || this.providers.hasGateway(runtime.modelProvider) && candidate.gateway(runtime.modelProvider) !== this.providers.gateway(runtime.modelProvider));
+        const unavailable = new Set([...this.sessions.values()].filter((runtime) => this.providers.mode === "catalog" && this.providers.hasGateway(runtime.modelProvider) && !candidate.hasGateway(runtime.modelProvider)));
+        const moving = [...this.sessions.values()].filter((runtime) => !unavailable.has(runtime) && (wholesale || this.providers.hasGateway(runtime.modelProvider) && candidate.gateway(runtime.modelProvider) !== this.providers.gateway(runtime.modelProvider)));
         const targets = new Map(moving.map((runtime) => {
           if (candidate.active === null)
             return [runtime, null];
@@ -26637,11 +26897,13 @@ class CodexAgent {
             cwd: runtime.session.cwd,
             config: config2,
             modelProvider,
-            model: selection.model,
+            model: candidate.upstreamModel(selection.model),
             excludeTurns: true
           }));
-          staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, requestedModel ?? thread.model, thread.reasoningEffort) });
+          staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, requestedModel ?? candidate.selectionId(thread.model, modelProvider), thread.reasoningEffort) });
         }
+        for (const runtime of unavailable)
+          runtime.config = candidate.rebind(runtime.config, this.providers, null);
         this.providers = candidate;
         for (const runtime of this.sessions.values()) {
           const next = staged.get(runtime);
@@ -26653,7 +26915,7 @@ class CodexAgent {
           }
           runtime.session.catalog = nextCatalog;
           runtime.session.gatewayGroups = candidate.gatewayGroups();
-          if (!next)
+          if (!next && !unavailable.has(runtime))
             runtime.session.model = resolveModelSelection(nextCatalog, findModel(nextCatalog, runtime.session.model.model) ? runtime.session.model.model : null, runtime.session.model.effort);
           runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(runtime.session), _meta: { codex: { routing: { stale: false } } } }).catch((error40) => logger.error("Provider config notification failed", error40));
         }
@@ -26669,7 +26931,7 @@ class CodexAgent {
               cwd: runtime.session.cwd,
               config: runtime.config,
               modelProvider: runtime.modelProvider,
-              model: runtime.session.model.model,
+              model: this.providers.upstreamModel(runtime.session.model.model),
               excludeTurns: true
             });
           } catch (rollbackError) {
@@ -26743,6 +27005,13 @@ class CodexAgent {
       this.assertUnsubscribeSettled(open2.request.sessionId);
     }
     const mcpServers = request.mcpServers ?? [];
+    const clientTools = clientToolsOf(request._meta);
+    const host = hostSessionOptions(request._meta);
+    const mode = host.mode ?? initialAgentMode(this.env);
+    const hostThreadOptions = {
+      ...host.instructions === undefined ? {} : { developerInstructions: host.instructions },
+      ...host.mode ? { approvalPolicy: mode.approvalPolicy, approvalsReviewer: mode.approvalsReviewer, sandbox: mode.sandboxMode } : {}
+    };
     const requestedModel = requestedModelOf(request._meta);
     let gatewayId = this.providers.defaultGatewayId();
     if (this.providers.active !== null && this.providers.mode === "catalog") {
@@ -26763,17 +27032,24 @@ class CodexAgent {
     const config2 = buildThreadConfig(this.providers.threadConfig(gatewayId), request.cwd, additionalDirectories, mcpServers, existingMcp);
     const mcpStartupGeneration = this.codex.mcpStartupGeneration;
     const modelProvider = gatewayId ?? await this.withCodex(() => this.resolveModelProvider());
-    const startModel = onGateway ? requestedModel ?? this.providers.gateway(gatewayId)?.model ?? null : requestedModel;
+    const startModel = this.providers.upstreamModel(onGateway ? requestedModel ?? this.providers.gateway(gatewayId)?.model ?? null : requestedModel);
     let readOnly = false;
     const { thread, skills } = await this.withSkillsContext(request.cwd, additionalDirectories, async (skills2) => ({ skills: skills2, thread: await this.withCodex(async () => {
       if (signal?.aborted)
         throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
       switch (open2.kind) {
         case "new":
-          return await this.codex.threadStart({ config: config2, cwd: request.cwd, modelProvider, model: startModel });
+          return await this.codex.threadStart({
+            ...hostThreadOptions,
+            config: config2,
+            cwd: request.cwd,
+            modelProvider,
+            model: startModel,
+            ...clientTools ? { dynamicTools: dynamicTools(clientTools) } : {}
+          });
         case "resume":
           try {
-            return await this.codex.threadResume({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+            return await this.codex.threadResume({ ...hostThreadOptions, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
           } catch (error40) {
             if (!errorMessage(error40).includes("already has an active writer"))
               throw error40;
@@ -26781,7 +27057,7 @@ class CodexAgent {
             return readOnlyThread((await this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false })).thread, request.cwd);
           }
         case "fork":
-          return await this.codex.threadFork({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+          return await this.codex.threadFork({ ...hostThreadOptions, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
       }
     }) }));
     const sessionId = thread.thread.id;
@@ -26810,8 +27086,9 @@ class CodexAgent {
         openedAccount = (await this.withCodex(() => this.codex.accountRead({ refreshToken: false }))).account;
       }
       const catalog = this.providers.catalog(codexCatalog);
-      const model = resolveModelSelection(catalog, startModel ?? thread.model, thread.reasoningEffort);
+      const model = resolveModelSelection(catalog, this.providers.selectionId(startModel ?? thread.model, gatewayId ?? thread.modelProvider), thread.reasoningEffort);
       const session = {
+        ...clientTools ? { clientTools } : {},
         id: sessionId,
         cwd: request.cwd,
         additionalDirectories,
@@ -26819,7 +27096,7 @@ class CodexAgent {
         catalog,
         gatewayGroups: this.providers.gatewayGroups(),
         model,
-        mode: initialAgentMode(this.env),
+        mode,
         collaborationMode: DEFAULT_COLLABORATION_MODE,
         fastMode: thread.serviceTier === FAST_SERVICE_TIER,
         account: openedAccount,
@@ -26888,11 +27165,13 @@ class CodexAgent {
     const approval = new CodexApprovalHandler(client, turnContext, signal);
     const elicitation = new CodexElicitationHandler(client, turnContext, signal);
     const runtime = { config: config2, modelProvider, stale: false, readOnly, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
+    const tools = new ClientTools(session, client, AbortSignal.any([runtime.lifetime.signal, this.codex.disconnectSignal]));
     const drained = (operation) => async (params) => {
       await abortable(this.drain(runtime), this.codex.disconnectSignal);
       return await operation(params);
     };
     this.codex.attachThread(session.id, {
+      tool: (params) => tools.call(params),
       notification: (notification) => this.enqueue(runtime, notification),
       approval: {
         handleCommandExecution: drained((params) => approval.handleCommandExecution(params)),
@@ -26996,8 +27275,8 @@ class CodexAgent {
       const result = await this.codex.awaitMcpStartup(runtime.session.mcpServerNames, afterGeneration, runtime.lifetime.signal, runtime.session.id);
       if (runtime.session.closed)
         return;
-      for (const failure of result.failed) {
-        await runtime.client.update(mcpStartupFailed(failure.server, `MCP server "${failure.server}" failed to start: ${failure.error}`));
+      for (const failure2 of result.failed) {
+        await runtime.client.update(mcpStartupFailed(failure2.server, `MCP server "${failure2.server}" failed to start: ${failure2.error}`));
       }
       for (const server of result.cancelled) {
         await runtime.client.update(mcpStartupFailed(server, `MCP server "${server}" startup was cancelled.`));
@@ -27205,10 +27484,11 @@ class CodexAgent {
   async setSessionConfigOptionInternal(params) {
     const runtime = this.runtime(params.sessionId, "session/set_config_option");
     assertWritable(runtime);
-    if (params.configId === MODEL_CONFIG_ID && this.providers.mode === "catalog" && typeof params.value === "string") {
+    if (params.configId === MODEL_CONFIG_ID && (this.providers.mode === "catalog" || runtime.session.model.model.startsWith("gateway:")) && typeof params.value === "string") {
+      this.providers.upstreamModel(params.value);
       const target = this.providers.gatewayIdFor(params.value);
-      const current = this.providers.hasGateway(runtime.modelProvider) ? runtime.modelProvider : null;
-      if (target !== current)
+      const destination = target ?? await this.withCodex(() => this.resolveModelProvider());
+      if (destination !== runtime.modelProvider)
         await this.rerouteSession(runtime, target, params.value);
     }
     await this.withCodex(() => applyConfigOption(runtime.session, this.codex, params));
@@ -27231,10 +27511,10 @@ class CodexAgent {
     const modelProvider = gatewayId ?? await this.withCodex(() => this.resolveModelProvider());
     await this.codex.threadUnsubscribe({ threadId: session.id });
     try {
-      await this.withCodex(() => this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: config2, modelProvider, model: modelId, excludeTurns: true }));
+      await this.withCodex(() => this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: config2, modelProvider, model: this.providers.upstreamModel(modelId), excludeTurns: true }));
     } catch (error40) {
       try {
-        await this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: runtime.config, modelProvider: runtime.modelProvider, model: session.model.model, excludeTurns: true });
+        await this.codex.threadResume({ threadId: session.id, cwd: session.cwd, config: runtime.config, modelProvider: runtime.modelProvider, model: this.providers.upstreamModel(session.model.model), excludeTurns: true });
       } catch (rollbackError) {
         runtime.stale = true;
         logger.error("Provider rollback failed", rollbackError, { sessionId: session.id });
@@ -27253,9 +27533,9 @@ class CodexAgent {
     return runtime;
   }
   async prompt(params) {
-    return await this.promptInternal(params);
+    return await this.promptInternal(params, false, crypto.randomUUID());
   }
-  async promptInternal(params, allowReentry = false) {
+  async promptInternal(params, allowReentry, messageId) {
     this.assertRoutingAvailable();
     if (!allowReentry && this.sessionMutations.has(params.sessionId))
       throw RequestError.invalidRequest({ sessionId: params.sessionId }, "Session lifecycle or configuration work is in progress; retry when it finishes");
@@ -27267,31 +27547,32 @@ class CodexAgent {
       throw RequestError.invalidParams(undefined, "prompt must contain at least one content block");
     }
     const { session } = runtime;
+    this.providers.upstreamModel(session.model.model);
     const model = findModel(session.catalog, session.model.model);
     if (!modelSupportsImages(model) && params.prompt.some((block) => block.type === "image")) {
       throw RequestError.invalidParams({ model: session.model.model }, "The current model does not support image input");
     }
     if (session.activeTurn) {
-      return await this.steerActiveTurn(runtime, session.activeTurn, params);
+      return await this.steerActiveTurn(runtime, session.activeTurn, params, messageId);
     }
-    const turn = createActiveTurn(session.id);
+    const turn = createActiveTurn(session.id, messageId);
     session.activeTurn = turn;
     runtime.client.reportRunning();
     this.runPrompt(runtime, turn, params);
-    return {};
+    return { messageId };
   }
-  async steerActiveTurn(runtime, turn, params) {
+  async steerActiveTurn(runtime, turn, params, messageId) {
     const turnId = turn.turnId ?? await turn.started;
     if (turnId === null || turn.threadId !== runtime.session.id) {
       throw RequestError.invalidRequest({ sessionId: params.sessionId }, "A turn is already running; wait for it to finish or cancel it");
     }
     try {
-      await this.codex.turnSteer({ threadId: runtime.session.id, expectedTurnId: turnId, input: toUserInput(params.prompt) });
-      return { _meta: { codex: { steered: turnId } } };
+      await this.codex.turnSteer({ threadId: runtime.session.id, expectedTurnId: turnId, clientUserMessageId: messageId, input: toUserInput(params.prompt) });
+      return { messageId, _meta: { codex: { steered: turnId } } };
     } catch (error40) {
       if (this.completedTurns.get(turn) === turnId || runtime.session.activeTurn !== turn) {
         await turn.finished;
-        return await this.promptInternal(params, true);
+        return await this.promptInternal(params, true, messageId);
       }
       throw RequestError.invalidRequest({ sessionId: params.sessionId, turnId }, `Could not steer the running turn: ${errorMessage(error40)}`);
     }
@@ -27396,11 +27677,12 @@ class CodexAgent {
         startSent = true;
         const completed = this.withCodex(() => this.codex.runTurn({
           threadId: session.id,
+          clientUserMessageId: turn.clientUserMessageId,
           input: toUserInput(prompt),
           approvalPolicy: session.mode.approvalPolicy,
           approvalsReviewer: session.mode.approvalsReviewer,
           sandboxPolicy: withWritableRoots(session.mode.sandboxPolicy, session.additionalDirectories),
-          model: session.model.model,
+          model: this.providers.upstreamModel(session.model.model),
           effort: session.model.effort,
           summary: disableSummary ? "none" : "auto",
           serviceTier: session.fastMode ? FAST_SERVICE_TIER : null
@@ -27753,16 +28035,33 @@ function readOnlyThread(thread, cwd) {
     model: thread.model ?? "",
     modelProvider: thread.modelProvider,
     serviceTier: null,
+    disabledPluginIds: [],
     cwd,
+    runtimeWorkspaceRoots: [],
     instructionSources: [],
     approvalPolicy: "on-request",
     approvalsReviewer: "user",
     sandbox: { type: "readOnly", networkAccess: false },
+    activePermissionProfile: null,
     reasoningEffort: thread.reasoningEffort,
+    collaborationMode: null,
+    multiAgentMode: "explicitRequestOnly",
+    initialTurnsPage: null,
     turnsBackwardsCursor: null,
     itemsBackwardsCursor: null
   };
 }
+function hostSessionOptions(meta) {
+  const instructions = meta?.alwith?.appendSystemPrompt;
+  if (instructions !== undefined && typeof instructions !== "string") {
+    throw RequestError.invalidParams(undefined, "appendSystemPrompt must be a string");
+  }
+  const modeId = meta?.codex?.mode;
+  const mode = typeof modeId === "string" ? findAgentMode(modeId) : undefined;
+  if (modeId !== undefined && !mode)
+    throw RequestError.invalidParams(undefined, "Unknown Codex session mode");
+  return { instructions, mode };
+}
 function requestedModelOf(meta) {
   const raw = meta?.alwith?.model;
   return typeof raw === "string" && raw.length > 0 ? raw : null;
@@ -27823,12 +28122,14 @@ var FileChangeApprovalRequest = new import_node.RequestType("item/fileChange/req
 var PermissionsApprovalRequest = new import_node.RequestType("item/permissions/requestApproval");
 var McpServerElicitationRequest = new import_node.RequestType("mcpServer/elicitation/request");
 var ToolRequestUserInputRequest = new import_node.RequestType("item/tool/requestUserInput");
+var DynamicToolCallRequest = new import_node.RequestType("item/tool/call");
 
 class AppServerClient {
   connection;
   threadHandlers = new Map;
   approvalHandlers = new Map;
   elicitationHandlers = new Map;
+  dynamicToolHandlers = new Map;
   turnCompletionWaiters = new Map;
   earlyTurnCompletions = new Map;
   startingThreads = new Map;
@@ -27841,6 +28142,10 @@ class AppServerClient {
   disconnected = new AbortController;
   constructor(connection) {
     this.connection = connection;
+    connection.onRequest(DynamicToolCallRequest, async (params) => {
+      const handler = this.dynamicToolHandlers.get(params.threadId);
+      return handler ? await handler(params) : { success: false, contentItems: [{ type: "inputText", text: "Client tools are unavailable for this thread" }] };
+    });
     connection.onClose(() => this.disconnected.abort(new Error("Connection to Codex was lost")));
     connection.onDispose(() => this.disconnected.abort(new Error("Connection to Codex was lost")));
     connection.onUnhandledNotification((message) => {
@@ -27874,11 +28179,14 @@ class AppServerClient {
     this.threadHandlers.set(threadId, handlers.notification);
     this.approvalHandlers.set(threadId, handlers.approval);
     this.elicitationHandlers.set(threadId, handlers.elicitation);
+    if (handlers.tool)
+      this.dynamicToolHandlers.set(threadId, handlers.tool);
   }
   detachThread(threadId) {
     this.threadHandlers.delete(threadId);
     this.approvalHandlers.delete(threadId);
     this.elicitationHandlers.delete(threadId);
+    this.dynamicToolHandlers.delete(threadId);
     for (const key of this.mcpStartupStates.keys()) {
       if (key.startsWith(`${threadId}\x00`))
         this.mcpStartupStates.delete(key);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {
@@ -37,7 +37,7 @@
     "package:win-x64": "cd dist/bin && zip codex-acp-v2-x64-windows.zip codex-acp-v2-x64-windows.exe",
     "package:win-arm64": "cd dist/bin && zip codex-acp-v2-arm64-windows.zip codex-acp-v2-arm64-windows.exe",
     "start": "bun src/index.ts",
-    "generate-types": "codex app-server generate-ts --out src/app-server",
+    "generate-types": "codex app-server generate-ts --experimental --out src/app-server",
     "test": "vitest run --exclude src/__tests__/e2e.test.ts",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
@@ -69,12 +69,12 @@
     "vitest": "^4.1.11"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^1.4.0",
+    "@agentclientprotocol/sdk": "^1.5.1",
     "diff": "^9.0.0",
     "open": "^11.0.2",
     "vscode-jsonrpc": "^9.0.2"
   },
   "optionalDependencies": {
-    "@openai/codex": "^0.153.0"
+    "@openai/codex": "^0.158.0"
   }
 }