@nyssance/codex-acp-v2 0.7.6 → 0.7.7

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.7.7 — 2026-10-09
+
+### Added
+
+- Independent read-only history APIs: `_codex/session_history` for paginated turns and
+  `_codex/session_history_items` for paginated items, advertised through the version 2
+  `sessionHistory` capability.
+- Browse mode for live history and export mode with optimistic consistency checks,
+  bounded response sizes, scoped cursors, cancellation, and structured errors.
+- History projections preserve media references and text annotations, with optional
+  native records and explicit omission metadata for archival and export consumers.
+
+### Fixed
+
+- Session listing includes custom-provider conversations by clearing the native
+  default model-provider filter.
+
 ## 0.7.6 — 2026-10-08
 
 ### Added

package/dist/index.js

@@ -22046,7 +22046,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.7.6",
+  version: "0.7.7",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -26888,6 +26888,255 @@ function firstLine(text2) {
   return line.length > 120 ? `${line.slice(0, 117)}...` : line;
 }
 
+// src/agent/historyProtocol.ts
+import { createHash } from "crypto";
+function historyError(reason, message, retryable, extra = {}, code = -32600) {
+  return new RequestError(code, message, { reason, retryable, ...extra });
+}
+function invalid(message) {
+  throw historyError("history_invalid_params", message, false, {}, -32602);
+}
+function parse5(raw, items) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    invalid("History params must be an object");
+  const p = raw;
+  const allowed = new Set(["sessionId", "cursor", "limit", "mode", "sortDirection", "maxBytes", "includeNative", "_meta", ...items ? ["turnId", "anchorItemId"] : ["itemsView"]]);
+  for (const key of Object.keys(p))
+    if (!allowed.has(key))
+      invalid(`Unknown history parameter: ${key}`);
+  if (typeof p["sessionId"] !== "string" || !p["sessionId"].trim())
+    invalid("sessionId must be a non-empty string");
+  if (p["cursor"] != null && (typeof p["cursor"] !== "string" || !p["cursor"] || p["cursor"].length > 65536))
+    invalid("cursor must be a non-empty history cursor or null");
+  for (const [key, min, max] of [["limit", 1, 100], ["maxBytes", 1024, 16 * 1024 * 1024]]) {
+    if (p[key] !== undefined && (typeof p[key] !== "number" || !Number.isInteger(p[key]) || p[key] < min || p[key] > max))
+      invalid(`${key} must be an integer between ${min} and ${max}`);
+  }
+  if (p["mode"] !== undefined && p["mode"] !== "browse" && p["mode"] !== "export")
+    invalid("mode must be browse or export");
+  if (p["sortDirection"] !== undefined && p["sortDirection"] !== "asc" && p["sortDirection"] !== "desc")
+    invalid("sortDirection must be asc or desc");
+  if (p["includeNative"] !== undefined && typeof p["includeNative"] !== "boolean")
+    invalid("includeNative must be a boolean");
+  if (!items && p["itemsView"] !== undefined && p["itemsView"] !== "summary" && p["itemsView"] !== "full")
+    invalid("itemsView must be summary or full");
+  if (!items && p["includeNative"] === true && p["itemsView"] !== "full")
+    invalid("includeNative requires itemsView: full; use the items endpoint for details");
+  for (const key of ["turnId", "anchorItemId"]) {
+    if (p[key] !== undefined && (typeof p[key] !== "string" || !p[key].trim()))
+      invalid(`${key} must be a non-empty string`);
+  }
+  if (p["anchorItemId"] !== undefined && (p["turnId"] === undefined || p["cursor"] != null))
+    invalid("anchorItemId requires turnId and cannot be combined with cursor");
+  return p;
+}
+function parseSessionHistoryParams(raw) {
+  return parse5(raw, false);
+}
+function parseSessionHistoryItemsParams(raw) {
+  return parse5(raw, true);
+}
+function sourceError(error40) {
+  if (error40 instanceof RequestError)
+    return error40;
+  const e = error40 && typeof error40 === "object" ? error40 : {};
+  const message = error40 instanceof Error ? error40.message : String(error40);
+  const native = { code: e["code"] ?? null, data: e["data"] ?? null };
+  const code = typeof e["code"] === "number" ? e["code"] : -32603;
+  if (/thread not found|no rollout found for thread|unknown thread/i.test(message))
+    return historyError("history_not_found", message, false, { native }, code);
+  if (code === -32602 && /cursor/i.test(message))
+    return historyError("history_invalid_cursor", message, false, { native }, code);
+  if (code === -32602)
+    return historyError("history_invalid_params", message, false, { native }, code);
+  if (code === -32601)
+    return historyError("history_unsupported", message, false, { native }, code);
+  if (["ECONNRESET", "EPIPE", "ETIMEDOUT", "ECONNREFUSED"].includes(String(e["code"])))
+    return historyError("history_unavailable", message, true, { native }, code);
+  return historyError("history_source_error", message, null, { native }, code);
+}
+
+class HistoryRead {
+  codex;
+  params;
+  signal;
+  direction;
+  mode;
+  after;
+  binding;
+  previous;
+  constructor(codex, params, scope, signal) {
+    this.codex = codex;
+    this.params = params;
+    this.signal = signal;
+    this.direction = params.sortDirection ?? "asc";
+    this.mode = params.mode ?? "browse";
+    this.binding = JSON.stringify({ sessionId: params.sessionId, mode: this.mode, sortDirection: this.direction, includeNative: params.includeNative ?? false, ...scope });
+    this.previous = this.decode(params.cursor);
+    this.after = this.previous?.after ?? null;
+  }
+  decode(raw) {
+    if (raw == null)
+      return null;
+    try {
+      const v = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+      if (!v || v.version !== 2 || v.binding !== this.binding || typeof v.after !== "string" || !v.after || (this.mode === "browse" ? v.revision !== null : typeof v.revision !== "string" || !/^[a-f0-9]{64}$/.test(v.revision)))
+        throw new Error("cursor mismatch");
+      return v;
+    } catch {
+      throw historyError("history_invalid_cursor", "Invalid history cursor or changed query options; restart without a cursor", false, {}, -32602);
+    }
+  }
+  async call(operation) {
+    const check2 = () => {
+      if (this.signal?.aborted)
+        throw historyError("history_cancelled", "History request cancelled", false);
+    };
+    check2();
+    try {
+      const result = this.signal ? await abortable(operation(), this.signal) : await operation();
+      check2();
+      return result;
+    } catch (error40) {
+      check2();
+      throw sourceError(error40);
+    }
+  }
+  async start() {
+    const boundary = await this.boundary();
+    if (this.previous && this.previous.revision !== boundary.revision)
+      this.changed();
+    return boundary;
+  }
+  async boundary() {
+    const { thread } = await this.call(() => this.codex.threadRead({ threadId: this.params.sessionId, includeTurns: false }));
+    if (this.mode === "browse")
+      return { thread, revision: null };
+    if (thread.status.type === "active")
+      this.busy();
+    if (thread.status.type === "systemError")
+      throw historyError("history_unavailable", "Codex reports a session error; retry when it is resolved", true);
+    const tail = await this.call(() => this.codex.threadTurnsList({ threadId: this.params.sessionId, limit: 1, sortDirection: "desc", itemsView: "summary" }));
+    this.checkTurns(tail.data);
+    const revision = createHash("sha256").update(JSON.stringify({ id: thread.id, cwd: thread.cwd, name: thread.name, preview: thread.preview, createdAt: thread.createdAt, updatedAt: thread.updatedAt, forkedFromId: thread.forkedFromId, tail: tail.data[0] ?? null })).digest("hex");
+    return { thread, revision };
+  }
+  checkTurns(turns) {
+    if (this.mode === "export" && turns.some((turn) => turn.status === "inProgress"))
+      this.busy();
+  }
+  busy() {
+    throw historyError("history_busy", "Session history is still running; retry after the turn finishes", true);
+  }
+  changed() {
+    throw historyError("history_changed", "Session history changed; discard collected pages and restart without a cursor", true);
+  }
+  async finish(start, next, count) {
+    if (next !== null && (!next || next === this.after || count === 0))
+      throw historyError("history_invalid_page", "Codex history pagination made no progress; restart the read", false, {}, -32603);
+    if (this.mode === "export" && start.revision !== (await this.boundary()).revision)
+      this.changed();
+    const nextCursor = next === null ? null : Buffer.from(JSON.stringify({ version: 2, binding: this.binding, revision: start.revision, after: next })).toString("base64url");
+    const t = start.thread;
+    return { sessionId: this.params.sessionId, cwd: t.cwd, title: t.name?.trim() || t.preview.trim() || null, createdAt: t.createdAt, updatedAt: t.updatedAt, forkedFromId: t.forkedFromId, running: t.status.type === "active" ? true : t.status.type === "idle" ? false : null, revision: start.revision, consistency: this.mode === "export" ? "optimistic" : "live", nextCursor, complete: nextCursor === null };
+  }
+  bounded(page) {
+    const bytes = Buffer.byteLength(JSON.stringify(page));
+    const maxBytes = this.params.maxBytes ?? 1024 * 1024;
+    if (bytes > maxBytes)
+      throw historyError("history_page_too_large", "History page exceeds maxBytes; retry the same cursor with a smaller limit or larger maxBytes, or start a new summary/item traversal", true, { bytes, maxBytes }, -32600);
+    return page;
+  }
+}
+
+// src/agent/historyProjection.ts
+import { pathToFileURL as pathToFileURL2 } from "url";
+function inputBlock(input) {
+  switch (input.type) {
+    case "text":
+      return { type: "text", text: input.text, ...input.text_elements.length ? { _meta: { codex: { textElements: input.text_elements } } } : {} };
+    case "image":
+      return { type: "resource_link", name: "Image", uri: "url" in input ? input.url : `codex-file:${encodeURIComponent(input.fileId)}`, _meta: { codex: { inputType: input.type, ...input.detail ? { detail: input.detail } : {}, ..."fileId" in input ? { fileId: input.fileId } : {} } } };
+    case "audio":
+      return { type: "resource_link", name: "Audio", uri: input.url, _meta: { codex: { inputType: input.type } } };
+    case "localImage":
+    case "localAudio":
+      return { type: "resource_link", name: input.type === "localImage" ? "Image" : "Audio", uri: input.path.startsWith("file://") ? input.path : pathToFileURL2(input.path).href, _meta: { codex: { inputType: input.type, ..."detail" in input && input.detail ? { detail: input.detail } : {} } } };
+    case "skill":
+    case "mention":
+      return { type: "resource_link", name: input.name, uri: input.path.startsWith("file://") ? input.path : pathToFileURL2(input.path).href, _meta: { codex: { inputType: input.type } } };
+  }
+}
+function projectHistoryItem(item, turnId, startedAt) {
+  const omissions = [];
+  let updates;
+  if (item.type === "userMessage") {
+    updates = [{ sessionUpdate: "user_message", messageId: item.clientId ?? item.id, content: item.content.map(inputBlock) }];
+  } else {
+    updates = itemSnapshot(item);
+    if (!updates.length)
+      omissions.push({ itemId: item.id, field: "*", reason: "no_acp_representation" });
+    if (item.type === "reasoning" && item.summary.length && item.content.length)
+      omissions.push({ itemId: item.id, field: "content", reason: "summary_selected" });
+    if (item.type === "agentMessage") {
+      for (const field of ["memoryCitation", "delivery", "questions"]) {
+        if (item[field] !== null)
+          omissions.push({ itemId: item.id, field, reason: "no_acp_representation" });
+      }
+    }
+  }
+  return { updates: updates.map((update) => withTurnId(update, turnId, startedAt)), omissions };
+}
+
+// src/agent/sessionHistory.ts
+async function readSessionHistory(codex, raw, signal) {
+  const params = parseSessionHistoryParams(raw);
+  const view = params.itemsView ?? "summary";
+  const read = new HistoryRead(codex, params, { endpoint: "turns", itemsView: view }, signal);
+  const start = await read.start();
+  const page = await read.call(() => codex.threadTurnsList({ threadId: params.sessionId, cursor: read.after, limit: params.limit ?? 50, sortDirection: read.direction, itemsView: view }));
+  read.checkTurns(page.data);
+  if (view === "full" && page.data.some((turn) => turn.itemsView !== "full"))
+    throw historyError("history_incomplete", "Codex did not return full history items; update Codex and retry", false, {}, -32603);
+  const result = await read.finish(start, page.nextCursor, page.data.length);
+  return read.bounded({ ...result, running: page.data.some((turn) => turn.status === "inProgress") ? true : result.running, turns: page.data.map((turn) => {
+    const projections = view === "full" ? turn.items.map((item) => projectHistoryItem(item, turn.id, turn.startedAt)) : [];
+    return {
+      turnId: turn.id,
+      status: turn.status,
+      error: turn.error,
+      startedAt: turn.startedAt,
+      completedAt: turn.completedAt,
+      durationMs: turn.durationMs,
+      itemsView: view === "summary" ? "summary" : turn.itemsView,
+      updates: projections.flatMap((p) => p.updates),
+      omissions: projections.flatMap((p) => p.omissions),
+      ...params.includeNative ? { _meta: { codex: { items: turn.items } } } : {}
+    };
+  }) });
+}
+async function readSessionHistoryItems(codex, raw, signal) {
+  const params = parseSessionHistoryItemsParams(raw);
+  const read = new HistoryRead(codex, params, { endpoint: "items", turnId: params.turnId ?? null }, signal);
+  const start = await read.start();
+  const page = await read.call(() => codex.threadItemsList({
+    threadId: params.sessionId,
+    turnId: params.turnId ?? null,
+    cursor: read.after ?? (params.anchorItemId ? { type: "item", itemId: params.anchorItemId } : null),
+    limit: params.limit ?? 50,
+    sortDirection: read.direction
+  }));
+  const result = await read.finish(start, page.nextCursor, page.data.length);
+  return read.bounded({ ...result, items: page.data.map((entry) => ({
+    turnId: entry.turnId,
+    itemId: entry.item.id,
+    startedAtMs: entry.startedAtMs,
+    completedAtMs: entry.completedAtMs,
+    ...projectHistoryItem(entry.item, entry.turnId),
+    ...params.includeNative ? { _meta: { codex: { item: entry.item } } } : {}
+  })) });
+}
+
 // src/agent/forkIndex.ts
 import { createReadStream } from "fs";
 import { readdir, realpath } from "fs/promises";
