@nyssance/codex-acp-v2 0.5.0 → 0.7.0

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.5.0",
+  version: "0.7.0",
   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,7 +21910,7 @@ 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"
@@ -21797,43 +21920,182 @@ var package_default = {
   }
 };
 
+// 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 "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");
   }
 }
 
@@ -23344,7 +23606,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 ? [{
@@ -23701,7 +23963,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":
@@ -23982,7 +24244,7 @@ function modelLacksReasoning(model) {
   const options = supportedEfforts(model);
   return options.length > 0 && options.every((option) => option.reasoningEffort === "none");
 }
-function modelConfigOption(catalog, current, gatewayGroup = null) {
+function modelConfigOption(catalog, current, gatewayGroups = []) {
   const visible = catalog.filter((model) => !model.hidden || model.id === current);
   const options = visible.map((model) => ({
     value: model.id,
@@ -24000,16 +24262,18 @@ function modelConfigOption(catalog, current, gatewayGroup = null) {
     type: "select",
     currentValue: current
   };
-  if (gatewayGroup === null)
+  if (gatewayGroups.length === 0)
     return { ...base, options };
-  const gatewayIds = new Set(gatewayGroup.modelIds);
-  const native = options.filter((option) => !gatewayIds.has(option.value));
-  const gateway = options.filter((option) => gatewayIds.has(option.value));
+  const owner = new Map;
+  for (const group of gatewayGroups)
+    for (const id of group.modelIds)
+      owner.set(id, group.id);
+  const native = options.filter((option) => !owner.has(option.value));
   return {
     ...base,
     options: [
       { groupId: "codex", name: "Codex", options: native },
-      { groupId: "custom-gateway", name: gatewayGroup.name, options: gateway }
+      ...gatewayGroups.map((group) => ({ groupId: group.id, name: group.name, options: options.filter((option) => owner.get(option.value) === group.id) }))
     ]
   };
 }
@@ -24900,29 +25164,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";
@@ -25740,6 +25981,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();
@@ -25966,7 +26210,7 @@ function sessionConfigOptions(session) {
   const model = findModel(session.catalog, session.model.model);
   const options = [
     modeConfigOption(session.mode),
-    modelConfigOption(session.catalog, session.model.model, session.gatewayGroup),
+    modelConfigOption(session.catalog, session.model.model, session.gatewayGroups),
     effortConfigOption(supportedEfforts(model), session.model.effort),
     collaborationModeConfigOption(session.collaborationMode)
   ];
@@ -26019,7 +26263,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;
@@ -26074,31 +26318,44 @@ import path6 from "path";
 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;
   configuredProvider;
-  gateway = null;
+  gateways = new Map;
   constructor(baseConfig, configuredProvider) {
     this.baseConfig = baseConfig;
     this.configuredProvider = configuredProvider;
   }
   copy() {
     const copy = new ProviderRouting(this.baseConfig, this.configuredProvider);
-    copy.gateway = this.gateway;
+    copy.gateways = new Map(this.gateways);
     return copy;
   }
   get active() {
-    return this.gateway;
+    return this.gateways.values().next().value ?? null;
+  }
+  gateway(id) {
+    return id === null ? null : this.gateways.get(id) ?? null;
+  }
+  hasGateway(id) {
+    return id !== null && this.gateways.has(id);
   }
   list() {
-    const routed = this.gateway !== null && this.gateway.mode === "route";
+    const first = this.active;
+    const routed = first !== null && first.mode === "route";
+    const summary = (gateway) => ({ id: gateway.id, name: gateway.name, baseUrl: gateway.baseUrl, models: gateway.models.map((model) => model.id) });
     return {
       providers: [{
         providerId: OPENAI_PROVIDER_ID,
         supported: ["openai"],
         required: false,
-        current: routed && this.gateway ? { apiType: "openai", baseUrl: this.gateway.baseUrl } : { apiType: "openai", baseUrl: this.nativeBaseUrl() },
-        ...this.gateway && !routed ? { _meta: { codex: { mode: "catalog", gateway: { name: this.gateway.name, baseUrl: this.gateway.baseUrl, models: this.gateway.models.map((model) => model.id) } } } } : {}
+        current: routed && first ? { apiType: "openai", baseUrl: first.baseUrl } : { apiType: "openai", baseUrl: this.nativeBaseUrl() },
+        ...first && !routed ? { _meta: { codex: { mode: "catalog", gateway: summary(first), gateways: [...this.gateways.values()].map(summary) } } } : {}
       }]
     };
   }
@@ -26114,7 +26371,13 @@ class ProviderRouting {
       throw RequestError.invalidParams({ baseUrl: request.baseUrl }, "baseUrl must be an http(s) URL");
     }
     const hints = readHints(request._meta);
-    this.gateway = {
+    if (hints.id === OPENAI_PROVIDER_ID || hints.id === this.configuredProvider) {
+      throw RequestError.invalidParams({ id: hints.id }, `_meta.codex.id "${hints.id}" is Codex's own provider; pick another gateway id`);
+    }
+    if (hints.mode === "route" || this.mode !== hints.mode)
+      this.gateways.clear();
+    this.gateways.set(hints.id, {
+      id: hints.id,
       baseUrl,
       headers: { ...request.headers ?? {} },
       name: hints.name ?? "Client-configured gateway",
@@ -26124,41 +26387,77 @@ class ProviderRouting {
       config: hints.config,
       mode: hints.mode,
       catalogEntries: hints.catalogEntries
-    };
+    });
   }
   get mode() {
-    return this.gateway?.mode ?? "route";
+    return this.active?.mode ?? "route";
+  }
+  gatewayFor(modelId) {
+    for (const gateway of this.gateways.values()) {
+      if (gateway.models.some((model) => (this.mode === "catalog" ? gatewayModelId(gateway.id, model.id) : model.id) === modelId))
+        return gateway;
+    }
+    return null;
+  }
+  gatewayIdFor(modelId) {
+    return this.gatewayFor(modelId)?.id ?? null;
   }
   isGatewayModel(modelId) {
-    return this.gateway !== null && this.gateway.models.some((model) => model.id === modelId);
+    return this.gatewayFor(modelId) !== null;
   }
-  gatewayGroup() {
-    if (!this.gateway || this.gateway.mode !== "catalog" || this.gateway.models.length === 0)
-      return null;
-    return { name: this.gateway.name, modelIds: this.gateway.models.map((model) => model.id) };
+  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) => 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)
-      this.gateway = null;
+    if (request.providerId !== OPENAI_PROVIDER_ID)
+      return;
+    const id = readGatewayId(request._meta);
+    if (id === null)
+      this.gateways.clear();
+    else
+      this.gateways.delete(id);
   }
   modelProvider() {
-    return this.gateway && this.gateway.mode === "route" ? GATEWAY_MODEL_PROVIDER : this.configuredProvider;
+    return this.defaultGatewayId() ?? this.configuredProvider;
   }
   routesByDefault() {
-    return this.gateway !== null && this.gateway.mode === "route";
+    return this.defaultGatewayId() !== null;
+  }
+  defaultGatewayId() {
+    const first = this.active;
+    return first !== null && first.mode === "route" ? first.id : null;
   }
-  threadConfig(onGateway = this.routesByDefault()) {
-    if (!this.gateway || !onGateway)
+  threadConfig(gatewayId = this.defaultGatewayId()) {
+    const gateway = this.gateway(gatewayId);
+    if (!gateway)
       return this.baseConfig;
-    return this.applyGateway(this.baseConfig, this.gateway);
+    return this.applyGateway(this.baseConfig, gateway);
   }
-  routeConfig(config2, onGateway) {
-    return this.rebind(config2, this, onGateway);
+  routeConfig(config2, gatewayId) {
+    return this.rebind(config2, this, gatewayId);
   }
   overrideKeys() {
-    return this.gateway ? Object.keys(this.gateway.config) : [];
+    const keys = new Set;
+    for (const gateway of this.gateways.values())
+      for (const key of Object.keys(gateway.config))
+        keys.add(key);
+    return [...keys];
   }
-  rebind(config2, previous, onGateway = this.routesByDefault()) {
+  rebind(config2, previous, gatewayId = this.defaultGatewayId()) {
     const next = { ...config2 };
     for (const key of previous.overrideKeys()) {
       if (key in this.baseConfig)
@@ -26166,13 +26465,11 @@ class ProviderRouting {
       else
         delete next[key];
     }
-    if (!this.gateway || !onGateway) {
-      delete next["model_providers"];
-      if (isRecord2(this.baseConfig["model_providers"]))
-        next["model_providers"] = this.baseConfig["model_providers"];
-      return next;
-    }
-    return this.applyGateway(next, this.gateway);
+    delete next["model_providers"];
+    if (isRecord2(this.baseConfig["model_providers"]))
+      next["model_providers"] = this.baseConfig["model_providers"];
+    const gateway = this.gateway(gatewayId);
+    return gateway ? this.applyGateway(next, gateway) : next;
   }
   applyGateway(config2, gateway) {
     const existing = isRecord2(config2["model_providers"]) ? config2["model_providers"] : {};
@@ -26187,15 +26484,24 @@ class ProviderRouting {
     return {
       ...config2,
       ...gateway.config,
-      model_providers: { ...existing, [GATEWAY_MODEL_PROVIDER]: entry }
+      model_providers: { ...existing, [gateway.id]: entry }
     };
   }
   catalog(codexCatalog) {
-    if (!this.gateway || this.gateway.models.length === 0)
+    const first = this.active;
+    if (first === null)
       return codexCatalog;
-    const gateway = this.gateway;
-    const own = gateway.models.map((model, index) => gatewayModel(model, gateway.mode === "route" && index === 0, codexCatalog[0], gateway.catalogEntries.get(model.id)));
-    return gateway.mode === "catalog" ? [...codexCatalog, ...own] : own;
+    if (first.mode === "route") {
+      if (first.models.length === 0)
+        return codexCatalog;
+      return first.models.map((model, index) => gatewayModel(model, index === 0, codexCatalog[0], first.catalogEntries.get(model.id)));
+    }
+    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)), id: gatewayModelId(gateway.id, model.id) });
+    }
+    return [...codexCatalog, ...own];
   }
   nativeBaseUrl() {
     const providers = this.baseConfig["model_providers"];
@@ -26212,6 +26518,7 @@ function readHints(meta) {
   const root = isRecord2(meta) ? meta : {};
   const alwith = isRecord2(root["alwith"]) ? root["alwith"] : {};
   const codex = isRecord2(root["codex"]) ? root["codex"] : {};
+  const id = readGatewayId(meta) ?? GATEWAY_MODEL_PROVIDER;
   const models = [];
   if (Array.isArray(alwith["models"])) {
     for (const entry of alwith["models"]) {
@@ -26249,7 +26556,18 @@ function readHints(meta) {
   }
   const catalogPath = config2["model_catalog_json"];
   const catalogEntries = typeof catalogPath === "string" ? readCatalogFile(catalogPath) : new Map;
-  return { models, model, name, bearerToken, config: config2, mode, catalogEntries };
+  return { id, models, model, name, bearerToken, config: config2, mode, catalogEntries };
+}
+function readGatewayId(meta) {
+  const root = isRecord2(meta) ? meta : {};
+  const codex = isRecord2(root["codex"]) ? root["codex"] : {};
+  const raw = codex["id"];
+  if (raw === undefined)
+    return null;
+  if (typeof raw !== "string" || !GATEWAY_ID_PATTERN.test(raw)) {
+    throw RequestError.invalidParams({ id: raw }, "_meta.codex.id must match [a-z0-9-]+");
+  }
+  return raw;
 }
 function readCatalogFile(catalogPath) {
   const resolved = catalogPath.startsWith("~/") ? path6.join(os2.homedir(), catalogPath.slice(2)) : catalogPath;
@@ -26310,7 +26628,7 @@ function gatewayModel(model, isDefault, template, entry) {
 }
 
 // src/agent/session.ts
-function createActiveTurn(threadId) {
+function createActiveTurn(threadId, clientUserMessageId = null) {
   let resolveStarted = () => {};
   let resolveFinished = () => {};
   let started = new Promise((resolve) => {
@@ -26324,6 +26642,7 @@ function createActiveTurn(threadId) {
   return {
     turnId: null,
     threadId,
+    clientUserMessageId,
     abort: new AbortController,
     stop: new AbortController,
     interrupts: new Map,
@@ -26406,6 +26725,12 @@ class CodexAgent {
       }
       if (notification.method === "account/updated")
         this.refreshAccounts().catch((error40) => logger.error("refreshing account failed", error40));
+      if (notification.method === "account/rateLimits/updated")
+        this.forward("_codex/rate_limits_updated", notification.params);
+      if (notification.method === "fuzzyFileSearch/sessionUpdated")
+        this.forward("_codex/fuzzy_file_search_updated", notification.params);
+      if (notification.method === "fuzzyFileSearch/sessionCompleted")
+        this.forward("_codex/fuzzy_file_search_completed", notification.params);
     });
     this.codex.disconnectSignal.addEventListener("abort", stopObserving, { once: true });
   }
@@ -26442,7 +26767,7 @@ class CodexAgent {
           additionalDirectories: {}
         },
         providers: {},
-        _meta: { codex: { archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: 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)
     };
@@ -26529,8 +26854,15 @@ 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 || runtime.modelProvider === GATEWAY_MODEL_PROVIDER);
-        const targets = new Map(moving.map((runtime) => [runtime, candidate.active !== null && (candidate.mode === "route" || runtime.modelProvider === GATEWAY_MODEL_PROVIDER)]));
+        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];
+          if (candidate.mode === "route")
+            return [runtime, candidate.defaultGatewayId()];
+          return [runtime, candidate.hasGateway(runtime.modelProvider) ? runtime.modelProvider : null];
+        }));
         for (const runtime of moving) {
           try {
             await this.codex.threadTurnsList({ threadId: runtime.session.id, limit: 1, itemsView: "notLoaded" });
@@ -26543,10 +26875,10 @@ class CodexAgent {
         }
         const nextCatalog = candidate.catalog(catalog);
         for (const runtime of moving) {
-          const onGateway = targets.get(runtime) === true;
-          const config2 = candidate.rebind(runtime.config, this.providers, onGateway);
-          const modelProvider = onGateway ? GATEWAY_MODEL_PROVIDER : nativeProvider;
-          const keep = findModel(nextCatalog, runtime.session.model.model) && candidate.isGatewayModel(runtime.session.model.model) === onGateway;
+          const target = targets.get(runtime) ?? null;
+          const config2 = candidate.rebind(runtime.config, this.providers, target);
+          const modelProvider = target ?? nativeProvider;
+          const keep = findModel(nextCatalog, runtime.session.model.model) && candidate.gatewayIdFor(runtime.session.model.model) === target;
           const requestedModel = candidate.mode === "route" ? candidate.active?.model ?? (keep ? runtime.session.model.model : null) : keep ? runtime.session.model.model : null;
           const selection = resolveModelSelection(nextCatalog, requestedModel, requestedModel === runtime.session.model.model ? runtime.session.model.effort : null);
           attempted.push(runtime);
@@ -26556,23 +26888,25 @@ 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);
           if (next) {
             runtime.config = next.config;
-            runtime.modelProvider = targets.get(runtime) === true ? GATEWAY_MODEL_PROVIDER : nativeProvider;
+            runtime.modelProvider = targets.get(runtime) ?? nativeProvider;
             runtime.session.model = next.model;
             runtime.stale = false;
           }
           runtime.session.catalog = nextCatalog;
-          runtime.session.gatewayGroup = candidate.gatewayGroup();
-          if (!next)
+          runtime.session.gatewayGroups = candidate.gatewayGroups();
+          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));
         }
@@ -26588,7 +26922,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) {
@@ -26662,36 +26996,51 @@ 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 onGateway = this.providers.routesByDefault();
+    let gatewayId = this.providers.defaultGatewayId();
     if (this.providers.active !== null && this.providers.mode === "catalog") {
       if (requestedModel !== null)
-        onGateway = this.providers.isGatewayModel(requestedModel);
+        gatewayId = this.providers.gatewayIdFor(requestedModel);
       else if (open2.kind === "resume") {
         const known = await this.withCodex(() => this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false }));
-        onGateway = known.thread.modelProvider === GATEWAY_MODEL_PROVIDER;
+        gatewayId = this.providers.hasGateway(known.thread.modelProvider) ? known.thread.modelProvider : null;
       }
     }
+    const onGateway = gatewayId !== null;
     let accountVersion = this.accountGeneration;
     const account = await this.withCodex(() => this.codex.accountRead({ refreshToken: false }));
     if (!onGateway && account.requiresOpenaiAuth && account.account === null) {
       throw RequestError.authRequired(undefined, "Log in to Codex first (auth/login)");
     }
     const existingMcp = mcpServers.length > 0 ? await this.withCodex(() => this.configuredMcpServerNames(request.cwd)) : new Set;
-    const config2 = buildThreadConfig(this.providers.threadConfig(onGateway), request.cwd, additionalDirectories, mcpServers, existingMcp);
+    const config2 = buildThreadConfig(this.providers.threadConfig(gatewayId), request.cwd, additionalDirectories, mcpServers, existingMcp);
     const mcpStartupGeneration = this.codex.mcpStartupGeneration;
-    const modelProvider = onGateway ? GATEWAY_MODEL_PROVIDER : await this.withCodex(() => this.resolveModelProvider());
-    const startModel = onGateway ? requestedModel ?? this.providers.active?.model ?? null : requestedModel;
+    const modelProvider = gatewayId ?? await this.withCodex(() => this.resolveModelProvider());
+    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;
@@ -26699,7 +27048,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;
@@ -26728,16 +27077,17 @@ 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,
         mcpServerNames: mcpServerNames(mcpServers).filter((name) => !existingMcp.has(name)),
         catalog,
-        gatewayGroup: this.providers.gatewayGroup(),
+        gatewayGroups: this.providers.gatewayGroups(),
         model,
-        mode: initialAgentMode(this.env),
+        mode,
         collaborationMode: DEFAULT_COLLABORATION_MODE,
         fastMode: thread.serviceTier === FAST_SERVICE_TIER,
         account: openedAccount,
@@ -26748,7 +27098,7 @@ class CodexAgent {
         contextWindow: null,
         closed: false
       };
-      const runtime = this.installRuntime(session, capabilities, config2, onGateway ? GATEWAY_MODEL_PROVIDER : thread.modelProvider, readOnly);
+      const runtime = this.installRuntime(session, capabilities, config2, gatewayId ?? thread.modelProvider, readOnly);
       const cancelOpening = () => {
         runtime.session.closed = true;
         runtime.lifetime.abort();
@@ -26806,11 +27156,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)),
@@ -26914,8 +27266,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.`));
@@ -27046,6 +27398,27 @@ class CodexAgent {
   notifySkillsChanged() {
     this.link.notify("_codex/skills_changed", {}).catch((error40) => logger.error("skills change notification failed", error40));
   }
+  forward(method, params) {
+    this.link.notify(method, params).catch((error40) => logger.error(`${method} notification failed`, error40));
+  }
+  async sessionRename(params) {
+    this.requireInitialized("_codex/session_rename");
+    await this.withCodex(() => this.codex.threadSetName({ threadId: params.sessionId, name: params.name }));
+    return {};
+  }
+  async accountRead() {
+    this.requireInitialized("_codex/account_read");
+    return await this.withCodex(() => this.codex.accountRead({ refreshToken: false }));
+  }
+  async rateLimits() {
+    this.requireInitialized("_codex/rate_limits");
+    return await this.withCodex(() => this.codex.accountRateLimitsRead());
+  }
+  async fuzzyFileSearch(params) {
+    this.requireInitialized("_codex/fuzzy_file_search");
+    const request = { query: params.query, roots: params.roots, cancellationToken: params.cancellationToken };
+    return await this.withCodex(() => this.codex.fuzzyFileSearch(request));
+  }
   async closeRuntime(sessionId) {
     const deadline = performance.now() + this.closeGraceMs;
     const runtime = this.sessions.get(sessionId);
@@ -27102,17 +27475,19 @@ 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") {
-      const toGateway = this.providers.isGatewayModel(params.value);
-      if (toGateway !== (runtime.modelProvider === GATEWAY_MODEL_PROVIDER))
-        await this.rerouteSession(runtime, toGateway, params.value);
+    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 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));
     const configOptions = sessionConfigOptions(runtime.session);
     await runtime.client.update({ sessionUpdate: "config_option_update", configOptions });
     return { configOptions };
   }
-  async rerouteSession(runtime, toGateway, modelId) {
+  async rerouteSession(runtime, gatewayId, modelId) {
     const { session } = runtime;
     this.assertRoutingAvailable();
     if (session.activeTurn !== null) {
@@ -27123,19 +27498,19 @@ class CodexAgent {
     } catch {
       await this.withCodex(() => this.codex.threadInjectItems({ threadId: session.id, items: [providerChangeNote()] }));
     }
-    const config2 = this.providers.routeConfig(runtime.config, toGateway);
-    const modelProvider = toGateway ? GATEWAY_MODEL_PROVIDER : await this.withCodex(() => this.resolveModelProvider());
+    const config2 = this.providers.routeConfig(runtime.config, gatewayId);
+    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 });
       }
-      throw RequestError.internalError({ sessionId: session.id, stale: runtime.stale }, `Could not move the session to ${toGateway ? "the gateway" : "Codex's provider"}: ${errorMessage(error40)}`);
+      throw RequestError.internalError({ sessionId: session.id, stale: runtime.stale }, `Could not move the session to ${gatewayId !== null ? `gateway "${gatewayId}"` : "Codex's provider"}: ${errorMessage(error40)}`);
     }
     runtime.config = config2;
     runtime.modelProvider = modelProvider;
@@ -27149,9 +27524,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");
@@ -27163,31 +27538,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)}`);
     }
@@ -27292,11 +27668,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
@@ -27592,6 +27969,28 @@ function interruptedTurn(threadId) {
     turn: { id: "", items: [], itemsView: "notLoaded", status: "interrupted", error: null, startedAt: null, completedAt: null, durationMs: null }
   };
 }
