@codex-native/sdk 0.0.1 → 0.0.2

package/dist/chunk-ZTUGAPWF.mjs

@@ -0,0 +1,1996 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+
+// src/nativeBinding.ts
+import fs from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var CLI_ENTRYPOINT_ENV = "CODEX_NODE_CLI_ENTRYPOINT";
+function ensureCliEntrypointEnv() {
+  if (process.env[CLI_ENTRYPOINT_ENV]) {
+    return;
+  }
+  const filename = fileURLToPath2(import.meta.url);
+  const dirname3 = path2.dirname(filename);
+  const candidates = [
+    path2.resolve(dirname3, "cli.cjs"),
+    path2.resolve(dirname3, "../cli.cjs"),
+    path2.resolve(dirname3, "../dist/cli.cjs")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      process.env[CLI_ENTRYPOINT_ENV] = candidate;
+      break;
+    }
+  }
+}
+ensureCliEntrypointEnv();
+var cachedBinding;
+function getImportMetaUrl() {
+  try {
+    return Function(
+      "return typeof import.meta !== 'undefined' && import.meta.url ? import.meta.url : undefined;"
+    )();
+  } catch {
+    return void 0;
+  }
+}
+function resolveBindingEntryPath() {
+  if (typeof __dirname === "string") {
+    return path2.resolve(__dirname, "..", "index.js");
+  }
+  const importMetaUrl = getImportMetaUrl();
+  if (importMetaUrl) {
+    try {
+      const filePath = fileURLToPath2(importMetaUrl);
+      return path2.resolve(path2.dirname(filePath), "..", "index.js");
+    } catch {
+    }
+  }
+  return path2.resolve(process.cwd(), "index.js");
+}
+function resolveRequire() {
+  const globalRequire = globalThis.require;
+  if (typeof globalRequire === "function") {
+    return globalRequire;
+  }
+  if (typeof __filename === "string") {
+    try {
+      return createRequire(__filename);
+    } catch {
+    }
+  }
+  const importMetaUrl = getImportMetaUrl();
+  if (importMetaUrl) {
+    try {
+      return createRequire(importMetaUrl);
+    } catch {
+    }
+  }
+  const fallbackBase = typeof __dirname === "string" ? __dirname : process.cwd();
+  const fallbackPath = path2.join(fallbackBase, "noop.js");
+  return createRequire(fallbackPath);
+}
+function getNativeBinding() {
+  if (cachedBinding !== void 0) {
+    return cachedBinding;
+  }
+  const requireFn = resolveRequire();
+  const envPath = process.env.CODEX_NATIVE_BINDING;
+  if (envPath && envPath.length > 0) {
+    process.env.NAPI_RS_NATIVE_LIBRARY_PATH = envPath;
+  }
+  const bindingEntryPath = resolveBindingEntryPath();
+  try {
+    const binding = requireFn(bindingEntryPath);
+    binding.ensureTokioRuntime?.();
+    cachedBinding = binding;
+    return cachedBinding;
+  } catch (error) {
+    console.warn("Failed to load native NAPI binding:", error);
+    cachedBinding = null;
+    return cachedBinding;
+  }
+}
+function runApplyPatch(patch) {
+  if (!patch) {
+    throw new Error("apply_patch requires patch contents");
+  }
+  const binding = getNativeBinding();
+  if (!binding) throw new Error("Native binding not available");
+  binding.runApplyPatch(patch);
+}
+async function reverieListConversations(codexHomePath, limit, offset) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieListConversations) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieListConversations(codexHomePath, limit, offset);
+}
+async function reverieSearchConversations(codexHomePath, query, limit) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieSearchConversations) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieSearchConversations(codexHomePath, query, limit);
+}
+async function reverieSearchSemantic(codexHomePath, context, options) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieSearchSemantic) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieSearchSemantic(codexHomePath, context, options);
+}
+async function reverieIndexSemantic(codexHomePath, options) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieIndexSemantic) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieIndexSemantic(codexHomePath, options);
+}
+async function reverieGetConversationInsights(conversationPath, query) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieGetConversationInsights) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieGetConversationInsights(conversationPath, query);
+}
+function encodeToToon(value) {
+  const binding = getNativeBinding();
+  if (!binding?.toonEncode) throw new Error("Native binding not available or toon encoder not supported");
+  return binding.toonEncode(value);
+}
+async function fastEmbedInit(options) {
+  const binding = getNativeBinding();
+  if (!binding?.fastEmbedInit) throw new Error("Native binding not available or FastEmbed functions not supported");
+  await binding.fastEmbedInit(options);
+}
+async function fastEmbedEmbed(request) {
+  const binding = getNativeBinding();
+  if (!binding?.fastEmbedEmbed) throw new Error("Native binding not available or FastEmbed functions not supported");
+  return binding.fastEmbedEmbed(request);
+}
+function tokenizerCount(text, options) {
+  const binding = getNativeBinding();
+  if (!binding?.tokenizerCount) throw new Error("Native binding not available or tokenizer functions not supported");
+  return binding.tokenizerCount(text, options);
+}
+function tokenizerEncode(text, options) {
+  const binding = getNativeBinding();
+  if (!binding?.tokenizerEncode) throw new Error("Native binding not available or tokenizer functions not supported");
+  return binding.tokenizerEncode(text, options);
+}
+function tokenizerDecode(tokens, options) {
+  const binding = getNativeBinding();
+  if (!binding?.tokenizerDecode) throw new Error("Native binding not available or tokenizer functions not supported");
+  return binding.tokenizerDecode(tokens, options);
+}
+async function collectRepoDiffSummary(options) {
+  const binding = getNativeBinding();
+  if (!binding?.collectRepoDiffSummary) {
+    throw new Error("Native binding not available or repo diff helpers not supported");
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const nativeOptions = options && (options.maxFiles !== void 0 || options.diffContextLines !== void 0 || options.diffCharLimit !== void 0) ? {
+    maxFiles: options.maxFiles,
+    diffContextLines: options.diffContextLines,
+    diffCharLimit: options.diffCharLimit
+  } : void 0;
+  return binding.collectRepoDiffSummary(cwd, options?.baseBranchOverride, nativeOptions);
+}
+
+// src/tui.ts
+function startTui(request) {
+  const binding = getNativeBinding();
+  if (!binding) {
+    throw new Error("Native binding is not available");
+  }
+  if (typeof binding.startTui === "function") {
+    const nativeSession = binding.startTui(request);
+    return wrapNativeSession(nativeSession);
+  }
+  if (typeof binding.runTui === "function") {
+    return createLegacySession(binding, request);
+  }
+  throw new Error("Native binding does not expose startTui or runTui");
+}
+async function runTui(request, options = {}) {
+  const session = startTui(request);
+  const { signal } = options;
+  let abortListener;
+  try {
+    if (signal) {
+      if (signal.aborted) {
+        session.shutdown();
+      } else {
+        abortListener = () => session.shutdown();
+        signal.addEventListener("abort", abortListener, { once: true });
+      }
+    }
+    return await session.wait();
+  } finally {
+    if (abortListener && signal) {
+      signal.removeEventListener("abort", abortListener);
+    }
+  }
+}
+function wrapNativeSession(nativeSession) {
+  return {
+    wait: () => nativeSession.wait(),
+    shutdown: () => nativeSession.shutdown(),
+    get closed() {
+      return nativeSession.closed;
+    }
+  };
+}
+function createLegacySession(binding, request) {
+  if (typeof binding.runTui !== "function") {
+    throw new Error("Native binding does not expose runTui");
+  }
+  let closed = false;
+  const promise = binding.runTui(request).then(
+    (result) => {
+      closed = true;
+      return result;
+    },
+    (error) => {
+      closed = true;
+      throw error;
+    }
+  );
+  return {
+    wait: () => promise,
+    shutdown() {
+      throw new Error(
+        "Programmatic shutdown is not supported by this native binding build. Rebuild the SDK to enable startTui()."
+      );
+    },
+    get closed() {
+      return closed;
+    }
+  };
+}
+
+// src/lsp/servers.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+var MARKERS_NODE = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"];
+var MARKERS_PY = ["pyproject.toml", "requirements.txt", "Pipfile", "setup.py", "setup.cfg", "poetry.lock"];
+var MARKERS_RUST = ["Cargo.toml"];
+var DEFAULT_SERVERS = [
+  {
+    id: "typescript",
+    displayName: "TypeScript Language Server",
+    command: ["typescript-language-server", "--stdio"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    workspace: { type: "markers", include: MARKERS_NODE }
+  },
+  {
+    id: "pyright",
+    displayName: "Pyright",
+    command: ["pyright-langserver", "--stdio"],
+    extensions: [".py", ".pyi"],
+    workspace: { type: "markers", include: MARKERS_PY }
+  },
+  {
+    id: "rust-analyzer",
+    displayName: "rust-analyzer",
+    command: ["rust-analyzer"],
+    extensions: [".rs"],
+    workspace: { type: "markers", include: MARKERS_RUST }
+  }
+];
+function findServerForFile(filePath) {
+  const lower = filePath.toLowerCase();
+  return DEFAULT_SERVERS.find((server) => server.extensions.some((ext) => lower.endsWith(ext)));
+}
+function resolveWorkspaceRoot(filePath, locator, fallbackDir) {
+  if (!locator) {
+    return fallbackDir;
+  }
+  if (locator.type === "fixed") {
+    return locator.path;
+  }
+  const include = locator.include ?? [];
+  const exclude = locator.exclude ?? [];
+  let current = fs2.statSync(filePath, { throwIfNoEntry: false })?.isDirectory() ? filePath : path3.dirname(filePath);
+  const root = path3.parse(current).root;
+  while (true) {
+    if (exclude.some((pattern) => fs2.existsSync(path3.join(current, pattern)))) {
+      break;
+    }
+    if (include.some((pattern) => fs2.existsSync(path3.join(current, pattern)))) {
+      return current;
+    }
+    if (current === root) {
+      break;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return fallbackDir;
+}
+
+// src/lsp/manager.ts
+import * as path5 from "path";
+
+// src/lsp/client.ts
+import { spawn } from "child_process";
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
+import { EventEmitter } from "events";
+import { createMessageConnection } from "vscode-jsonrpc";
+import { StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/lib/node/main.js";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+var DEFAULT_TIMEOUT_MS = 3e3;
+var LspClient = class _LspClient {
+  constructor(config, root) {
+    this.config = config;
+    this.root = root;
+  }
+  connection = null;
+  process = null;
+  diagnostics = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  emitter = new EventEmitter();
+  static async start(server, root) {
+    const client = new _LspClient(server, root);
+    await client.initialize();
+    return client;
+  }
+  async initialize() {
+    const [command, ...args] = this.config.command;
+    if (!command) {
+      throw new Error(`LSP server ${this.config.id} is missing a command executable`);
+    }
+    try {
+      this.process = spawn(command, args, {
+        cwd: this.root,
+        env: { ...process.env, ...this.config.env },
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(`Failed to spawn ${this.config.displayName} (${command}): ${String(error)}`);
+    }
+    const child = this.process;
+    child.stderr.on("data", (_chunk) => {
+    });
+    const reader = new StreamMessageReader(child.stdout);
+    const writer = new StreamMessageWriter(child.stdin);
+    this.connection = createMessageConnection(reader, writer);
+    this.connection.onNotification("textDocument/publishDiagnostics", (payload) => {
+      const fsPath = fileURLToPath3(payload.uri);
+      this.diagnostics.set(fsPath, payload.diagnostics);
+      this.emitter.emit(`diagnostics:${fsPath}`);
+    });
+    this.connection.onError((err) => {
+      console.warn(`[lsp:${this.config.id}] connection error`, err);
+    });
+    this.connection.listen();
+    await this.connection.sendRequest("initialize", {
+      rootUri: pathToFileURL(this.root).href,
+      processId: process.pid,
+      initializationOptions: this.config.initializationOptions ?? {},
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true
+          },
+          publishDiagnostics: {
+            versionSupport: true
+          }
+        },
+        workspace: {
+          workspaceFolders: true
+        }
+      },
+      workspaceFolders: [
+        {
+          name: path4.basename(this.root),
+          uri: pathToFileURL(this.root).href
+        }
+      ]
+    });
+    await this.connection.sendNotification("initialized", {});
+  }
+  async openFile(filePath, waitForDiagnostics) {
+    if (!this.connection) return;
+    const absolute = path4.resolve(filePath);
+    const text = await fs3.readFile(absolute, "utf8");
+    const uri = pathToFileURL(absolute).href;
+    const languageId = detectLanguageId(absolute);
+    const existingVersion = this.versions.get(absolute);
+    if (existingVersion === void 0) {
+      this.versions.set(absolute, 0);
+      await this.connection.sendNotification("textDocument/didOpen", {
+        textDocument: {
+          uri,
+          languageId,
+          version: 0,
+          text
+        }
+      });
+    } else {
+      const next = existingVersion + 1;
+      this.versions.set(absolute, next);
+      await this.connection.sendNotification("textDocument/didChange", {
+        textDocument: {
+          uri,
+          version: next
+        },
+        contentChanges: [{ text }]
+      });
+    }
+    if (waitForDiagnostics) {
+      await this.waitForDiagnostics(absolute);
+    }
+  }
+  getDiagnostics(filePath) {
+    const absolute = path4.resolve(filePath);
+    return this.diagnostics.get(absolute) ?? [];
+  }
+  waitForDiagnostics(filePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const absolute = path4.resolve(filePath);
+    return new Promise((resolve5) => {
+      const timer = setTimeout(resolve5, timeoutMs).unref();
+      this.emitter.once(`diagnostics:${absolute}`, () => {
+        clearTimeout(timer);
+        resolve5();
+      });
+    });
+  }
+  async shutdown() {
+    try {
+      await this.connection?.dispose();
+    } catch {
+    }
+    if (this.process && !this.process.killed) {
+      this.process.kill();
+    }
+  }
+};
+function detectLanguageId(filePath) {
+  const ext = path4.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "typescript";
+    case ".tsx":
+      return "typescriptreact";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    case ".jsx":
+      return "javascriptreact";
+    case ".py":
+    case ".pyi":
+      return "python";
+    case ".rs":
+      return "rust";
+    default:
+      return "plaintext";
+  }
+}
+function normalizeSeverity(severity) {
+  switch (severity) {
+    case DiagnosticSeverity.Error:
+      return "error";
+    case DiagnosticSeverity.Warning:
+      return "warning";
+    case DiagnosticSeverity.Information:
+      return "info";
+    case DiagnosticSeverity.Hint:
+      return "hint";
+    default:
+      return "error";
+  }
+}
+
+// src/lsp/manager.ts
+var LspManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  clients = /* @__PURE__ */ new Map();
+  async collectDiagnostics(files) {
+    const unique = Array.from(new Set(files.map((file) => path5.resolve(file))));
+    const results = [];
+    for (const filePath of unique) {
+      const server = findServerForFile(filePath);
+      if (!server) {
+        continue;
+      }
+      const root = resolveWorkspaceRoot(filePath, server.workspace, this.options.workingDirectory);
+      const client = await this.getClient(server, root);
+      if (!client) {
+        continue;
+      }
+      try {
+        await client.openFile(filePath, this.options.waitForDiagnostics !== false);
+      } catch (error) {
+        console.warn(`[lsp] failed to open ${filePath}:`, error);
+        continue;
+      }
+      const normalized = client.getDiagnostics(filePath).map((diag) => normalizeDiagnostic(diag)).filter((diag) => diag.message.trim().length > 0);
+      if (normalized.length > 0) {
+        results.push({ path: filePath, diagnostics: normalized });
+      }
+    }
+    return results;
+  }
+  async dispose() {
+    await Promise.all(
+      Array.from(this.clients.values()).map(async (promise) => {
+        const client = await promise;
+        await client?.shutdown();
+      })
+    );
+    this.clients.clear();
+  }
+  async getClient(server, root) {
+    const key = `${server.id}:${root}`;
+    let existing = this.clients.get(key);
+    if (!existing) {
+      existing = this.createClient(server, root);
+      this.clients.set(key, existing);
+    }
+    const client = await existing;
+    if (!client) {
+      this.clients.delete(key);
+    }
+    return client;
+  }
+  async createClient(server, root) {
+    try {
+      return await LspClient.start(server, root);
+    } catch (error) {
+      console.warn(`[lsp] unable to start ${server.displayName}:`, error);
+      return null;
+    }
+  }
+};
+function normalizeDiagnostic(diag) {
+  return {
+    message: diag.message ?? "",
+    severity: normalizeSeverity(diag.severity),
+    source: diag.source,
+    code: diag.code,
+    range: diag.range
+  };
+}
+
+// src/lsp/format.ts
+import * as path6 from "path";
+var MAX_DIAGNOSTICS_PER_FILE = 5;
+function formatDiagnosticsForTool(diagnostics) {
+  return diagnostics.map(({ path: filePath, diagnostics: entries }) => {
+    const rel = filePath;
+    const lines = entries.slice(0, MAX_DIAGNOSTICS_PER_FILE).map((diag) => {
+      const { line, character } = diag.range.start;
+      const location = `${line + 1}:${character + 1}`;
+      const source = diag.source ? ` \xB7 ${diag.source}` : "";
+      return `  - [${diag.severity.toUpperCase()}] ${diag.message} (${location}${source})`;
+    });
+    const trimmed = entries.length > MAX_DIAGNOSTICS_PER_FILE ? "  - \u2026" : "";
+    return [`\u2022 ${rel}`, ...lines, trimmed].filter(Boolean).join("\n");
+  }).join("\n");
+}
+function formatDiagnosticsForBackgroundEvent(diagnostics, cwd) {
+  return diagnostics.map(({ path: filePath, diagnostics: entries }) => {
+    const rel = path6.relative(cwd, filePath) || filePath;
+    const lines = entries.slice(0, MAX_DIAGNOSTICS_PER_FILE).map((diag) => {
+      const { line, character } = diag.range.start;
+      const location = `${line + 1}:${character + 1}`;
+      const source = diag.source ? ` \xB7 ${diag.source}` : "";
+      return `  - [${diag.severity.toUpperCase()}] ${diag.message} (${location}${source})`;
+    });
+    const trimmed = entries.length > MAX_DIAGNOSTICS_PER_FILE ? "  - \u2026" : "";
+    return [`\u2022 ${rel}`, ...lines, trimmed].filter(Boolean).join("\n");
+  }).join("\n");
+}
+function filterBySeverity(diagnostics, minSeverity = "error") {
+  const severityOrder = {
+    error: 0,
+    warning: 1,
+    info: 2,
+    hint: 3
+  };
+  const threshold = severityOrder[minSeverity];
+  return diagnostics.map((file) => ({
+    ...file,
+    diagnostics: file.diagnostics.filter(
+      (diag) => severityOrder[diag.severity] <= threshold
+    )
+  })).filter((file) => file.diagnostics.length > 0);
+}
+function summarizeDiagnostics(diagnostics) {
+  let errorCount = 0;
+  let warningCount = 0;
+  let infoCount = 0;
+  let hintCount = 0;
+  for (const file of diagnostics) {
+    for (const diag of file.diagnostics) {
+      switch (diag.severity) {
+        case "error":
+          errorCount++;
+          break;
+        case "warning":
+          warningCount++;
+          break;
+        case "info":
+          infoCount++;
+          break;
+        case "hint":
+          hintCount++;
+          break;
+      }
+    }
+  }
+  return {
+    fileCount: diagnostics.length,
+    errorCount,
+    warningCount,
+    infoCount,
+    hintCount,
+    totalCount: errorCount + warningCount + infoCount + hintCount
+  };
+}
+function formatDiagnosticsWithSummary(diagnostics, cwd, options = {}) {
+  const filtered = options.minSeverity ? filterBySeverity(diagnostics, options.minSeverity) : diagnostics;
+  if (filtered.length === 0) {
+    return "No diagnostics found.";
+  }
+  const summary = summarizeDiagnostics(filtered);
+  const maxPerFile = options.maxPerFile ?? MAX_DIAGNOSTICS_PER_FILE;
+  const header = `LSP Diagnostics Summary: ${summary.errorCount} error${summary.errorCount !== 1 ? "s" : ""}, ${summary.warningCount} warning${summary.warningCount !== 1 ? "s" : ""} across ${summary.fileCount} file${summary.fileCount !== 1 ? "s" : ""}`;
+  const details = filtered.map(({ path: filePath, diagnostics: entries }) => {
+    const rel = path6.relative(cwd, filePath) || filePath;
+    const lines = entries.slice(0, maxPerFile).map((diag) => {
+      const { line, character } = diag.range.start;
+      const location = `${line + 1}:${character + 1}`;
+      const source = diag.source ? ` \xB7 ${diag.source}` : "";
+      return `  - [${diag.severity.toUpperCase()}] ${diag.message} (${location}${source})`;
+    });
+    const trimmed = entries.length > maxPerFile ? `  - \u2026 (${entries.length - maxPerFile} more)` : "";
+    return [`\u2022 ${rel}`, ...lines, trimmed].filter(Boolean).join("\n");
+  }).join("\n");
+  return `${header}
+
+${details}`;
+}
+
+// src/lsp/bridge.ts
+import * as path7 from "path";
+var LspDiagnosticsBridge = class {
+  constructor(options) {
+    this.options = options;
+    this.manager = new LspManager(options);
+  }
+  manager;
+  attached = /* @__PURE__ */ new WeakSet();
+  attach(thread) {
+    if (this.attached.has(thread)) {
+      return () => {
+      };
+    }
+    this.attached.add(thread);
+    const unsubscribe = thread.onEvent((event) => {
+      if (event.type !== "item.completed") {
+        return;
+      }
+      if (event.item.type === "file_change") {
+        const targets = event.item.changes.filter((change) => change.kind !== "delete").map((change) => path7.resolve(this.options.workingDirectory, change.path));
+        if (targets.length === 0) {
+          return;
+        }
+        void this.processDiagnostics(thread, targets);
+        return;
+      }
+      if (event.item.type === "mcp_tool_call") {
+        const targets = extractReadFileTargets(event.item, this.options.workingDirectory);
+        if (targets.length === 0) {
+          return;
+        }
+        void this.processDiagnostics(thread, targets);
+      }
+    });
+    return () => {
+      this.attached.delete(thread);
+      unsubscribe();
+    };
+  }
+  async dispose() {
+    await this.manager.dispose();
+  }
+  async processDiagnostics(thread, files) {
+    try {
+      const diagnostics = await this.manager.collectDiagnostics(files);
+      if (diagnostics.length === 0) {
+        return;
+      }
+      const summary = formatDiagnosticsForBackgroundEvent(
+        diagnostics,
+        this.options.workingDirectory
+      );
+      console.log(`
+\u{1F4DF} LSP diagnostics detected:
+${summary}
+`);
+      try {
+        await thread.sendBackgroundEvent(`LSP diagnostics detected:
+${summary}`);
+      } catch {
+      }
+    } catch (error) {
+      console.warn("[lsp] failed to collect diagnostics", error);
+    }
+  }
+};
+function extractReadFileTargets(item, cwd) {
+  if (item.type !== "mcp_tool_call") {
+    return [];
+  }
+  const toolName = item.tool?.toLowerCase?.();
+  if (toolName !== "read_file" && toolName !== "read_file_v2") {
+    return [];
+  }
+  let args = item.arguments;
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return [];
+    }
+  }
+  if (!args || typeof args !== "object") {
+    return [];
+  }
+  const filePath = args.file_path ?? args.path;
+  if (typeof filePath !== "string" || filePath.trim().length === 0) {
+    return [];
+  }
+  const resolved = path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+  return [resolved];
+}
+
+// src/lsp/hooks.ts
+function attachLspDiagnostics(thread, options) {
+  const bridge = new LspDiagnosticsBridge(options);
+  const detach = bridge.attach(thread);
+  return () => {
+    detach();
+    void bridge.dispose().catch((error) => {
+      console.warn("Failed to dispose LSP bridge", error);
+    });
+  };
+}
+
+// src/thread.ts
+import * as fs5 from "fs";
+import * as path9 from "path";
+
+// src/events/convert.ts
+function convertRustEventToThreadEvent(rustEvent) {
+  if (rustEvent?.ThreadStarted) {
+    return {
+      type: "thread.started",
+      thread_id: rustEvent.ThreadStarted.thread_id
+    };
+  }
+  if (rustEvent?.TurnStarted) {
+    return { type: "turn.started" };
+  }
+  if (rustEvent?.TurnCompleted) {
+    return {
+      type: "turn.completed",
+      usage: rustEvent.TurnCompleted.usage
+    };
+  }
+  if (rustEvent?.TurnFailed) {
+    return {
+      type: "turn.failed",
+      error: rustEvent.TurnFailed.error
+    };
+  }
+  if (rustEvent?.ItemStarted) {
+    return {
+      type: "item.started",
+      item: rustEvent.ItemStarted.item
+    };
+  }
+  if (rustEvent?.ItemUpdated) {
+    return {
+      type: "item.updated",
+      item: rustEvent.ItemUpdated.item
+    };
+  }
+  if (rustEvent?.ItemCompleted) {
+    return {
+      type: "item.completed",
+      item: rustEvent.ItemCompleted.item
+    };
+  }
+  if (rustEvent?.Error) {
+    return {
+      type: "error",
+      message: rustEvent.Error.message
+    };
+  }
+  if (rustEvent?.BackgroundEvent) {
+    return {
+      type: "background_event",
+      message: rustEvent.BackgroundEvent.message
+    };
+  }
+  if (rustEvent?.type === "background_event" && typeof rustEvent.message === "string") {
+    return {
+      type: "background_event",
+      message: rustEvent.message
+    };
+  }
+  if (rustEvent?.type === "plan_update_scheduled" && rustEvent.plan) {
+    const planData = rustEvent.plan;
+    const planItems = planData.plan || [];
+    return {
+      type: "item.completed",
+      item: {
+        id: `plan-${Date.now()}`,
+        type: "todo_list",
+        items: planItems.map((item) => ({
+          text: item.step,
+          completed: item.status === "completed"
+        }))
+      }
+    };
+  }
+  if (rustEvent?.type) {
+    return rustEvent;
+  }
+  return rustEvent;
+}
+
+// src/outputSchemaFile.ts
+import { promises as fs4 } from "fs";
+import os from "os";
+import path8 from "path";
+function normalizeOutputSchema(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  if (isJsonObject(schema) && (schema.type === "json_schema" || schema.type === "json-schema") && isJsonObject(schema.json_schema) && isJsonObject(schema.json_schema.schema)) {
+    const strict = typeof schema.json_schema.strict === "boolean" ? schema.json_schema.strict : true;
+    return normalizeJsonSchemaObject(schema.json_schema.schema, strict);
+  }
+  if (isJsonObject(schema) && isJsonObject(schema.schema)) {
+    const strict = typeof schema.strict === "boolean" ? schema.strict : true;
+    return normalizeJsonSchemaObject(schema.schema, strict);
+  }
+  if (!isJsonObject(schema)) {
+    throw new Error(
+      "outputSchema must be a plain JSON object or an OpenAI-style json_schema wrapper"
+    );
+  }
+  return normalizeJsonSchemaObject(schema, true);
+}
+async function createOutputSchemaFile(schema) {
+  const normalizedSchema = normalizeOutputSchema(schema);
+  if (!normalizedSchema) {
+    return { cleanup: async () => {
+    } };
+  }
+  const schemaDir = await fs4.mkdtemp(path8.join(os.tmpdir(), "codex-output-schema-"));
+  const schemaPath = path8.join(schemaDir, "schema.json");
+  const cleanup = async () => {
+    try {
+      await fs4.rm(schemaDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    await fs4.writeFile(schemaPath, JSON.stringify(normalizedSchema), "utf8");
+    return { schemaPath, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeJsonSchemaObject(schema, strict) {
+  const record = { ...schema };
+  const hasExplicitAdditional = typeof record.additionalProperties === "boolean" || typeof record.additionalProperties === "object";
+  const additionalProperties = hasExplicitAdditional ? record.additionalProperties : strict ? false : record.additionalProperties;
+  return {
+    ...record,
+    ...hasExplicitAdditional || strict ? { additionalProperties } : {}
+  };
+}
+
+// src/thread.ts
+var UNTRUSTED_DIRECTORY_ERROR = "Not inside a trusted directory and --skip-git-repo-check was not specified.";
+function findGitRoot(startDir) {
+  let current = path9.resolve(startDir);
+  while (true) {
+    const gitPath = path9.join(current, ".git");
+    if (fs5.existsSync(gitPath)) {
+      try {
+        const stats = fs5.statSync(gitPath);
+        if (stats.isDirectory() || stats.isFile()) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path9.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+function assertTrustedDirectory(workingDirectory) {
+  const directory = workingDirectory ? path9.resolve(workingDirectory) : process.cwd();
+  if (!findGitRoot(directory)) {
+    throw new Error(UNTRUSTED_DIRECTORY_ERROR);
+  }
+}
+var Thread = class _Thread {
+  _exec;
+  _options;
+  _id;
+  _threadOptions;
+  _eventListeners = [];
+  _approvalHandler = null;
+  /** Returns the ID of the thread. Populated after the first turn starts. */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Register an event listener for thread events.
+   * @param listener Callback function that receives ThreadEvent objects
+   * @returns Unsubscribe function to remove the listener
+   */
+  onEvent(listener) {
+    this._eventListeners.push(listener);
+    return () => {
+      const index = this._eventListeners.indexOf(listener);
+      if (index !== -1) {
+        this._eventListeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Remove an event listener.
+   * @param listener The listener function to remove
+   */
+  offEvent(listener) {
+    const index = this._eventListeners.indexOf(listener);
+    if (index !== -1) {
+      this._eventListeners.splice(index, 1);
+    }
+  }
+  /**
+   * Register a callback to handle approval requests from the agent.
+   * The handler should return true to approve the action, false to deny it.
+   *
+   * @param handler Callback function that receives ApprovalRequest and returns approval decision
+   * @example
+   * ```typescript
+   * thread.onApprovalRequest(async (request) => {
+   *   console.log(`Approval requested for ${request.type}`);
+   *   return true; // Auto-approve
+   * });
+   * ```
+   */
+  onApprovalRequest(handler) {
+    this._approvalHandler = handler;
+    const binding = getNativeBinding();
+    if (binding && typeof binding.registerApprovalCallback === "function") {
+      binding.registerApprovalCallback(handler);
+    }
+  }
+  /**
+   * Emit a background notification while the agent is running the current turn.
+   * The message is surfaced to event subscribers but does not modify the user input queue.
+   *
+   * @throws Error if the thread has not been started yet.
+   */
+  async sendBackgroundEvent(message) {
+    const trimmed = message?.toString();
+    if (!trimmed || trimmed.trim().length === 0) {
+      throw new Error("Background event message must be a non-empty string");
+    }
+    if (!this._id) {
+      throw new Error("Cannot emit a background event before the thread has started");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.emitBackgroundEvent !== "function") {
+      throw new Error("emitBackgroundEvent is not available in this build");
+    }
+    await binding.emitBackgroundEvent({ threadId: this._id, message: trimmed });
+  }
+  /**
+   * Programmatically update the agent's plan/todo list.
+   * The plan will be applied at the start of the next turn.
+   *
+   * @param args The plan update arguments
+   * @throws Error if no thread ID is available
+   */
+  updatePlan(args) {
+    if (!this._id) {
+      throw new Error("Cannot update plan: no active thread");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.emitPlanUpdate !== "function") {
+      throw new Error("emitPlanUpdate is not available in this build");
+    }
+    binding.emitPlanUpdate({
+      threadId: this._id,
+      explanation: args.explanation,
+      plan: args.plan
+    });
+  }
+  /**
+   * Modify the agent's plan/todo list with granular operations.
+   * Changes will be applied at the start of the next turn.
+   *
+   * @param operations Array of operations to perform on the plan
+   * @throws Error if no thread ID is available
+   */
+  modifyPlan(operations) {
+    if (!this._id) {
+      throw new Error("Cannot modify plan: no active thread");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.modifyPlan !== "function") {
+      throw new Error("modifyPlan is not available in this build");
+    }
+    binding.modifyPlan({
+      threadId: this._id,
+      operations
+    });
+  }
+  /**
+   * Add a new todo item to the agent's plan.
+   *
+   * @param step The todo step description
+   * @param status The initial status (defaults to "pending")
+   */
+  addTodo(step, status = "pending") {
+    this.modifyPlan([{ type: "add", item: { step, status } }]);
+  }
+  /**
+   * Update an existing todo item.
+   *
+   * @param index The index of the todo item to update
+   * @param updates The updates to apply
+   */
+  updateTodo(index, updates) {
+    this.modifyPlan([{ type: "update", index, updates }]);
+  }
+  /**
+   * Remove a todo item from the plan.
+   *
+   * @param index The index of the todo item to remove
+   */
+  removeTodo(index) {
+    this.modifyPlan([{ type: "remove", index }]);
+  }
+  /**
+   * Reorder the todo items in the plan.
+   *
+   * @param newOrder Array of indices representing the new order
+   */
+  reorderTodos(newOrder) {
+    this.modifyPlan([{ type: "reorder", newOrder }]);
+  }
+  /** Compacts the conversation history for this thread using Codex's builtin compaction. */
+  async compact() {
+    const skipGitRepoCheck = this._threadOptions?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory(this._threadOptions?.workingDirectory);
+    }
+    const events = await this._exec.compact({
+      input: "compact",
+      threadId: this._id,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      model: this._threadOptions?.model ?? this._options.defaultModel,
+      sandboxMode: this._threadOptions?.sandboxMode,
+      approvalMode: this._threadOptions?.approvalMode,
+      workspaceWriteOptions: this._threadOptions?.workspaceWriteOptions,
+      workingDirectory: this._threadOptions?.workingDirectory,
+      skipGitRepoCheck,
+      modelProvider: this._options.modelProvider
+    });
+    if (!Array.isArray(events)) {
+      throw new Error("Compact did not return event list");
+    }
+  }
+  /**
+   * Fork this thread at the specified user message, returning a new thread that starts
+   * from the conversation history prior to that message.
+   *
+   * @param options Fork configuration including which user message to branch before and optional thread overrides.
+   */
+  async fork(options) {
+    if (!this._id) {
+      throw new Error("Cannot fork: no active thread");
+    }
+    const nthUserMessage = options?.nthUserMessage;
+    if (typeof nthUserMessage !== "number" || !Number.isInteger(nthUserMessage) || nthUserMessage < 0) {
+      throw new Error("nthUserMessage must be a non-negative integer");
+    }
+    const overrides = options.threadOptions ?? {};
+    const nextThreadOptions = {
+      ...this._threadOptions,
+      ...overrides
+    };
+    const skipGitRepoCheck = nextThreadOptions.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    nextThreadOptions.skipGitRepoCheck = skipGitRepoCheck;
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory(nextThreadOptions.workingDirectory);
+    }
+    const forkArgs = {
+      threadId: this._id,
+      nthUserMessage,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      model: nextThreadOptions.model ?? this._options.defaultModel,
+      oss: nextThreadOptions.oss,
+      sandboxMode: nextThreadOptions.sandboxMode,
+      approvalMode: nextThreadOptions.approvalMode,
+      workspaceWriteOptions: nextThreadOptions.workspaceWriteOptions,
+      workingDirectory: nextThreadOptions.workingDirectory,
+      skipGitRepoCheck,
+      fullAuto: nextThreadOptions.fullAuto,
+      modelProvider: this._options.modelProvider
+    };
+    const result = await this._exec.fork(forkArgs);
+    return new _Thread(
+      this._exec,
+      this._options,
+      nextThreadOptions,
+      result.threadId
+    );
+  }
+  /* @internal */
+  constructor(exec, options, threadOptions, id = null) {
+    this._exec = exec;
+    this._options = options;
+    this._id = id;
+    this._threadOptions = threadOptions;
+  }
+  /** Provides the input to the agent and streams events as they are produced during the turn. */
+  async runStreamed(input, turnOptions = {}) {
+    return { events: this.runStreamedInternal(input, turnOptions, false) };
+  }
+  async *runStreamedInternal(input, turnOptions = {}, emitRawEvents = true) {
+    const normalizedSchema = normalizeOutputSchema(turnOptions.outputSchema);
+    const needsSchemaFile = this._exec.requiresOutputSchemaFile();
+    const schemaFile = needsSchemaFile ? await createOutputSchemaFile(normalizedSchema) : { schemaPath: void 0, cleanup: async () => {
+    } };
+    const options = this._threadOptions;
+    const { prompt, images } = normalizeInput(input);
+    const skipGitRepoCheck = options?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory(options?.workingDirectory);
+    }
+    const generator = this._exec.run({
+      input: prompt,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      threadId: this._id,
+      images,
+      model: options?.model,
+      oss: turnOptions?.oss ?? options?.oss,
+      sandboxMode: options?.sandboxMode,
+      approvalMode: options?.approvalMode,
+      workspaceWriteOptions: options?.workspaceWriteOptions,
+      workingDirectory: options?.workingDirectory,
+      skipGitRepoCheck,
+      outputSchemaFile: schemaFile.schemaPath,
+      outputSchema: normalizedSchema,
+      fullAuto: options?.fullAuto
+    });
+    try {
+      for await (const item of generator) {
+        let parsed;
+        try {
+          parsed = JSON.parse(item);
+        } catch (error) {
+          throw new Error(`Failed to parse item: ${item}. Parse error: ${error}`);
+        }
+        if (parsed === null) {
+          continue;
+        }
+        if (emitRawEvents) {
+          yield { type: "raw_event", raw: parsed };
+        }
+        const threadEvent = convertRustEventToThreadEvent(parsed);
+        if (threadEvent.type === "thread.started") {
+          this._id = threadEvent.thread_id;
+        }
+        for (const listener of this._eventListeners) {
+          try {
+            listener(threadEvent);
+          } catch (error) {
+            console.warn("Thread event listener threw error:", error);
+          }
+        }
+        yield threadEvent;
+      }
+    } finally {
+      await schemaFile.cleanup();
+    }
+  }
+  /** Provides the input to the agent and returns the completed turn. */
+  async run(input, turnOptions = {}) {
+    const generator = this.runStreamedInternal(input, turnOptions, true);
+    const items = [];
+    let finalResponse = "";
+    let usage = null;
+    let turnFailure = null;
+    for await (const event of generator) {
+      if (event.type === "item.completed") {
+        if (event.item.type === "agent_message") {
+          finalResponse = event.item.text;
+        }
+        items.push(event.item);
+      } else if (event.type === "turn.completed") {
+        usage = event.usage;
+      } else if (event.type === "turn.failed") {
+        turnFailure = event.error;
+        break;
+      }
+    }
+    if (turnFailure) {
+      throw new Error(turnFailure.message);
+    }
+    return { items, finalResponse, usage };
+  }
+  buildTuiRequest(overrides = {}) {
+    const skipGitRepoCheck = this._threadOptions?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory(this._threadOptions?.workingDirectory);
+    }
+    const request = { ...overrides };
+    const assignIfUndefined = (key, value) => {
+      if (request[key] === void 0 && value !== void 0) {
+        request[key] = value;
+      }
+    };
+    assignIfUndefined("model", this._threadOptions?.model ?? this._options.defaultModel);
+    assignIfUndefined("oss", this._threadOptions?.oss);
+    assignIfUndefined("sandboxMode", this._threadOptions?.sandboxMode);
+    assignIfUndefined("approvalMode", this._threadOptions?.approvalMode);
+    assignIfUndefined("fullAuto", this._threadOptions?.fullAuto);
+    assignIfUndefined("workingDirectory", this._threadOptions?.workingDirectory);
+    assignIfUndefined("baseUrl", this._options.baseUrl);
+    assignIfUndefined("apiKey", this._options.apiKey);
+    if (request.resumeSessionId === void 0 && request.resumePicker !== true && request.resumeLast !== true && this._id) {
+      request.resumeSessionId = this._id;
+    }
+    return request;
+  }
+  /**
+   * Launches the interactive Codex TUI (Terminal User Interface) for this thread and returns a session handle.
+   *
+   * The handle allows advanced workflows where the TUI can be started and stopped programmatically,
+   * while preserving the underlying conversation state.
+   */
+  launchTui(overrides = {}) {
+    const request = this.buildTuiRequest(overrides);
+    const detachLsp = this.attachDefaultLspBridge(request);
+    const session = startTui(request);
+    return this.wrapTuiSession(session, detachLsp);
+  }
+  /**
+   * Launches the interactive Codex TUI (Terminal User Interface) for this thread.
+   *
+   * This method enables seamless transition from programmatic agent interaction to
+   * interactive terminal chat within the same session. The TUI takes over the terminal
+   * and allows you to continue the conversation interactively.
+   *
+   * @param overrides - Optional configuration to override thread defaults. Supports all TUI options
+   *                    including prompt, sandbox mode, approval mode, and resume options.
+   * @param options - Optional run options including an AbortSignal to request shutdown.
+   * @returns A Promise that resolves to TUI exit information including:
+   *          - tokenUsage: Token consumption statistics
+   *          - conversationId: Session ID for resuming later
+   *          - updateAction: Optional suggested update command
+   * @throws {Error} If not in a trusted git repository (unless skipGitRepoCheck is set)
+   * @throws {Error} If the terminal is not interactive (TTY required)
+   */
+  async tui(overrides = {}, options = {}) {
+    const request = this.buildTuiRequest(overrides);
+    const detachLsp = this.attachDefaultLspBridge(request);
+    try {
+      return await runTui(request, options);
+    } finally {
+      detachLsp();
+    }
+  }
+  wrapTuiSession(session, cleanup) {
+    let released = false;
+    const release = () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      cleanup();
+    };
+    return {
+      wait: async () => {
+        try {
+          return await session.wait();
+        } finally {
+          release();
+        }
+      },
+      shutdown: () => {
+        release();
+        session.shutdown();
+      },
+      get closed() {
+        return session.closed;
+      }
+    };
+  }
+  attachDefaultLspBridge(request) {
+    const workingDirectory = request.workingDirectory ?? this._threadOptions?.workingDirectory ?? (typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".");
+    return attachLspDiagnostics(this, {
+      workingDirectory,
+      waitForDiagnostics: true
+    });
+  }
+};
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { prompt: input, images: [] };
+  }
+  const promptParts = [];
+  const images = [];
+  for (const item of input) {
+    if (item.type === "text") {
+      promptParts.push(item.text);
+    } else if (item.type === "local_image") {
+      images.push(item.path);
+    }
+  }
+  return { prompt: promptParts.join("\n\n"), images };
+}
+
+// src/exec.ts
+var CodexExec = class {
+  native;
+  constructor() {
+    const nativeBinding = getNativeBinding();
+    if (!nativeBinding) {
+      throw new Error(
+        "Native NAPI binding not available. Make sure @openai/codex-native is properly installed and built."
+      );
+    }
+    this.native = nativeBinding;
+  }
+  requiresOutputSchemaFile() {
+    return false;
+  }
+  async *run(args) {
+    const binding = this.native;
+    const queue = new AsyncQueue();
+    validateModel(args.model, args.oss === true);
+    const request = {
+      prompt: args.input,
+      threadId: args.threadId ?? void 0,
+      images: args.images && args.images.length > 0 ? args.images : void 0,
+      model: args.model,
+      oss: args.oss,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      sandboxMode: args.sandboxMode,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      outputSchema: args.outputSchema,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      modelProvider: args.modelProvider,
+      fullAuto: args.fullAuto,
+      reviewMode: args.review ? true : void 0,
+      reviewHint: args.review?.userFacingHint
+    };
+    let runPromise = Promise.resolve();
+    try {
+      runPromise = binding.runThreadStream(request, (err, eventJson) => {
+        if (err) {
+          queue.fail(err);
+          return;
+        }
+        try {
+          queue.push(eventJson ?? "null");
+        } catch (error) {
+          queue.fail(error);
+        }
+      }).then(
+        () => {
+          queue.end();
+        },
+        (error) => {
+          queue.fail(error);
+        }
+      );
+    } catch (error) {
+      queue.fail(error);
+      throw error;
+    }
+    let loopError;
+    try {
+      for await (const value of queue) {
+        yield value;
+      }
+      await runPromise;
+    } catch (error) {
+      loopError = error;
+      throw error;
+    } finally {
+      queue.end();
+      if (loopError) {
+        await runPromise.catch(() => {
+        });
+      }
+    }
+  }
+  async compact(args) {
+    validateModel(args.model, args.oss === true);
+    const request = {
+      prompt: args.input,
+      threadId: args.threadId ?? void 0,
+      images: args.images && args.images.length > 0 ? args.images : void 0,
+      model: args.model,
+      modelProvider: args.modelProvider,
+      oss: args.oss,
+      sandboxMode: args.sandboxMode,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      outputSchema: args.outputSchema,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      fullAuto: args.fullAuto,
+      reviewMode: args.review ? true : void 0,
+      reviewHint: args.review?.userFacingHint
+    };
+    return this.native.compactThread(request);
+  }
+  async fork(args) {
+    if (!args.threadId) {
+      throw new Error("threadId is required to fork a conversation");
+    }
+    const request = {
+      threadId: args.threadId,
+      nthUserMessage: args.nthUserMessage,
+      model: args.model,
+      oss: args.oss,
+      sandboxMode: args.sandboxMode,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      modelProvider: args.modelProvider,
+      linuxSandboxPath: args.linuxSandboxPath,
+      fullAuto: args.fullAuto
+    };
+    return this.native.forkThread(request);
+  }
+  async listConversations(request) {
+    return this.native.listConversations(request);
+  }
+  async deleteConversation(request) {
+    return this.native.deleteConversation(request);
+  }
+  async resumeConversationFromRollout(request) {
+    return this.native.resumeConversationFromRollout(request);
+  }
+};
+var AsyncQueue = class {
+  buffer = [];
+  waiters = [];
+  ended = false;
+  error;
+  push(value) {
+    if (this.ended) return;
+    if (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter.resolve({ value, done: false });
+      return;
+    }
+    this.buffer.push(value);
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(error) {
+    if (this.ended) return;
+    this.error = error;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.reject(error);
+    }
+  }
+  async next() {
+    if (this.buffer.length > 0) {
+      const value = this.buffer.shift();
+      return { value, done: false };
+    }
+    if (this.error) {
+      return Promise.reject(this.error);
+    }
+    if (this.ended) {
+      return { value: void 0, done: true };
+    }
+    return new Promise((resolve5, reject) => {
+      this.waiters.push({ resolve: resolve5, reject });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+function validateModel(model, oss) {
+  if (!model) return;
+  const trimmed = String(model).trim();
+  if (oss) {
+    if (!trimmed.startsWith("gpt-oss:")) {
+      throw new Error(
+        `Invalid model "${trimmed}" for OSS mode. Use models prefixed with "gpt-oss:", e.g. "gpt-oss:20b".`
+      );
+    }
+    return;
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    // GPT models
+    "gpt-5",
+    "gpt-5-codex",
+    "gpt-5-codex-mini",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-mini",
+    // Claude models
+    "claude-sonnet-4-5-20250929",
+    "claude-sonnet-4-20250514",
+    "claude-opus-4-20250514"
+  ]);
+  if (!allowed.has(trimmed) && !trimmed.startsWith("claude-") && !trimmed.startsWith("gpt-")) {
+    throw new Error(
+      `Invalid model "${trimmed}". Supported models: ${Array.from(allowed).map((m) => `"${m}"`).join(", ")}, or any model starting with "claude-" or "gpt-".`
+    );
+  }
+}
+
+// src/reviewOptions.ts
+function buildReviewPrompt(target) {
+  switch (target.type) {
+    case "current_changes":
+      return {
+        prompt: "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.",
+        hint: "current changes"
+      };
+    case "branch": {
+      const branch = target.baseBranch;
+      const prompt = `Review the code changes against the base branch '${branch}'. Start by finding the merge diff between the current branch and ${branch}'s upstream e.g. (\`git merge-base HEAD "$(git rev-parse --abbrev-ref "${branch}@{upstream}")"\`), then run \`git diff\` against that SHA to see what changes we would merge into the ${branch} branch. Provide prioritized, actionable findings.`;
+      return {
+        prompt,
+        hint: `changes against '${branch}'`
+      };
+    }
+    case "commit": {
+      const shortSha = target.sha.slice(0, 7);
+      const subject = target.subject ?? target.sha;
+      return {
+        prompt: `Review the code changes introduced by commit ${target.sha} ("${subject}"). Provide prioritized, actionable findings.`,
+        hint: `commit ${shortSha}`
+      };
+    }
+    case "custom": {
+      const hint = target.hint ?? "custom review";
+      return {
+        prompt: target.prompt,
+        hint
+      };
+    }
+    default: {
+      const exhaustive = target;
+      throw new Error(`Unsupported review target: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/codex.ts
+var Codex = class {
+  exec;
+  options;
+  nativeBinding;
+  lspForTools;
+  constructor(options = {}) {
+    const predefinedTools = options.tools ? [...options.tools] : [];
+    const preserveRegisteredTools = options.preserveRegisteredTools === true;
+    this.nativeBinding = getNativeBinding();
+    this.options = { ...options, tools: [] };
+    if (this.nativeBinding) {
+      if (!preserveRegisteredTools && typeof this.nativeBinding.clearRegisteredTools === "function") {
+        this.nativeBinding.clearRegisteredTools();
+      }
+      for (const tool of predefinedTools) {
+        this.registerTool(tool);
+      }
+    }
+    this.lspForTools = this.createLspManagerForTools();
+    if (this.lspForTools && this.nativeBinding) {
+      this.registerDefaultReadFileInterceptor();
+    }
+    this.exec = new CodexExec();
+  }
+  /**
+   * Register a tool for Codex. When `tool.name` matches a built-in Codex tool,
+   * the native implementation is replaced for this Codex instance.
+   */
+  registerTool(tool) {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool registration requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.registerTool !== "function") {
+      console.warn("registerTool is not available in this build - tools feature may be incomplete");
+      return;
+    }
+    const { handler, ...info } = tool;
+    this.nativeBinding.registerTool(info, handler);
+    if (!this.options.tools) {
+      this.options.tools = [];
+    }
+    this.options.tools.push(tool);
+  }
+  /**
+   * Register a tool interceptor for Codex. Interceptors can modify tool invocations
+   * and results, and can call the built-in implementation.
+   */
+  registerToolInterceptor(toolName, handler) {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool interceptor registration requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.registerToolInterceptor !== "function" || typeof this.nativeBinding.callToolBuiltin !== "function") {
+      console.warn("registerToolInterceptor is not available in this build - interceptor feature may be incomplete");
+      return;
+    }
+    this.nativeBinding.registerToolInterceptor(toolName, async (...args) => {
+      const context = args.length === 1 ? args[0] : args[1];
+      if (!context || typeof context !== "object") {
+        throw new Error("Native interceptor callback did not receive a context object");
+      }
+      const { invocation, token } = context;
+      const callBuiltin = (override) => this.nativeBinding.callToolBuiltin(token, override ?? invocation);
+      return handler({ invocation, callBuiltin });
+    });
+  }
+  /**
+   * Clear all registered tools, restoring built-in defaults.
+   */
+  clearTools() {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool management requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.clearRegisteredTools === "function") {
+      this.nativeBinding.clearRegisteredTools();
+    }
+    if (this.options.tools) {
+      this.options.tools = [];
+    }
+  }
+  buildConversationConfig(options = {}) {
+    return {
+      model: options.model ?? this.options.defaultModel,
+      modelProvider: options.modelProvider ?? this.options.modelProvider,
+      oss: options.oss,
+      sandboxMode: options.sandboxMode,
+      approvalMode: options.approvalMode,
+      workspaceWriteOptions: options.workspaceWriteOptions,
+      workingDirectory: options.workingDirectory,
+      skipGitRepoCheck: options.skipGitRepoCheck,
+      reasoningEffort: options.reasoningEffort,
+      reasoningSummary: options.reasoningSummary,
+      fullAuto: options.fullAuto,
+      baseUrl: this.options.baseUrl,
+      apiKey: this.options.apiKey
+    };
+  }
+  createLspManagerForTools() {
+    const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+    const options = {
+      workingDirectory: cwd,
+      waitForDiagnostics: true
+    };
+    try {
+      return new LspManager(options);
+    } catch {
+      return null;
+    }
+  }
+  registerDefaultReadFileInterceptor() {
+    if (!this.lspForTools) {
+      return;
+    }
+    try {
+      this.registerToolInterceptor("read_file", async ({ invocation, callBuiltin }) => {
+        let base;
+        try {
+          base = await callBuiltin();
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+            output: void 0
+          };
+        }
+        if (!base.output || base.success === false) {
+          return base;
+        }
+        let filePath;
+        if (invocation.arguments) {
+          try {
+            const args = JSON.parse(invocation.arguments);
+            const candidate = typeof args.file_path === "string" && args.file_path || typeof args.path === "string" && args.path || void 0;
+            if (candidate && candidate.trim().length > 0) {
+              filePath = candidate;
+            }
+          } catch {
+          }
+        }
+        if (!filePath) {
+          return base;
+        }
+        let diagnosticsText = "";
+        try {
+          const results = await this.lspForTools.collectDiagnostics([filePath]);
+          if (!results.length) {
+            return base;
+          }
+          diagnosticsText = formatDiagnosticsForTool(results);
+        } catch {
+          return base;
+        }
+        if (!diagnosticsText) {
+          return base;
+        }
+        const header = `LSP diagnostics for ${filePath}:
+${diagnosticsText}`;
+        return prependSystemHintToToolResult(base, header);
+      });
+    } catch {
+    }
+  }
+  /**
+   * Register a programmatic approval callback that Codex will call before executing
+   * sensitive operations (e.g., shell commands, file writes).
+   */
+  setApprovalCallback(handler) {
+    if (!this.nativeBinding || typeof this.nativeBinding.registerApprovalCallback !== "function") {
+      console.warn("Approval callback is not available in this build");
+      return;
+    }
+    this.nativeBinding.registerApprovalCallback(handler);
+  }
+  /**
+   * Starts a new conversation with an agent.
+   * @returns A new thread instance.
+   */
+  startThread(options = {}) {
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions);
+  }
+  /**
+   * Resumes a conversation with an agent based on the thread id.
+   * Threads are persisted in ~/.codex/sessions.
+   *
+   * @param id The id of the thread to resume.
+   * @returns A new thread instance.
+   */
+  resumeThread(id, options = {}) {
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions, id);
+  }
+  async listConversations(options = {}) {
+    const request = {
+      config: this.buildConversationConfig(options),
+      pageSize: options.pageSize,
+      cursor: options.cursor,
+      modelProviders: options.modelProviders
+    };
+    return this.exec.listConversations(request);
+  }
+  async deleteConversation(id, options = {}) {
+    const result = await this.exec.deleteConversation({
+      id,
+      config: this.buildConversationConfig(options)
+    });
+    return result.deleted;
+  }
+  async resumeConversationFromRollout(rolloutPath, options = {}) {
+    const result = await this.exec.resumeConversationFromRollout({
+      rolloutPath,
+      config: this.buildConversationConfig(options)
+    });
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions, result.threadId);
+  }
+  /**
+   * Starts a review task using the built-in Codex review flow.
+   */
+  async review(options) {
+    const generator = this.reviewStreamedInternal(options);
+    const items = [];
+    let finalResponse = "";
+    let usage = null;
+    let turnFailure = null;
+    for await (const event of generator) {
+      if (event === null) continue;
+      if (event.type === "item.completed") {
+        if (event.item.type === "agent_message") {
+          finalResponse = event.item.text;
+        }
+        items.push(event.item);
+      } else if (event.type === "exited_review_mode") {
+        if (event.review_output) {
+          const reviewOutput = event.review_output;
+          let reviewText = "";
+          if (reviewOutput.overall_explanation) {
+            reviewText += reviewOutput.overall_explanation;
+          }
+          if (reviewOutput.findings && reviewOutput.findings.length > 0) {
+            if (reviewText) reviewText += "\n\n";
+            reviewText += "## Review Findings\n\n";
+            reviewOutput.findings.forEach((finding, index) => {
+              reviewText += `### ${index + 1}. ${finding.title}
+`;
+              reviewText += `${finding.body}
+`;
+              reviewText += `**Priority:** ${finding.priority} | **Confidence:** ${finding.confidence_score}
+`;
+              reviewText += `**Location:** ${finding.code_location.absolute_file_path}:${finding.code_location.line_range.start}-${finding.code_location.line_range.end}
+
+`;
+            });
+          }
+          finalResponse = reviewText;
+        }
+      } else if (event.type === "turn.completed") {
+        usage = event.usage;
+      } else if (event.type === "turn.failed") {
+        turnFailure = event.error;
+        break;
+      }
+    }
+    if (turnFailure) {
+      throw new Error(turnFailure.message);
+    }
+    return { items, finalResponse, usage };
+  }
+  /**
+   * Starts a review task and returns the event stream.
+   */
+  async reviewStreamed(options) {
+    return { events: this.reviewStreamedInternal(options) };
+  }
+  async *reviewStreamedInternal(options) {
+    const { target, threadOptions = {}, turnOptions = {} } = options;
+    const { prompt, hint } = buildReviewPrompt(target);
+    const normalizedSchema = normalizeOutputSchema(turnOptions.outputSchema);
+    const needsSchemaFile = this.exec.requiresOutputSchemaFile();
+    const schemaFile = needsSchemaFile ? await createOutputSchemaFile(normalizedSchema) : { schemaPath: void 0, cleanup: async () => {
+    } };
+    const generator = this.exec.run({
+      input: prompt,
+      baseUrl: this.options.baseUrl,
+      apiKey: this.options.apiKey,
+      model: threadOptions.model,
+      modelProvider: threadOptions.modelProvider ?? this.options.modelProvider,
+      oss: threadOptions.oss,
+      sandboxMode: threadOptions.sandboxMode,
+      approvalMode: threadOptions.approvalMode,
+      workspaceWriteOptions: threadOptions.workspaceWriteOptions,
+      workingDirectory: threadOptions.workingDirectory,
+      skipGitRepoCheck: threadOptions.skipGitRepoCheck,
+      outputSchemaFile: schemaFile.schemaPath,
+      outputSchema: normalizedSchema,
+      fullAuto: threadOptions.fullAuto,
+      review: {
+        userFacingHint: hint
+      }
+    });
+    try {
+      for await (const item of generator) {
+        let parsed;
+        try {
+          parsed = JSON.parse(item);
+        } catch (error) {
+          throw new Error(`Failed to parse item: ${item}`, { cause: error });
+        }
+        yield parsed;
+      }
+    } finally {
+      await schemaFile.cleanup();
+    }
+  }
+};
+function prependSystemHintToToolResult(base, hint) {
+  const trimmedHint = hint.trim();
+  if (!trimmedHint) {
+    return base;
+  }
+  const existing = base.output ?? "";
+  const separator = existing.length === 0 || existing.startsWith("\n") ? "\n\n" : "\n\n";
+  const output = existing.length === 0 ? `[SYSTEM_HINT]
+${trimmedHint}` : `[SYSTEM_HINT]
+${trimmedHint}${separator}${existing}`;
+  return {
+    ...base,
+    output
+  };
+}
+
+export {
+  convertRustEventToThreadEvent,
+  getNativeBinding,
+  runApplyPatch,
+  reverieListConversations,
+  reverieSearchConversations,
+  reverieSearchSemantic,
+  reverieIndexSemantic,
+  reverieGetConversationInsights,
+  encodeToToon,
+  fastEmbedInit,
+  fastEmbedEmbed,
+  tokenizerCount,
+  tokenizerEncode,
+  tokenizerDecode,
+  collectRepoDiffSummary,
+  startTui,
+  runTui,
+  DEFAULT_SERVERS,
+  findServerForFile,
+  resolveWorkspaceRoot,
+  LspManager,
+  formatDiagnosticsForTool,
+  formatDiagnosticsForBackgroundEvent,
+  filterBySeverity,
+  summarizeDiagnostics,
+  formatDiagnosticsWithSummary,
+  LspDiagnosticsBridge,
+  attachLspDiagnostics,
+  Thread,
+  Codex
+};
+//# sourceMappingURL=chunk-ZTUGAPWF.mjs.map