@@ -27117,7 +27366,7 @@ class CodexAgent {
           additionalDirectories: {}
         },
         providers: {},
-        _meta: { alwith: { tools: { version: 1 }, turns: { version: 2 } }, codex: { forkAtTurn: true, sessionLineage: true, archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
+        _meta: { alwith: { tools: { version: 1 }, turns: { version: 2 } }, codex: { forkAtTurn: true, sessionLineage: true, archive: true, sessionHistory: { version: 2, items: true, modes: ["browse", "export"] }, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
       },
       authMethods: authMethods(this.capabilities, this.env)
     };
@@ -27669,6 +27918,7 @@ class CodexAgent {
       cursor,
       ...cwd ? { cwd } : {},
       sourceKinds: ["cli", "vscode", "exec", "appServer", "unknown"],
+      modelProviders: [],
       ...archived ? { archived: true } : {}
     }));
     const response = await list(params.cursor ?? null);
@@ -27722,6 +27972,25 @@ class CodexAgent {
     await this.withCodex(() => this.codex.threadDelete({ threadId: params.sessionId }));
     return {};
   }
+  async sessionHistory(params, signal) {
+    this.requireInitialized("_codex/session_history");
+    this.checkHistoryIdle(params);
+    const response = await readSessionHistory(this.codex, params, signal);
+    this.checkHistoryIdle(params);
+    return { ...response, running: this.sessions.get(params.sessionId)?.session.activeTurn ? true : response.running };
+  }
+  async sessionHistoryItems(params, signal) {
+    this.requireInitialized("_codex/session_history_items");
+    this.checkHistoryIdle(params);
+    const response = await readSessionHistoryItems(this.codex, params, signal);
+    this.checkHistoryIdle(params);
+    return { ...response, running: this.sessions.get(params.sessionId)?.session.activeTurn ? true : response.running };
+  }
+  checkHistoryIdle(params) {
+    if (params.mode === "export" && this.sessions.get(params.sessionId)?.session.activeTurn) {
+      throw historyError("history_busy", "Session history is still running; retry after the turn finishes", true);
+    }
+  }
   async archiveSession(params) {
     return await this.admission(() => this.archiveSessionInternal(params), params.sessionId);
   }
