@agentknight/sdk 0.9.42 → 0.9.43

package/dist/chunks/codex-adapter-VQTLTFNP.js

@@ -0,0 +1,1249 @@
+import {
+  latestPreviewItems
+} from "./chunk-DB3EAMYS.js";
+import {
+  UnsupportedAgentOperationError
+} from "./chunk-ULM5KUJ7.js";
+import {
+  ConversationItemSchema,
+  InteractionRequestSchema,
+  SESSION_TIMELINE_PAGE_SIZE,
+  SessionSummarySchema
+} from "./chunk-7QOBDG6R.js";
+
+// src/codex-adapter.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join2, resolve } from "node:path";
+import { z as z4 } from "zod";
+
+// src/adapters/codex/rpc.ts
+import { spawn } from "node:child_process";
+import { z as z2 } from "zod";
+
+// src/adapters/codex/executable.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, win32 } from "node:path";
+import { z } from "zod";
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) return false;
+    throw new Error("Cannot inspect the configured Codex installation", { cause: error });
+  }
+}
+var Package = z.object({
+  name: z.literal("@openai/codex"),
+  bin: z.object({ codex: z.literal("bin/codex.js") })
+});
+var unsupportedShim = () => new Error(
+  "Codex was found as a Windows script shim, but its installed native executable could not be resolved. Set AGENTKNIGHT_CODEX_COMMAND to the full path of codex.exe. Script wrappers are not executed through a shell."
+);
+function nativeFromNpmShim(shim, architecture) {
+  const filename = win32.basename(shim).toLowerCase();
+  if (!["codex", "codex.cmd", "codex.bat", "codex.ps1"].includes(filename)) throw unsupportedShim();
+  const triple = architecture === "x64" ? "x86_64-pc-windows-msvc" : architecture === "arm64" ? "aarch64-pc-windows-msvc" : void 0;
+  if (!triple) throw unsupportedShim();
+  const shimDirectory = dirname(shim);
+  const roots = [
+    join(shimDirectory, "node_modules", "@openai", "codex"),
+    ...win32.basename(shimDirectory).toLowerCase() === ".bin" ? [join(shimDirectory, "..", "@openai", "codex")] : []
+  ];
+  for (const root of roots) {
+    const manifest = join(root, "package.json");
+    if (!isFile(manifest)) continue;
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(manifest, "utf8"));
+    } catch {
+      throw unsupportedShim();
+    }
+    if (!Package.safeParse(raw).success) throw unsupportedShim();
+    const packageRoot = realpathSync(root);
+    const vendorRoots = [join(packageRoot, "vendor")];
+    try {
+      const require2 = createRequire(join(packageRoot, "package.json"));
+      const platformManifest = require2.resolve(`@openai/codex-win32-${architecture}/package.json`);
+      vendorRoots.unshift(join(dirname(platformManifest), "vendor"));
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND")) {
+        throw new Error("Cannot resolve the installed Codex native package", { cause: error });
+      }
+    }
+    for (const vendor of vendorRoots) {
+      const executable = join(vendor, triple, "bin", "codex.exe");
+      if (isFile(executable)) return realpathSync(executable);
+    }
+  }
+  throw unsupportedShim();
+}
+function resolveCodexExecutable(command, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") return command;
+  const environment = options.environment ?? process.env;
+  const architecture = options.architecture ?? process.arch;
+  const explicit = win32.isAbsolute(command) || command.includes("/") || command.includes("\\");
+  const pathValue = Object.entries(environment).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+  const bases = explicit ? [command] : pathValue.split(";").filter(Boolean).map((entry) => join(entry.replace(/^"(.*)"$/, "$1"), command));
+  const extensions = win32.extname(command) ? [""] : [".exe", ".com", ".cmd", ".bat", ".ps1", ""];
+  for (const base2 of bases) {
+    for (const extension of extensions) {
+      const path = `${base2}${extension}`;
+      if (!isFile(path)) continue;
+      if ([".exe", ".com"].includes(win32.extname(path).toLowerCase())) return realpathSync(path);
+      return nativeFromNpmShim(path, architecture);
+    }
+  }
+  throw new Error(
+    "Codex executable was not found. Install Codex or set AGENTKNIGHT_CODEX_COMMAND to the full path of codex.exe."
+  );
+}
+
+// src/adapters/codex/rpc.ts
+var spawnCodex = (command, args) => spawn(resolveCodexExecutable(command), [...args], { stdio: "pipe", windowsHide: true, shell: false });
+var Id = z2.union([z2.string(), z2.number().int()]);
+var Envelope = z2.object({
+  id: Id.optional(),
+  method: z2.string().optional(),
+  params: z2.unknown().optional(),
+  result: z2.unknown().optional(),
+  error: z2.object({ code: z2.number(), message: z2.string() }).optional()
+});
+var CodexRpcError = class extends Error {
+  constructor(code) {
+    super(`Codex rejected the request (RPC ${code})`);
+    this.code = code;
+  }
+  code;
+};
+var CodexRpc = class {
+  constructor(child, options) {
+    this.child = child;
+    this.options = options;
+    child.stdout.on("data", this.#data);
+    child.stdout.on("end", this.#end);
+    child.stdout.on("error", this.#streamError);
+    child.stdin.on("error", this.#streamError);
+    child.stderr.on("error", this.#streamError);
+    child.stderr.on("data", this.#stderr);
+    child.on("error", this.#streamError);
+    child.on("exit", this.#exit);
+    child.once("close", this.#processClosed);
+  }
+  child;
+  options;
+  #pending = /* @__PURE__ */ new Map();
+  #buffer = Buffer.alloc(0);
+  #sequence = 0;
+  #closed = false;
+  #exited = false;
+  #exitWaiters = /* @__PURE__ */ new Set();
+  #stderrReported = false;
+  get pendingCount() {
+    return this.#pending.size;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  waitForExit(timeoutMs) {
+    if (this.#exited) return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      const finish = () => {
+        clearTimeout(timer);
+        this.#exitWaiters.delete(finish);
+        resolve2();
+      };
+      const timer = setTimeout(() => {
+        this.#exitWaiters.delete(finish);
+        reject(new Error("Codex process termination was not confirmed"));
+      }, timeoutMs);
+      this.#exitWaiters.add(finish);
+    });
+  }
+  request(method, params) {
+    if (this.#closed) return Promise.reject(new Error("Codex transport is closed"));
+    const id = ++this.#sequence;
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => this.fail(new Error("Codex request timed out; outcome unknown")), this.options.timeoutMs);
+      this.#pending.set(id, { resolve: resolve2, reject, timer });
+      try {
+        this.#write({ id, method, params });
+      } catch {
+        this.fail(new Error("Codex request write failed; outcome unknown"));
+      }
+    });
+  }
+  notify(method, params) {
+    this.#write({ method, ...params === void 0 ? {} : { params } });
+  }
+  respond(id, result) {
+    this.#write({ id, result });
+  }
+  reject(id, code = -32601) {
+    this.#write({ id, error: { code, message: "Request unsupported or unavailable" } });
+  }
+  #write(value) {
+    if (this.#closed) throw new Error("Codex transport is closed");
+    const line = JSON.stringify(value) + "\n";
+    if (Buffer.byteLength(line) > this.options.maxFrameBytes) throw new Error("Codex outgoing frame exceeds limit");
+    this.child.stdin.write(line);
+  }
+  #data = (chunk) => {
+    if (this.#closed) return;
+    if (!Buffer.isBuffer(chunk) && typeof chunk !== "string") {
+      this.fail(new Error("Invalid Codex stream chunk"));
+      return;
+    }
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    let start = 0;
+    while (start < bytes.length && !this.#closed) {
+      const newline = bytes.indexOf(10, start);
+      const end = newline < 0 ? bytes.length : newline;
+      if (this.#buffer.length + end - start > this.options.maxFrameBytes) {
+        this.fail(new Error("Codex JSONL frame exceeds limit"));
+        return;
+      }
+      this.#buffer = Buffer.concat([this.#buffer, bytes.subarray(start, end)]);
+      if (newline < 0) return;
+      const line = this.#buffer.toString("utf8").trim();
+      this.#buffer = Buffer.alloc(0);
+      start = newline + 1;
+      if (!line) continue;
+      try {
+        const raw = JSON.parse(line);
+        const message = Envelope.parse(raw);
+        if (message.method !== void 0) {
+          this.options.onMessage(message.method, message.params, message.id);
+        } else if (message.id !== void 0) {
+          const pending = this.#pending.get(message.id);
+          if (!pending) continue;
+          if (message.error === void 0 && !Object.prototype.hasOwnProperty.call(raw, "result")) {
+            throw new Error("Missing RPC result");
+          }
+          this.#pending.delete(message.id);
+          clearTimeout(pending.timer);
+          if (message.error) pending.reject(new CodexRpcError(message.error.code));
+          else pending.resolve(message.result);
+        } else throw new Error("Invalid RPC envelope");
+      } catch {
+        this.fail(new Error("Invalid Codex JSONL protocol frame"));
+      }
+    }
+  };
+  #end = () => {
+    this.fail(new Error("Codex stdout closed; outcome unknown"));
+  };
+  #observeExit() {
+    this.#exited = true;
+    for (const finish of this.#exitWaiters) finish();
+  }
+  #exit = () => {
+    this.#observeExit();
+    this.fail(new Error("Codex process exited; outcome unknown"));
+  };
+  #processClosed = () => {
+    this.#observeExit();
+    this.fail(new Error("Codex process closed; outcome unknown"));
+    this.child.stdout.off("error", this.#streamError);
+    this.child.stdin.off("error", this.#streamError);
+    this.child.stderr.off("error", this.#streamError);
+    this.child.off("error", this.#streamError);
+    this.child.off("exit", this.#exit);
+  };
+  #streamError = () => {
+    this.fail(new Error("Codex process I/O failed; outcome unknown"));
+  };
+  #stderr = () => {
+    if (!this.#closed && !this.#stderrReported) {
+      this.#stderrReported = true;
+      this.options.onDiagnostic?.("Codex emitted stderr (content withheld)");
+    }
+  };
+  fail(error) {
+    if (this.#closed) return;
+    this.close();
+    this.options.onFailure(error);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#buffer = Buffer.alloc(0);
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Codex transport closed; outcome unknown"));
+    }
+    this.#pending.clear();
+    this.child.stdout.off("data", this.#data);
+    this.child.stdout.off("end", this.#end);
+    this.child.stderr.off("data", this.#stderr);
+    this.child.stdin.end();
+    this.child.kill();
+  }
+};
+
+// src/adapters/codex/protocol.ts
+import { z as z3 } from "zod";
+var NativeId = z3.string().min(1).max(256);
+var NativeItem = z3.object({
+  id: NativeId,
+  type: z3.string(),
+  clientId: z3.string().nullable().optional(),
+  text: z3.string().optional(),
+  content: z3.array(z3.object({ type: z3.string(), text: z3.string().optional() })).optional(),
+  command: z3.string().optional(),
+  tool: z3.string().optional(),
+  status: z3.string().optional(),
+  aggregatedOutput: z3.string().nullable().optional(),
+  changes: z3.array(z3.object({ path: z3.string(), diff: z3.string() })).optional()
+});
+var NativeTurn = z3.object({
+  id: NativeId,
+  status: z3.enum(["inProgress", "completed", "interrupted", "failed"]),
+  items: z3.array(NativeItem)
+});
+var ThreadResult = z3.object({
+  thread: z3.object({
+    id: NativeId,
+    status: z3.object({ type: z3.enum(["notLoaded", "idle", "active", "systemError"]) }),
+    turns: z3.array(NativeTurn)
+  })
+});
+var EventContext = z3.object({ threadId: NativeId, turnId: NativeId });
+var ItemEvent = EventContext.extend({ item: NativeItem });
+var DeltaEvent = EventContext.extend({ itemId: NativeId, delta: z3.string() });
+var TurnEvent = z3.object({ threadId: NativeId, turn: NativeTurn });
+var Approval = EventContext.extend({
+  itemId: NativeId,
+  reason: z3.string().nullable().optional(),
+  command: z3.string().nullable().optional()
+});
+var Questions = EventContext.extend({
+  itemId: NativeId,
+  questions: z3.array(z3.object({
+    id: NativeId,
+    question: z3.string().min(1).max(4096),
+    isOther: z3.boolean(),
+    isSecret: z3.boolean(),
+    options: z3.array(z3.object({ label: z3.string().max(1024) })).max(100).nullable()
+  })).min(1).max(20)
+});
+
+// src/adapters/codex/timeline.ts
+import { createHash } from "node:crypto";
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+var itemId = (threadId, nativeId) => `codex:${hash(`${threadId}:${nativeId}`)}`;
+function base(threadId, turnId, nativeId) {
+  return {
+    id: itemId(threadId, nativeId),
+    turnId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    revision: 1,
+    sourceEventIds: [nativeId]
+  };
+}
+function projectItem(threadId, turnId, item, completed) {
+  const common = base(threadId, turnId, item.id);
+  switch (item.type) {
+    case "userMessage":
+      return ConversationItemSchema.parse({
+        ...common,
+        kind: "human-message",
+        actor: "human",
+        content: (item.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n"),
+        attachments: [],
+        sourceMessageIds: item.clientId ? [item.id, item.clientId] : [item.id]
+      });
+    case "agentMessage":
+      return ConversationItemSchema.parse({
+        ...common,
+        kind: "assistant-message",
+        actor: "assistant",
+        content: item.text ?? "",
+        final: completed
+      });
+    case "commandExecution":
+    case "fileChange":
+    case "mcpToolCall":
+    case "dynamicToolCall":
+    case "collabAgentToolCall": {
+      const failed = item.status === "failed" || item.status === "declined";
+      const status = failed ? "failed" : completed ? "completed" : "running";
+      return ConversationItemSchema.parse({
+        ...common,
+        kind: "activity-group",
+        actor: "assistant",
+        status,
+        steps: [{
+          id: item.id,
+          kind: "tool",
+          name: (item.command ?? item.tool ?? item.type).slice(0, 256) || item.type,
+          status,
+          timestamp: common.timestamp
+        }]
+      });
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/codex-adapter.ts
+var CODEX_DEFAULT_MODEL_ID = "codex:agent-default";
+var StoredSession = z4.object({
+  summary: SessionSummarySchema,
+  modelId: z4.string(),
+  items: z4.array(ConversationItemSchema),
+  uncertain: z4.boolean()
+});
+var Inventory = z4.object({
+  version: z4.literal(1),
+  identity: z4.string(),
+  sessions: z4.array(StoredSession)
+});
+var CodexCodingAgentAdapter = class {
+  agentId = "codex";
+  sdkVersion = "app-server-v2 (rust-v0.160.0)";
+  agentModes = ["interactive"];
+  supportsReasoningEffort = false;
+  supportsFileAttachments = false;
+  supportsSessionDelete = false;
+  supportsSessionListUpdates = true;
+  supportsAssistantPreview = true;
+  groupChatEnabled = false;
+  #options;
+  #identity;
+  #directory;
+  #sessions = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Map();
+  #callbacks;
+  #rpc;
+  #opening;
+  #starting;
+  #stopping;
+  #lifecycle = 0;
+  #started = false;
+  #fatal;
+  #saveRunning;
+  #saveVersion = 0;
+  #operations = 0;
+  constructor(options) {
+    for (const limit of [options.requestTimeoutMs, options.interactionTimeoutMs, options.maxFrameBytes]) {
+      if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1)) throw new RangeError("Codex limits must be positive integers");
+    }
+    const command = options.command ?? "codex";
+    if (!command.trim() || command.includes("\0")) throw new Error("Invalid Codex executable");
+    this.#options = { ...options, command, args: [...options.args ?? ["app-server"]] };
+    this.#identity = hash(JSON.stringify([options.ownerId ?? "host", command, this.#options.args]));
+    this.#directory = join2(resolve(options.dataDirectory), "codex", this.#identity);
+  }
+  async start() {
+    if (this.#started) return;
+    if (this.#starting) return this.#starting;
+    if (this.#stopping) throw new Error("Codex adapter is stopping");
+    if (this.#fatal) throw new Error("Create a new Codex adapter after a transport failure");
+    const work = this.#start(++this.#lifecycle);
+    this.#starting = work;
+    try {
+      await work;
+    } finally {
+      this.#starting = void 0;
+    }
+  }
+  async #start(generation) {
+    await mkdir(this.#directory, { recursive: true, mode: 448 });
+    let stored;
+    try {
+      stored = JSON.parse(await readFile(join2(this.#directory, "inventory.json"), "utf8"));
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+    }
+    if (generation !== this.#lifecycle) throw new Error("Codex startup cancelled");
+    if (stored !== void 0) {
+      const inventory = Inventory.parse(stored);
+      if (inventory.identity !== this.#identity) throw new Error("Codex inventory owner mismatch");
+      const restored = /* @__PURE__ */ new Map();
+      for (const data of inventory.sessions) {
+        if (restored.has(data.summary.sessionId)) throw new Error("Duplicate Codex owned thread");
+        restored.set(data.summary.sessionId, this.#runtime(data));
+      }
+      for (const [id, session] of restored) this.#sessions.set(id, session);
+    }
+    this.#started = true;
+  }
+  #runtime(data) {
+    return {
+      ...data,
+      loaded: false,
+      active: void 0,
+      sending: false,
+      aborting: false,
+      queue: [],
+      epoch: 0,
+      lock: Promise.resolve(),
+      completed: /* @__PURE__ */ new Set(),
+      settled: /* @__PURE__ */ new Set(),
+      pumpScheduled: false
+    };
+  }
+  async stop() {
+    if (this.#stopping) return this.#stopping;
+    const work = this.#stop();
+    this.#stopping = work;
+    try {
+      await work;
+    } finally {
+      this.#stopping = void 0;
+    }
+  }
+  async #stop() {
+    this.#lifecycle++;
+    if (!this.#started && !this.#rpc) {
+      if (this.#starting) await Promise.allSettled([this.#starting]);
+      return;
+    }
+    this.#started = false;
+    for (const session of this.#sessions.values()) {
+      session.epoch++;
+      session.queue = [];
+      if (session.active || session.sending) session.uncertain = true;
+    }
+    this.#dismiss();
+    const rpc = this.#rpc;
+    rpc?.close();
+    await Promise.allSettled([
+      ...this.#opening ? [this.#opening] : [],
+      ...[...this.#sessions.values()].map((session) => session.lock)
+    ]);
+    await this.#save();
+    try {
+      await rpc?.waitForExit(this.#options.requestTimeoutMs ?? 3e4);
+    } catch (error) {
+      this.#fatal = new Error("Codex shutdown could not confirm native process termination", { cause: error });
+      for (const session of this.#sessions.values()) session.uncertain = true;
+      await this.#save();
+      throw this.#fatal;
+    }
+    this.#rpc = void 0;
+    this.#sessions.clear();
+  }
+  setSessionCallbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  get #events() {
+    return this.#started ? this.#callbacks : void 0;
+  }
+  #ready() {
+    if (!this.#started) throw new Error("Codex adapter is not started");
+  }
+  #known(id, requireShared = true) {
+    this.#ready();
+    const session = this.#sessions.get(id);
+    if (!session) throw new Error("Unknown or unowned Codex session");
+    if (requireShared && !session.summary.isRemote) throw new Error("Codex session is not shared");
+    return session;
+  }
+  isSessionVisible(id) {
+    return this.#started && this.#sessions.get(id)?.summary.isRemote === true;
+  }
+  async #native() {
+    this.#ready();
+    if (this.#fatal) throw this.#fatal;
+    if (this.#opening) return this.#opening;
+    if (this.#rpc) return this.#rpc;
+    const rpc = new CodexRpc(
+      (this.#options.spawn ?? spawnCodex)(this.#options.command ?? "codex", this.#options.args ?? ["app-server"]),
+      {
+        timeoutMs: this.#options.requestTimeoutMs ?? 3e4,
+        maxFrameBytes: this.#options.maxFrameBytes ?? 4 * 1024 * 1024,
+        onMessage: (method, params, id) => this.#message(method, params, id),
+        onFailure: (error) => this.#fail(error),
+        ...this.#options.onDiagnostic ? { onDiagnostic: this.#options.onDiagnostic } : {}
+      }
+    );
+    this.#rpc = rpc;
+    this.#opening = (async () => {
+      const response = await rpc.request("initialize", {
+        clientInfo: { name: "agentknight", title: "AgentKnight", version: "1" },
+        capabilities: { experimentalApi: true, requestAttestation: false, explicitGatewayOauth: true }
+      });
+      z4.object({ userAgent: z4.string() }).parse(response);
+      this.#ready();
+      rpc.notify("initialized");
+      return rpc;
+    })();
+    try {
+      return await this.#opening;
+    } catch (error) {
+      rpc.fail(new Error("Codex initialization failed"));
+      throw error;
+    } finally {
+      this.#opening = void 0;
+    }
+  }
+  #fail(error) {
+    this.#fatal ??= error;
+    this.#rpc?.close();
+    this.#dismiss();
+    for (const session of this.#sessions.values()) {
+      if (session.active || session.sending) session.uncertain = true;
+      session.queue = [];
+      for (const resolve2 of session.settled) resolve2();
+      session.settled.clear();
+      this.#events?.onSyncError(session.summary.sessionId, error);
+    }
+    void this.#save().catch(() => {
+      this.#options.onDiagnostic?.("Codex host inventory could not be persisted");
+    });
+  }
+  #save() {
+    this.#saveVersion++;
+    if (this.#saveRunning) return this.#saveRunning;
+    const work = (async () => {
+      let persisted = -1;
+      while (persisted !== this.#saveVersion) {
+        const version = this.#saveVersion;
+        const snapshot = JSON.stringify({
+          version: 1,
+          identity: this.#identity,
+          sessions: [...this.#sessions.values()].map(({ summary, modelId, items, uncertain }) => ({
+            summary,
+            modelId,
+            items,
+            uncertain
+          }))
+        });
+        const staging = join2(this.#directory, `inventory-${randomUUID()}.tmp`);
+        try {
+          await writeFile(staging, snapshot, { mode: 384, flag: "wx" });
+          await rename(staging, join2(this.#directory, "inventory.json"));
+          persisted = version;
+        } finally {
+          await rm(staging, { force: true });
+        }
+      }
+    })();
+    this.#saveRunning = work;
+    const saving = work.then(() => {
+      this.#saveRunning = void 0;
+    }, (error) => {
+      this.#saveRunning = void 0;
+      const failure = new Error("Codex host inventory persistence failed", { cause: error });
+      this.#fatal = failure;
+      this.#rpc?.close();
+      this.#dismiss();
+      for (const session of this.#sessions.values()) {
+        if (session.active || session.sending) session.uncertain = true;
+        session.queue = [];
+        for (const resolve2 of session.settled) resolve2();
+        session.settled.clear();
+        this.#events?.onSyncError(session.summary.sessionId, failure);
+      }
+    });
+    return saving.then(() => work);
+  }
+  async canUpgrade() {
+    return this.#started && !this.#fatal && !this.#opening && !this.#saveRunning && this.#operations === 0 && this.#pending.size === 0 && (this.#rpc?.pendingCount ?? 0) === 0 && [...this.#sessions.values()].every((s) => !s.uncertain && !s.active && !s.sending && !s.aborting && !s.queue.length);
+  }
+  async listSessions(userId, machineId) {
+    this.#ready();
+    const owned = [...this.#sessions.values()].filter((s) => s.summary.userId === userId && s.summary.machineId === machineId && s.summary.isRemote);
+    const rpc = this.#rpc;
+    if (owned.length && rpc && !rpc.closed && !this.#opening && !this.#fatal) {
+      this.#operations++;
+      try {
+        let cursor = null;
+        const seen = /* @__PURE__ */ new Set();
+        let changed = false;
+        do {
+          const result = z4.object({
+            data: z4.array(z4.object({ id: NativeId, preview: z4.string().optional(), name: z4.string().nullable().optional() })),
+            nextCursor: z4.string().nullable()
+          }).parse(await rpc.request("thread/list", {
+            cursor,
+            limit: 100,
+            useStateDbOnly: true,
+            cwd: [...new Set(owned.flatMap((session) => session.summary.workingDirectory ? [session.summary.workingDirectory] : []))]
+          }));
+          this.#ready();
+          for (const entry of result.data) {
+            const session = owned.find((candidate) => candidate.summary.sessionId === entry.id);
+            if (!session || !session.summary.isRemote) continue;
+            const summary = (entry.name ?? entry.preview)?.slice(0, 4096);
+            if (summary && summary !== session.summary.summary) {
+              session.summary.summary = summary;
+              changed = true;
+            }
+          }
+          cursor = result.nextCursor;
+          if (cursor !== null) {
+            if (seen.has(cursor) || seen.size >= 100) throw new Error("Codex thread pagination did not terminate");
+            seen.add(cursor);
+          }
+        } while (cursor !== null);
+        if (changed) await this.#save();
+      } finally {
+        this.#operations--;
+      }
+    }
+    return [...this.#sessions.values()].filter(
+      (s) => s.summary.userId === userId && s.summary.machineId === machineId && s.summary.isRemote
+    ).map((s) => ({ ...s.summary })).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+  }
+  async listModels(sessionId) {
+    if (sessionId) this.#known(sessionId);
+    this.#operations++;
+    try {
+      const rpc = await this.#native();
+      const models = /* @__PURE__ */ new Map([
+        [CODEX_DEFAULT_MODEL_ID, { id: CODEX_DEFAULT_MODEL_ID, name: "Codex default", isDefault: true }]
+      ]);
+      let cursor = null;
+      const seen = /* @__PURE__ */ new Set();
+      do {
+        const result = z4.object({
+          data: z4.array(z4.object({
+            model: z4.string().min(1).max(256),
+            displayName: z4.string().min(1).max(260),
+            hidden: z4.boolean().optional()
+          })),
+          nextCursor: z4.string().nullable()
+        }).parse(await rpc.request("model/list", { cursor, limit: 100 }));
+        this.#ready();
+        for (const model of result.data) {
+          if (!model.hidden) models.set(model.model, { id: model.model, name: model.displayName, isDefault: false });
+        }
+        cursor = result.nextCursor;
+        if (cursor !== null) {
+          if (seen.has(cursor) || seen.size >= 100) throw new Error("Codex model pagination did not terminate");
+          seen.add(cursor);
+        }
+      } while (cursor !== null);
+      return [...models.values()];
+    } finally {
+      this.#operations--;
+    }
+  }
+  #validate(options) {
+    if (options.agentMode !== void 0 && options.agentMode !== "interactive") this.#unsupported("agent modes");
+    if (options.reasoningEffort !== void 0 && options.reasoningEffort !== "default") this.#unsupported("reasoning effort");
+    if (options.configOption) this.#unsupported("native configuration options");
+  }
+  #unsupported(operation) {
+    throw new UnsupportedAgentOperationError("codex", operation);
+  }
+  async createSession(options) {
+    this.#validate(options);
+    if (!isAbsolute(options.workingDirectory)) throw new Error("Codex working directory must be absolute");
+    this.#operations++;
+    try {
+      const rpc = await this.#native();
+      const result = ThreadResult.parse(await rpc.request("thread/start", {
+        cwd: options.workingDirectory,
+        ...options.modelId === CODEX_DEFAULT_MODEL_ID ? {} : { model: options.modelId },
+        approvalPolicy: "on-request",
+        approvalsReviewer: "user",
+        sandbox: "workspace-write",
+        ephemeral: false
+      }));
+      this.#ready();
+      if (this.#sessions.has(result.thread.id)) throw new Error("Codex reused an owned thread ID");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const summary = SessionSummarySchema.parse({
+        sessionId: result.thread.id,
+        userId: options.userId,
+        machineId: options.machineId,
+        workingDirectory: options.workingDirectory,
+        createdAt: now,
+        modifiedAt: now,
+        isRemote: true,
+        renameSupported: false
+      });
+      const session = this.#runtime({
+        summary,
+        modelId: options.modelId,
+        items: [],
+        uncertain: result.thread.status.type !== "idle" || result.thread.turns.some((turn) => turn.status === "inProgress")
+      });
+      session.loaded = true;
+      this.#sessions.set(summary.sessionId, session);
+      await this.#save();
+      this.#events?.onSessionInventoryChanged(summary.sessionId);
+      return { ...summary };
+    } finally {
+      this.#operations--;
+    }
+  }
+  async getSessionConfiguration(id) {
+    return { modelId: this.#known(id).modelId, agentMode: "interactive", reasoningEffort: "default" };
+  }
+  async configureSession(id, options) {
+    const session = this.#known(id);
+    this.#validate(options);
+    if (options.modelId !== void 0 && options.modelId !== session.modelId) this.#unsupported("changing a session model");
+    return this.getSessionConfiguration(id);
+  }
+  async getSessionDirectoryMetadata(id) {
+    const cwd = this.#known(id).summary.workingDirectory;
+    return cwd === void 0 ? {} : { workingDirectory: cwd };
+  }
+  async getSessionEnvironment(id) {
+    this.#known(id);
+    return { tools: [], skills: [], slashCommands: [] };
+  }
+  async getSessionRemoteStatus(id) {
+    const session = this.#known(id, false);
+    return { state: session.summary.isRemote ? "active" : "off", steerable: session.summary.isRemote && !session.uncertain && !this.#fatal };
+  }
+  async setSessionRemote(id, enabled) {
+    const session = this.#known(id, false);
+    session.summary.isRemote = enabled;
+    if (!enabled) await this.#abort(session);
+    await this.#save();
+    this.#events?.onSessionInventoryChanged(id);
+    return this.getSessionRemoteStatus(id);
+  }
+  async watchSession(id, _watched) {
+    this.#known(id);
+  }
+  async readSessionPlan(_id) {
+    return this.#unsupported("plan documents");
+  }
+  async setGroupChatEnabled(enabled) {
+    if (enabled) this.#unsupported("group chat");
+  }
+  async setPeerChatEnabled(enabled) {
+    if (enabled) this.#unsupported("peer chat");
+  }
+  async readSessionTimelinePage(id, options = {}) {
+    const session = this.#known(id);
+    const size = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
+    if (!Number.isInteger(size) || size < 1 || size > SESSION_TIMELINE_PAGE_SIZE) throw new RangeError("Invalid timeline page size");
+    let end = session.items.length;
+    let cursorStatus = "ok";
+    if (options.cursor !== void 0) {
+      const index = session.items.findIndex((item) => `${hash(id)}:${item.id}` === options.cursor);
+      if (index < 0) cursorStatus = "expired";
+      else end = index;
+    }
+    const start = Math.max(0, end - size);
+    const items = options.metadataOnly ? options.assistantPreview ? latestPreviewItems(session.items).slice(-size) : [] : session.items.slice(start, end);
+    return {
+      items: structuredClone(items),
+      cursor: `${hash(id)}:${session.items[start]?.id ?? "empty"}`,
+      hasMore: options.metadataOnly ? false : start > 0,
+      cursorStatus
+    };
+  }
+  #locked(session, run) {
+    this.#operations++;
+    const work = session.lock.then(run);
+    session.lock = work.then(() => {
+      this.#operations--;
+    }, () => {
+      this.#operations--;
+    });
+    return work;
+  }
+  async #load(session) {
+    if (session.loaded) return;
+    const rpc = await this.#native();
+    const threadId = session.summary.sessionId;
+    const read = ThreadResult.parse(await rpc.request("thread/read", { threadId, includeTurns: true }));
+    if (read.thread.id !== threadId || !["idle", "notLoaded"].includes(read.thread.status.type) || read.thread.turns.some((turn) => turn.status === "inProgress")) {
+      session.uncertain = true;
+      await this.#save();
+      throw new Error("Codex owned thread is not verifiably idle; refusing to attach");
+    }
+    this.#known(threadId);
+    if (session.aborting) throw new Error("Codex resume cancelled");
+    const resumed = ThreadResult.parse(await rpc.request("thread/resume", {
+      threadId,
+      cwd: session.summary.workingDirectory,
+      approvalPolicy: "on-request",
+      approvalsReviewer: "user",
+      sandbox: "workspace-write"
+    }));
+    if (resumed.thread.id !== threadId || resumed.thread.status.type !== "idle") {
+      session.uncertain = true;
+      await this.#save();
+      throw new Error("Codex resume did not confirm an idle owned thread");
+    }
+    for (const turn of resumed.thread.turns) {
+      for (const item of turn.items) {
+        const projected = projectItem(threadId, turn.id, item, turn.status !== "inProgress");
+        if (projected) this.#upsert(session, projected);
+      }
+    }
+    session.loaded = true;
+  }
+  async sendPrompt(id, prompt, mode, attachments = [], _persistInteractions = true, files = [], _operationId, persona) {
+    const session = this.#known(id);
+    if (attachments.length || files.length) this.#unsupported("attachments");
+    if (persona !== void 0) this.#unsupported("avatar personas");
+    if (mode !== "enqueue" && mode !== "immediate") this.#unsupported("delivery mode");
+    if (!prompt.trim() || prompt.length > 1e5) throw new Error("Invalid Codex prompt length");
+    const job = { id: randomUUID(), text: prompt, epoch: session.epoch };
+    return this.#locked(session, async () => {
+      this.#checkSend(session, job, mode === "enqueue" && session.active !== void 0);
+      if (mode === "enqueue" && (session.active || session.queue.length)) {
+        if (session.queue.length >= 100) throw new Error("Codex host queue is full");
+        session.queue.push(job);
+        return { messageId: job.id, deliveryState: "queued" };
+      }
+      return this.#dispatch(session, job);
+    });
+  }
+  #checkSend(session, job, allowPending = false) {
+    this.#known(session.summary.sessionId);
+    if (this.#fatal) throw this.#fatal;
+    if (session.aborting || session.epoch !== job.epoch) throw new Error("Codex prompt cancelled");
+    if (session.uncertain && !session.active && !session.sending) throw new Error("Codex outcome unknown; refusing automatic replay or new work");
+    if (!allowPending && [...this.#pending.values()].some((p) => p.session === session)) {
+      throw new Error("Codex session awaits an interaction");
+    }
+  }
+  async #dispatch(session, job) {
+    this.#checkSend(session, job);
+    await this.#load(session);
+    this.#checkSend(session, job);
+    const rpc = await this.#native();
+    this.#checkSend(session, job);
+    const expectedTurnId = session.active;
+    session.sending = true;
+    session.uncertain = true;
+    let transmitted = false;
+    try {
+      await this.#save();
+      this.#checkSend(session, job);
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const input = [{ type: "text", text: job.text, text_elements: [] }];
+      transmitted = true;
+      const response = expectedTurnId ? await rpc.request("turn/steer", { threadId: session.summary.sessionId, expectedTurnId, clientUserMessageId: job.id, input }) : await rpc.request("turn/start", { threadId: session.summary.sessionId, clientUserMessageId: job.id, input });
+      this.#ready();
+      const startedTurn = expectedTurnId ? void 0 : z4.object({ turn: NativeTurn }).parse(response).turn;
+      const turnId = startedTurn?.id ?? z4.object({ turnId: NativeId }).parse(response).turnId;
+      if (expectedTurnId && turnId !== expectedTurnId) throw new Error("Codex steer changed the expected turn");
+      if (startedTurn && startedTurn.status !== "inProgress") this.#complete(session, startedTurn);
+      else if (!session.completed.has(turnId)) session.active = turnId;
+      session.uncertain = session.active !== void 0;
+      return { messageId: job.id, deliveryState: "processing", submittedAt };
+    } catch (error) {
+      if (!transmitted || error instanceof CodexRpcError) {
+        session.uncertain = session.active !== void 0;
+      } else {
+        session.uncertain = true;
+        if (this.#started) this.#fail(new Error("Codex submission outcome unknown; no automatic replay"));
+      }
+      throw error;
+    } finally {
+      session.sending = false;
+      await this.#save();
+      this.#pump(session);
+    }
+  }
+  #pump(session) {
+    if (!this.#started || this.#fatal || session.active || session.sending || session.aborting || session.uncertain || session.pumpScheduled || !session.queue.length) return;
+    session.pumpScheduled = true;
+    void this.#locked(session, async () => {
+      if (session.active || session.aborting || session.uncertain) return;
+      const job = session.queue.shift();
+      if (job) await this.#dispatch(session, job);
+    }).catch((error) => {
+      session.queue = [];
+      this.#events?.onSyncError(session.summary.sessionId, error);
+    }).finally(() => {
+      session.pumpScheduled = false;
+      this.#pump(session);
+    });
+  }
+  async abortSession(id) {
+    await this.#abort(this.#known(id));
+  }
+  async #abort(session) {
+    session.aborting = true;
+    session.epoch++;
+    session.queue = [];
+    this.#dismiss(session);
+    try {
+      await session.lock;
+      if (session.active) {
+        const rpc = this.#rpc;
+        if (!rpc || rpc.closed) throw new Error("Codex interrupt cannot verify native settlement");
+        const turnId = session.active;
+        await rpc.request("turn/interrupt", { threadId: session.summary.sessionId, turnId });
+        if (session.active === turnId) {
+          await new Promise((resolve2, reject) => {
+            const finish = () => {
+              clearTimeout(timer);
+              session.settled.delete(finish);
+              resolve2();
+            };
+            const timer = setTimeout(() => {
+              session.settled.delete(finish);
+              reject(new Error("Codex interrupt settlement timed out"));
+            }, this.#options.requestTimeoutMs ?? 3e4);
+            session.settled.add(finish);
+          });
+        }
+      }
+      if (session.active || session.uncertain || this.#fatal) throw new Error("Codex cancellation outcome is unknown");
+    } catch (error) {
+      session.uncertain = true;
+      throw error;
+    } finally {
+      session.aborting = false;
+      await this.#save();
+    }
+  }
+  #upsert(session, value) {
+    const index = session.items.findIndex((item2) => item2.id === value.id);
+    const previous = session.items[index];
+    const item = ConversationItemSchema.parse({
+      ...value,
+      revision: previous ? previous.revision + 1 : 1,
+      timestamp: previous?.timestamp ?? value.timestamp
+    });
+    if (index < 0) session.items.push(item);
+    else session.items[index] = item;
+    session.summary.modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (session.summary.isRemote) this.#events?.onConversationItem(session.summary.sessionId, structuredClone(item));
+    void this.#save().catch(() => {
+    });
+  }
+  #message(method, params, rpcId) {
+    if (!this.#started || this.#fatal) return;
+    if (rpcId !== void 0) {
+      this.#request(method, params, rpcId);
+      return;
+    }
+    const context = z4.object({ threadId: NativeId }).safeParse(params);
+    if (!context.success) return;
+    const session = this.#sessions.get(context.data.threadId);
+    if (session && method === "serverRequest/resolved") {
+      const resolved = z4.object({ requestId: z4.union([z4.string(), z4.number().int()]) }).parse(params);
+      for (const [id, pending] of this.#pending) {
+        if (pending.session === session && pending.rpcId === resolved.requestId) this.#finish(id, void 0, false);
+      }
+      return;
+    }
+    if (session?.loaded && method === "thread/status/changed") {
+      const status = z4.object({ status: z4.object({ type: z4.string() }) }).parse(params).status.type;
+      if (status === "systemError" || status === "active" && !session.active && !session.sending) {
+        session.uncertain = true;
+        this.#fail(new Error("Codex owned thread has unverifiable native activity"));
+      }
+      return;
+    }
+    if (session?.loaded && method === "turn/started" && !session.active && !session.sending) {
+      const { turn } = TurnEvent.parse(params);
+      if (!session.completed.has(turn.id)) {
+        session.uncertain = true;
+        this.#fail(new Error("Codex started an unsolicited native turn"));
+      }
+      return;
+    }
+    if (!session || !session.loaded || !session.active && !session.sending) return;
+    if (method === "turn/started" || method === "turn/completed") {
+      const { turn } = TurnEvent.parse(params);
+      if (session.active && session.active !== turn.id) return;
+      if (method === "turn/started") {
+        if (session.completed.has(turn.id)) return;
+        session.active = turn.id;
+        this.#events?.onSessionActivity?.(session.summary.sessionId, "working", (/* @__PURE__ */ new Date()).toISOString());
+      } else {
+        this.#complete(session, turn);
+        void this.#save().then(() => this.#pump(session)).catch(() => {
+        });
+      }
+      return;
+    }
+    const event = EventContext.safeParse(params);
+    if (!event.success || session.completed.has(event.data.turnId) || session.active && event.data.turnId !== session.active) return;
+    if (method === "item/started" || method === "item/completed") {
+      const { turnId, item } = ItemEvent.parse(params);
+      if (method === "item/started" && session.items.some((existing) => existing.id === itemId(session.summary.sessionId, item.id))) return;
+      const projected = projectItem(session.summary.sessionId, turnId, item, method === "item/completed");
+      if (projected) this.#upsert(session, projected);
+      if (item.aggregatedOutput) this.#output(session, turnId, `${item.id}:output`, "Tool output", item.aggregatedOutput);
+      if (item.changes) this.#output(
+        session,
+        turnId,
+        `${item.id}:diff`,
+        "File changes",
+        item.changes.map((change) => `${change.path}
+${change.diff}`).join("\n")
+      );
+    } else if (method === "item/agentMessage/delta") {
+      const delta = DeltaEvent.parse(params);
+      const old = session.items.find((item) => item.id === itemId(delta.threadId, delta.itemId));
+      if (old?.kind === "assistant-message" && old.final) return;
+      this.#upsert(session, ConversationItemSchema.parse({
+        ...base(delta.threadId, delta.turnId, delta.itemId),
+        kind: "assistant-message",
+        actor: "assistant",
+        content: ((old?.kind === "assistant-message" ? old.content : "") + delta.delta).slice(0, 5e5),
+        final: false
+      }));
+    } else if (method === "item/commandExecution/outputDelta" || method === "item/fileChange/outputDelta") {
+      const delta = DeltaEvent.parse(params);
+      const nativeId = `${delta.itemId}:output`;
+      const old = session.items.find((item) => item.id === itemId(delta.threadId, nativeId));
+      this.#output(
+        session,
+        delta.turnId,
+        nativeId,
+        "Tool output",
+        (old?.kind === "notice" ? old.content : "") + delta.delta
+      );
+    } else if (method === "turn/diff/updated") {
+      const diff = EventContext.extend({ diff: z4.string() }).parse(params);
+      this.#output(session, diff.turnId, `${diff.turnId}:diff`, "Turn diff", diff.diff);
+    } else if (method === "item/fileChange/patchUpdated") {
+      const patch = EventContext.extend({
+        itemId: NativeId,
+        changes: z4.array(z4.object({ path: z4.string(), diff: z4.string() }))
+      }).parse(params);
+      this.#output(
+        session,
+        patch.turnId,
+        `${patch.itemId}:diff`,
+        "File changes",
+        patch.changes.map((change) => `${change.path}
+${change.diff}`).join("\n")
+      );
+    } else if (method === "error") {
+      const error = new Error("Codex reported a native turn error");
+      this.#events?.onSyncError(session.summary.sessionId, error);
+    }
+  }
+  #output(session, turnId, id, title, text) {
+    this.#upsert(session, ConversationItemSchema.parse({
+      ...base(session.summary.sessionId, turnId, id),
+      kind: "notice",
+      actor: "assistant",
+      severity: "info",
+      title,
+      content: text.slice(-4096)
+    }));
+  }
+  #complete(session, turn) {
+    session.completed.add(turn.id);
+    session.active = void 0;
+    session.uncertain = false;
+    for (const item of turn.items) {
+      const projected = projectItem(session.summary.sessionId, turn.id, item, true);
+      if (projected) this.#upsert(session, projected);
+    }
+    for (const item of [...session.items]) {
+      if (item.turnId !== turn.id) continue;
+      if (item.kind === "assistant-message" && !item.final) {
+        this.#upsert(session, { ...item, final: true });
+      } else if (item.kind === "activity-group" && item.status === "running") {
+        const status = turn.status === "completed" ? "completed" : "failed";
+        this.#upsert(session, { ...item, status, steps: item.steps.map((step) => step.kind !== "skill" && step.status === "running" ? { ...step, status } : step) });
+      }
+    }
+    this.#dismiss(session);
+    for (const resolve2 of session.settled) resolve2();
+    session.settled.clear();
+    this.#events?.onSessionActivity?.(session.summary.sessionId, "idle", (/* @__PURE__ */ new Date()).toISOString());
+  }
+  #request(method, params, rpcId) {
+    const context = EventContext.safeParse(params);
+    const session = context.success ? this.#sessions.get(context.data.threadId) : void 0;
+    if (!session || !session.summary.isRemote || session.aborting || context.success && session.completed.has(context.data.turnId) || !session.active && !session.sending || session.active && context.success && session.active !== context.data.turnId) {
+      this.#rpc?.reject(rpcId);
+      return;
+    }
+    if ([...this.#pending.values()].some((pending2) => pending2.rpcId === rpcId)) return;
+    let request;
+    let questionId;
+    if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+      const approval = Approval.parse(params);
+      request = InteractionRequestSchema.parse({
+        kind: "permission",
+        permissionKind: method.includes("commandExecution") ? "shell" : "write",
+        title: "Codex approval",
+        description: (approval.reason ?? approval.command ?? "Approve this action?").slice(0, 4096),
+        canApproveSession: false,
+        canApproveAlways: false
+      });
+    } else if (method === "item/tool/requestUserInput") {
+      const questions = Questions.parse(params);
+      const question = questions.questions[0];
+      if (questions.questions.length !== 1 || !question || question.isSecret) {
+        this.#rpc?.reject(rpcId);
+        return;
+      }
+      questionId = question.id;
+      request = InteractionRequestSchema.parse({
+        kind: "user_input",
+        question: question.question,
+        choices: question.options?.map((option) => option.label) ?? [],
+        allowFreeform: question.isOther || !question.options?.length
+      });
+    } else {
+      this.#rpc?.reject(rpcId);
+      return;
+    }
+    const id = randomUUID();
+    const pending = {
+      session,
+      rpcId,
+      request,
+      ...questionId ? { questionId } : {},
+      timer: setTimeout(() => this.#finish(id), this.#options.interactionTimeoutMs ?? 12e4)
+    };
+    this.#pending.set(id, pending);
+    this.#publish(id, pending);
+  }
+  #publish(id, pending) {
+    if (!pending.session.summary.isRemote) return;
+    if (this.#events?.onInteractionRequest) {
+      this.#events.onInteractionRequest(pending.session.summary.sessionId, id, pending.request);
+    } else if (pending.request.kind === "permission") {
+      this.#events?.onPermissionRequest(pending.session.summary.sessionId, id, { kind: pending.request.permissionKind });
+    }
+  }
+  #finish(id, result, respond = true) {
+    const pending = this.#pending.get(id);
+    if (!pending) return false;
+    clearTimeout(pending.timer);
+    this.#pending.delete(id);
+    if (respond && this.#rpc && !this.#rpc.closed) {
+      this.#rpc.respond(pending.rpcId, result ?? (pending.questionId ? { answers: {} } : { decision: "cancel" }));
+    }
+    this.#events?.onInteractionDismissed?.(pending.session.summary.sessionId, id);
+    return true;
+  }
+  #dismiss(session) {
+    for (const [id, pending] of this.#pending) if (!session || session === pending.session) this.#finish(id);
+  }
+  respondPermission(id, decision, _feedback) {
+    const pending = this.#pending.get(id);
+    if (!pending || pending.request.kind !== "permission" || !this.isSessionVisible(pending.session.summary.sessionId)) return false;
+    return this.#finish(id, { decision: decision === "approve-once" ? "accept" : "decline" });
+  }
+  async respondInteraction(id, response) {
+    const pending = this.#pending.get(id);
+    if (!pending || !this.isSessionVisible(pending.session.summary.sessionId)) return false;
+    if (response.kind === "permission" && pending.request.kind === "permission") {
+      if (response.decision !== "approve-once" && response.decision !== "reject") this.#unsupported("persistent approval");
+      return this.respondPermission(id, response.decision);
+    }
+    if (response.kind === "user_input" && pending.request.kind === "user_input" && pending.questionId) {
+      if (!pending.request.allowFreeform && !pending.request.choices.includes(response.answer)) throw new Error("Invalid Codex question answer");
+      return this.#finish(id, { answers: { [pending.questionId]: { answers: [response.answer] } } });
+    }
+    this.#unsupported("interaction response");
+  }
+  replayPendingInteractions() {
+    if (!this.#started) return;
+    for (const [id, pending] of this.#pending) this.#publish(id, pending);
+  }
+};
+export {
+  CODEX_DEFAULT_MODEL_ID,
+  CodexCodingAgentAdapter
+};