+function parseSessionRenameParams(raw) {
+  const params = objectParams()(raw);
+  if (typeof params.sessionId !== "string" || params.sessionId.length === 0) {
+    throw RequestError.invalidParams({ sessionId: params.sessionId }, "sessionId must be a non-empty string");
+  }
+  if (typeof params.name !== "string")
+    throw RequestError.invalidParams({ name: params.name }, "name must be a string");
+  return { sessionId: params.sessionId, name: params.name };
+}
+function parseFuzzyFileSearchParams(raw) {
+  const params = objectParams()(raw);
+  if (typeof params.query !== "string")
+    throw RequestError.invalidParams({ query: params.query }, "query must be a string");
+  if (!Array.isArray(params.roots) || !params.roots.every((root) => typeof root === "string")) {
+    throw RequestError.invalidParams({ roots: params.roots }, "roots must be an array of directory paths");
+  }
+  const token = params.cancellationToken;
+  if (token !== undefined && token !== null && typeof token !== "string") {
+    throw RequestError.invalidParams({ cancellationToken: token }, "cancellationToken must be a string when given");
+  }
+  return { query: params.query, roots: params.roots, cancellationToken: typeof token === "string" ? token : null };
+}
 function objectParams() {
   return (raw) => {
     if (raw === undefined || raw === null)
@@ -27637,6 +28036,17 @@ function readOnlyThread(thread, cwd) {
     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;
@@ -27687,7 +28097,7 @@ function createAgentApp(options) {
   };
   return agent({ name: options.info.name }).onConnect((connection) => {
     agent2 = new CodexAgent(connection.client, options);
-  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
+  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest("_codex/session_rename", { parse: parseSessionRenameParams }, (ctx) => current().sessionRename(ctx.params)).onRequest("_codex/account_read", { parse: objectParams() }, () => current().accountRead()).onRequest("_codex/rate_limits", { parse: objectParams() }, () => current().rateLimits()).onRequest("_codex/fuzzy_file_search", { parse: parseFuzzyFileSearchParams }, (ctx) => current().fuzzyFileSearch(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
 }
 
 // src/codex/AppServerClient.ts
@@ -27697,12 +28107,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;
@@ -27715,6 +28127,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) => {
@@ -27748,11 +28164,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);
@@ -28100,6 +28519,15 @@ class AppServerClient {
   accountRead(params) {
     return this.send({ method: "account/read", params });
   }
+  accountRateLimitsRead() {
+    return this.send({ method: "account/rateLimits/read", params: undefined });
+  }
+  threadSetName(params) {
+    return this.send({ method: "thread/name/set", params });
+  }
+  fuzzyFileSearch(params) {
+    return this.send({ method: "fuzzyFileSearch", params });
+  }
   accountLogin(params) {
     return this.send({ method: "account/login/start", params });
   }