@@ -28526,7 +28795,7 @@ function createAgentApp(options) {
   };
   return agent({ name: options.info.name }).onConnect((connection) => {
     agent2 = new CodexAgent(connection.client, options);
-  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest("_codex/session_rename", { parse: parseSessionRenameParams }, (ctx) => current().sessionRename(ctx.params)).onRequest("_codex/account_read", { parse: objectParams() }, () => current().accountRead()).onRequest("_codex/rate_limits", { parse: objectParams() }, () => current().rateLimits()).onRequest("_codex/fuzzy_file_search", { parse: parseFuzzyFileSearchParams }, (ctx) => current().fuzzyFileSearch(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
+  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_history", { parse: parseSessionHistoryParams }, (ctx) => current().sessionHistory(ctx.params, ctx.signal)).onRequest("_codex/session_history_items", { parse: parseSessionHistoryItemsParams }, (ctx) => current().sessionHistoryItems(ctx.params, ctx.signal)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest("_codex/skills_list", { parse: objectParams() }, (ctx) => current().skillsList(ctx.params)).onRequest("_codex/skills_config_write", { parse: objectParams() }, (ctx) => current().skillsConfigWrite(ctx.params)).onRequest("_codex/plugin_list", { parse: objectParams() }, (ctx) => current().pluginList(ctx.params)).onRequest("_codex/plugin_installed", { parse: objectParams() }, (ctx) => current().pluginInstalled(ctx.params)).onRequest("_codex/plugin_install", { parse: objectParams() }, (ctx) => current().pluginInstall(ctx.params)).onRequest("_codex/plugin_uninstall", { parse: objectParams() }, (ctx) => current().pluginUninstall(ctx.params)).onRequest("_codex/plugin_read", { parse: objectParams() }, (ctx) => current().pluginRead(ctx.params)).onRequest("_codex/marketplace_add", { parse: objectParams() }, (ctx) => current().marketplaceAdd(ctx.params)).onRequest("_codex/marketplace_remove", { parse: objectParams() }, (ctx) => current().marketplaceRemove(ctx.params)).onRequest("_codex/marketplace_upgrade", { parse: objectParams() }, (ctx) => current().marketplaceUpgrade(ctx.params)).onRequest("_codex/session_rename", { parse: parseSessionRenameParams }, (ctx) => current().sessionRename(ctx.params)).onRequest("_codex/account_read", { parse: objectParams() }, () => current().accountRead()).onRequest("_codex/rate_limits", { parse: objectParams() }, () => current().rateLimits()).onRequest("_codex/fuzzy_file_search", { parse: parseFuzzyFileSearchParams }, (ctx) => current().fuzzyFileSearch(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
 }
 
 // src/codex/AppServerClient.ts
@@ -28843,6 +29112,9 @@ class AppServerClient {
   threadTurnsList(params) {
     return this.send({ method: "thread/turns/list", params });
   }
+  threadItemsList(params) {
+    return this.send({ method: "thread/items/list", params });
+  }
   threadArchive(params) {
     return this.send({ method: "thread/archive", params });
   }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {