@narumitw/pi-codex-compact 0.50.0 → 0.50.2

package/dist/index.ts

@@ -0,0 +1,813 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/codex-compact.ts
+import { hasApi } from "@earendil-works/pi-ai";
+import {
+  buildContextEntries,
+  buildSessionContext,
+  convertToLlm,
+  sessionEntryToContextMessages
+} from "@earendil-works/pi-coding-agent";
+
+// src/checkpoint.ts
+import { createHash, randomUUID } from "node:crypto";
+
+// src/protocol.ts
+var MAX_SSE_BYTES = 8 * 1024 * 1024;
+var MAX_COMPACTION_ITEM_BYTES = 2 * 1024 * 1024;
+var CodexCompactionProtocolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexCompactionProtocolError";
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function byteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function isCompactionItem(value) {
+  return isObject(value) && value.type === "compaction" && typeof value.encrypted_content === "string" && value.encrypted_content.length > 0;
+}
+function validateCompactionItem(value, maxBytes = MAX_COMPACTION_ITEM_BYTES) {
+  if (!isCompactionItem(value)) {
+    throw new CodexCompactionProtocolError(
+      "Remote response did not contain a valid compaction item"
+    );
+  }
+  if (byteLength(value) > maxBytes) {
+    throw new CodexCompactionProtocolError("Remote compaction item exceeded the size limit");
+  }
+  return structuredClone(value);
+}
+function compactionItemsFromEvent(event) {
+  const items = [];
+  if (event.type === "response.output_item.done" && isObject(event.item)) {
+    items.push(event.item);
+  }
+  if (event.type === "response.completed" && isObject(event.response)) {
+    const output = event.response.output;
+    if (Array.isArray(output)) items.push(...output);
+  }
+  return items.filter((item) => isObject(item) && item.type === "compaction");
+}
+async function collectCompactionSse(stream, options = {}) {
+  const maxBytes = options.maxBytes ?? MAX_SSE_BYTES;
+  const reader = stream.getReader();
+  const onAbort = () => {
+    void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => void 0);
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let pending = "";
+  let dataLines = [];
+  let completedResponse;
+  const items = /* @__PURE__ */ new Map();
+  const checkAbort = () => {
+    if (options.signal?.aborted) throw new DOMException("Compaction aborted", "AbortError");
+  };
+  const dispatch = () => {
+    if (dataLines.length === 0) return;
+    const data = dataLines.join("\n");
+    dataLines = [];
+    if (data === "[DONE]") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      throw new CodexCompactionProtocolError("Remote compaction returned malformed SSE JSON");
+    }
+    if (!isObject(parsed)) return;
+    if (parsed.type === "response.completed") {
+      completedResponse = isObject(parsed.response) ? parsed.response : {};
+    }
+    for (const candidate of compactionItemsFromEvent(parsed)) {
+      const item = validateCompactionItem(candidate, options.maxItemBytes);
+      items.set(JSON.stringify(item), item);
+    }
+  };
+  const processLine = (line) => {
+    if (line === "") {
+      dispatch();
+      return;
+    }
+    if (line.startsWith(":")) return;
+    if (line === "data") dataLines.push("");
+    else if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+  };
+  try {
+    while (true) {
+      checkAbort();
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > maxBytes) {
+        throw new CodexCompactionProtocolError("Remote compaction stream exceeded the size limit");
+      }
+      pending += decoder.decode(value, { stream: true });
+      let newline = pending.indexOf("\n");
+      while (newline !== -1) {
+        const rawLine = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        processLine(rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine);
+        newline = pending.indexOf("\n");
+      }
+    }
+    pending += decoder.decode();
+    if (pending.length > 0) processLine(pending.endsWith("\r") ? pending.slice(0, -1) : pending);
+    dispatch();
+    checkAbort();
+  } catch (error) {
+    await reader.cancel(error).catch(() => void 0);
+    throw error;
+  } finally {
+    options.signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock();
+  }
+  if (!completedResponse) {
+    throw new CodexCompactionProtocolError(
+      "Remote compaction stream ended without response.completed"
+    );
+  }
+  if (items.size !== 1) {
+    throw new CodexCompactionProtocolError(
+      `Remote compaction returned ${items.size} distinct compaction items; expected exactly one`
+    );
+  }
+  return { item: [...items.values()][0], completedResponse };
+}
+function markerTextFromItem(item) {
+  if (!isObject(item) || item.role !== "user" || !Array.isArray(item.content)) return void 0;
+  if (item.content.length !== 1) return void 0;
+  const content = item.content[0];
+  if (!isObject(content) || content.type !== "input_text" || typeof content.text !== "string") {
+    return void 0;
+  }
+  return content.text;
+}
+function rewriteCheckpointMarker(payload, marker, replacementHistory) {
+  if (!isObject(payload) || !Array.isArray(payload.input)) {
+    throw new CodexCompactionProtocolError("OpenAI Codex payload is missing an input array");
+  }
+  const matches = payload.input.map((item, index2) => markerTextFromItem(item) === marker ? index2 : -1).filter((index2) => index2 >= 0);
+  if (matches.length !== 1) {
+    throw new CodexCompactionProtocolError(
+      `Provider payload contained ${matches.length} checkpoint markers; expected exactly one`
+    );
+  }
+  const index = matches[0];
+  return {
+    ...payload,
+    input: [
+      ...payload.input.slice(0, index),
+      ...structuredClone(replacementHistory),
+      ...payload.input.slice(index + 1)
+    ]
+  };
+}
+function appendCompactionTrigger(payload) {
+  if (!isObject(payload) || !Array.isArray(payload.input)) {
+    throw new CodexCompactionProtocolError("OpenAI Codex payload is missing an input array");
+  }
+  if (payload.input.some((item) => isObject(item) && item.type === "compaction_trigger")) {
+    throw new CodexCompactionProtocolError(
+      "Provider payload already contains a compaction trigger"
+    );
+  }
+  return { ...payload, input: [...payload.input, { type: "compaction_trigger" }] };
+}
+function prepareRemoteCompactionPayload(payload, checkpoint) {
+  const expanded = checkpoint ? rewriteCheckpointMarker(payload, checkpoint.marker, checkpoint.replacementHistory) : payload;
+  return appendCompactionTrigger(expanded);
+}
+function hasCheckpointMarker(payload, marker) {
+  return isObject(payload) && Array.isArray(payload.input) && payload.input.some((item) => markerTextFromItem(item) === marker);
+}
+
+// src/checkpoint.ts
+var CHECKPOINT_KIND = "pi-codex-remote-compaction";
+var CHECKPOINT_VERSION = 1;
+var REPLACEMENT_TOKEN_BUDGET = 64e3;
+var REPLACEMENT_BYTE_BUDGET = 8 * 1024 * 1024;
+var MAX_MEDIA_ITEM_BYTES = 2 * 1024 * 1024;
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!isObject2(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, stableValue(child)])
+  );
+}
+function serializedBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function fingerprintMessage(message) {
+  return createHash("sha256").update(JSON.stringify(stableValue(message))).digest("hex");
+}
+function checkpointMarker(checkpointId) {
+  return [
+    `[PI_CODEX_REMOTE_CHECKPOINT:${checkpointId}]`,
+    "Opaque checkpoint injection failed. Do not infer missing history; tell the user to re-enable",
+    "@narumitw/pi-codex-compact with an openai-codex model."
+  ].join(" ");
+}
+function fallbackSummary(checkpointId) {
+  return [
+    `OpenAI Codex Remote Compaction V2 checkpoint ${checkpointId} stores the older history opaquely.`,
+    "Full replay requires @narumitw/pi-codex-compact and an openai-codex model.",
+    "Without them, only Pi's retained recent messages remain available."
+  ].join(" ");
+}
+function markerMessage(checkpointId, timestamp) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: checkpointMarker(checkpointId) }],
+    timestamp
+  };
+}
+function parseCheckpointDetails(value) {
+  if (!isObject2(value)) return void 0;
+  if (value.kind !== CHECKPOINT_KIND || value.version !== CHECKPOINT_VERSION || typeof value.checkpointId !== "string" || value.checkpointId.length < 8 || value.provider !== "openai-codex" || value.api !== "openai-codex-responses" || typeof value.modelId !== "string" || value.protocol !== "remote-compaction-v2" || !Array.isArray(value.replacementHistory) || !Array.isArray(value.keptMessageFingerprints) || typeof value.createdAt !== "string") {
+    return void 0;
+  }
+  if (value.replacementHistory.length === 0 || !value.replacementHistory.every(isObject2) || !value.keptMessageFingerprints.every(
+    (fingerprint) => typeof fingerprint === "string" && /^[a-f0-9]{64}$/.test(fingerprint)
+  ) || serializedBytes(value.replacementHistory) > REPLACEMENT_BYTE_BUDGET) {
+    return void 0;
+  }
+  const last = value.replacementHistory.at(-1);
+  try {
+    validateCompactionItem(last);
+  } catch {
+    return void 0;
+  }
+  return structuredClone(value);
+}
+function latestCheckpoint(entries) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry.type !== "compaction") continue;
+    const details = parseCheckpointDetails(entry.details);
+    return details ? { entry, details } : void 0;
+  }
+  return void 0;
+}
+function isOlderCompactionSummary(message, timestamp) {
+  return message.role === "compactionSummary" && Number.isFinite(message.timestamp) && Number.isFinite(timestamp) && message.timestamp < timestamp;
+}
+function projectCheckpointContext(messages, details) {
+  const summary = fallbackSummary(details.checkpointId);
+  const summaryIndex = messages.findIndex(
+    (message) => message.role === "compactionSummary" && message.summary === summary
+  );
+  if (summaryIndex < 0) return void 0;
+  const timestamp = messages[summaryIndex].timestamp;
+  let messageIndex = summaryIndex + 1;
+  let fingerprintIndex = 0;
+  while (fingerprintIndex < details.keptMessageFingerprints.length) {
+    if (messageIndex >= messages.length) return void 0;
+    const message = messages[messageIndex];
+    if (fingerprintMessage(message) === details.keptMessageFingerprints[fingerprintIndex]) {
+      messageIndex += 1;
+      fingerprintIndex += 1;
+      continue;
+    }
+    if (isOlderCompactionSummary(message, timestamp)) {
+      messageIndex += 1;
+      continue;
+    }
+    return void 0;
+  }
+  while (messageIndex < messages.length && isOlderCompactionSummary(messages[messageIndex], timestamp)) {
+    messageIndex += 1;
+  }
+  return [
+    ...messages.slice(0, summaryIndex),
+    markerMessage(details.checkpointId, timestamp),
+    ...messages.slice(messageIndex)
+  ];
+}
+function rawText(item) {
+  if (!Array.isArray(item.content)) return "";
+  return item.content.flatMap(
+    (part) => isObject2(part) && typeof part.text === "string" && part.type === "input_text" ? [part.text] : []
+  ).join("\n");
+}
+function hasMedia(item) {
+  return Array.isArray(item.content) && item.content.some((part) => isObject2(part) && part.type === "input_image");
+}
+function truncateTextItem(item, maxChars) {
+  if (!Array.isArray(item.content) || maxChars <= 32) return void 0;
+  let remaining = maxChars - 16;
+  const content = [...item.content].reverse().flatMap((part) => {
+    if (!isObject2(part) || part.type !== "input_text" || typeof part.text !== "string" || remaining <= 0) {
+      return [];
+    }
+    const text = part.text.slice(-remaining);
+    remaining -= text.length;
+    return [{ ...part, text: `[truncated]
+${text}` }];
+  });
+  if (content.length === 0) return void 0;
+  return { ...item, content: content.reverse() };
+}
+function buildReplacementHistory(input, compactionItem, options = {}) {
+  const tokenBudget = options.tokenBudget ?? REPLACEMENT_TOKEN_BUDGET;
+  const byteBudget = options.byteBudget ?? REPLACEMENT_BYTE_BUDGET;
+  const opaque = validateCompactionItem(compactionItem);
+  let remainingBytes = byteBudget - serializedBytes(opaque);
+  let remainingChars = tokenBudget * 4;
+  if (remainingBytes <= 0)
+    throw new Error("Opaque compaction item exceeds replacement history budget");
+  const retainedNewestFirst = [];
+  const candidates = input.filter(
+    (item) => isObject2(item) && item.role === "user" && item.type !== "compaction_trigger"
+  );
+  for (let index = candidates.length - 1; index >= 0; index--) {
+    const candidate = candidates[index];
+    const bytes = serializedBytes(candidate);
+    if (hasMedia(candidate) && bytes > MAX_MEDIA_ITEM_BYTES) continue;
+    const text = rawText(candidate);
+    let retained = candidate;
+    if (text.length > remainingChars) {
+      if (hasMedia(candidate)) continue;
+      const truncated = truncateTextItem(candidate, remainingChars);
+      if (!truncated) continue;
+      retained = truncated;
+    }
+    if (serializedBytes(retained) > remainingBytes) {
+      if (hasMedia(retained)) continue;
+      const maxCharsByBytes = Math.max(0, remainingBytes - 128);
+      const truncated = truncateTextItem(retained, Math.min(remainingChars, maxCharsByBytes));
+      if (!truncated || serializedBytes(truncated) > remainingBytes) continue;
+      retained = truncated;
+    }
+    retainedNewestFirst.push(structuredClone(retained));
+    remainingBytes -= serializedBytes(retained);
+    remainingChars -= Math.min(remainingChars, rawText(retained).length);
+    if (remainingBytes <= 128 || remainingChars <= 32) break;
+  }
+  return [...retainedNewestFirst.reverse(), opaque];
+}
+function createCheckpointDetails(input) {
+  const details = {
+    kind: CHECKPOINT_KIND,
+    version: CHECKPOINT_VERSION,
+    checkpointId: input.checkpointId ?? randomUUID(),
+    provider: "openai-codex",
+    api: "openai-codex-responses",
+    modelId: input.modelId,
+    protocol: "remote-compaction-v2",
+    replacementHistory: structuredClone(input.replacementHistory),
+    keptMessageFingerprints: input.keptMessages.map(fingerprintMessage),
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const parsed = parseCheckpointDetails(details);
+  if (!parsed) throw new Error("Created an invalid Codex checkpoint");
+  return parsed;
+}
+
+// src/remote.ts
+var EMPTY_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+};
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function abortError() {
+  return new DOMException("Compaction aborted", "AbortError");
+}
+async function requestRemoteCompaction(request) {
+  if (request.signal.aborted) throw abortError();
+  let sentInput;
+  const inspections = [];
+  const baseFetch = request.fetch ?? globalThis.fetch;
+  const inspectedFetch = async (input, init) => {
+    const response = await baseFetch(input, init);
+    if (!response.ok || !response.body) return response;
+    const [providerBody, inspectionBody] = response.body.tee();
+    const inspection2 = collectCompactionSse(inspectionBody, { signal: request.signal }).then(
+      (value) => ({ ok: true, value }),
+      (error) => ({ ok: false, error })
+    );
+    inspections.push(inspection2);
+    return new Response(providerBody, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+  const stream = request.provider.stream(request.model, request.context, {
+    apiKey: request.apiKey,
+    headers: request.headers,
+    env: request.env,
+    signal: request.signal,
+    transport: "sse",
+    cacheRetention: "none",
+    timeoutMs: request.requestTimeoutMs ?? 5 * 60 * 1e3,
+    maxRetries: request.maxRetries ?? 2,
+    fetch: inspectedFetch,
+    onPayload: (payload) => {
+      const prepared = prepareRemoteCompactionPayload(payload, request.priorCheckpoint);
+      if (!Array.isArray(prepared.input) || !prepared.input.every(isObject3)) {
+        throw new CodexCompactionProtocolError(
+          "Prepared compaction payload has invalid input items"
+        );
+      }
+      sentInput = structuredClone(prepared.input.slice(0, -1));
+      return prepared;
+    }
+  });
+  let usage = EMPTY_USAGE;
+  for await (const event of stream) {
+    if (request.signal.aborted) throw abortError();
+    if (event.type === "error") {
+      throw new Error(event.error.errorMessage ?? "OpenAI Codex compaction request failed");
+    }
+    if (event.type === "done") usage = event.message.usage;
+  }
+  if (request.signal.aborted) throw abortError();
+  if (!sentInput)
+    throw new CodexCompactionProtocolError("Provider did not expose a request payload");
+  if (inspections.length === 0) {
+    throw new CodexCompactionProtocolError("Provider response did not expose an SSE body");
+  }
+  const inspection = await inspections.at(-1);
+  if (request.signal.aborted) throw abortError();
+  if (!inspection?.ok) throw inspection?.error ?? new Error("Remote compaction inspection failed");
+  return { item: inspection.value.item, promptInput: sentInput, usage };
+}
+
+// src/settings.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+var CODEX_COMPACT_SETTINGS_FILE = "pi-codex-compact.json";
+var MAX_SETTINGS_BYTES = 64 * 1024;
+var DEFAULT_CODEX_COMPACT_SETTINGS = Object.freeze({
+  enabled: true,
+  requestTimeoutMs: 3e5,
+  maxRetries: 2,
+  replacementTokenBudget: 64e3,
+  notifyOnFallback: true
+});
+var LIMITS = Object.freeze({
+  requestTimeoutMs: { minimum: 3e4, maximum: 6e5 },
+  maxRetries: { minimum: 0, maximum: 2 },
+  replacementTokenBudget: { minimum: 8e3, maximum: 128e3 }
+});
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validInteger(value, minimum, maximum) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+}
+function normalizeCodexCompactSettings(value) {
+  if (!isRecord(value)) return void 0;
+  if (Object.hasOwn(value, "enabled") && typeof value.enabled !== "boolean") return void 0;
+  if (Object.hasOwn(value, "notifyOnFallback") && typeof value.notifyOnFallback !== "boolean") {
+    return void 0;
+  }
+  for (const [field, limits] of Object.entries(LIMITS)) {
+    if (Object.hasOwn(value, field) && !validInteger(value[field], limits.minimum, limits.maximum)) {
+      return void 0;
+    }
+  }
+  return {
+    enabled: typeof value.enabled === "boolean" ? value.enabled : DEFAULT_CODEX_COMPACT_SETTINGS.enabled,
+    requestTimeoutMs: typeof value.requestTimeoutMs === "number" ? value.requestTimeoutMs : DEFAULT_CODEX_COMPACT_SETTINGS.requestTimeoutMs,
+    maxRetries: typeof value.maxRetries === "number" ? value.maxRetries : DEFAULT_CODEX_COMPACT_SETTINGS.maxRetries,
+    replacementTokenBudget: typeof value.replacementTokenBudget === "number" ? value.replacementTokenBudget : DEFAULT_CODEX_COMPACT_SETTINGS.replacementTokenBudget,
+    notifyOnFallback: typeof value.notifyOnFallback === "boolean" ? value.notifyOnFallback : DEFAULT_CODEX_COMPACT_SETTINGS.notifyOnFallback
+  };
+}
+function codexCompactSettingsPath() {
+  return join(getAgentDir(), CODEX_COMPACT_SETTINGS_FILE);
+}
+function aborted(signal) {
+  if (signal?.aborted) throw new DOMException("Settings operation aborted", "AbortError");
+}
+async function loadCodexCompactSettings(path = codexCompactSettingsPath(), signal) {
+  aborted(signal);
+  try {
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let text;
+    try {
+      const stats = await handle.stat();
+      aborted(signal);
+      if (!stats.isFile()) throw new Error("settings path is not a regular file");
+      if (stats.size > MAX_SETTINGS_BYTES) throw new Error("settings file exceeds 64 KiB");
+      text = await handle.readFile("utf8");
+    } finally {
+      await handle.close();
+    }
+    aborted(signal);
+    const document = JSON.parse(text);
+    const settings = normalizeCodexCompactSettings(document);
+    if (!settings || !isRecord(document)) throw new Error("invalid settings shape or bounds");
+    return { kind: "loaded", path, settings, document };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return {
+        kind: "missing",
+        path,
+        settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+        document: {}
+      };
+    }
+    return {
+      kind: "invalid",
+      path,
+      settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+      issue: isNodeError(error) && error.code === "ELOOP" ? "symbolic links are not accepted" : error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function savePatch(path, patch, signal) {
+  const latest = await loadCodexCompactSettings(path, signal);
+  if (latest.kind === "invalid") {
+    throw new Error(
+      "Cannot overwrite an invalid pi-codex-compact.json; repair it and reload first"
+    );
+  }
+  const document = { ...latest.document, ...patch };
+  const settings = normalizeCodexCompactSettings(document);
+  if (!settings) throw new Error("Refusing to save invalid Codex compaction settings");
+  const temporaryPath = join(dirname(path), `.${basename(path)}.${randomUUID2()}.tmp`);
+  await mkdir(dirname(path), { recursive: true });
+  aborted(signal);
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(document, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    aborted(signal);
+    const current = await loadCodexCompactSettings(path, signal);
+    if (current.kind === "invalid" || current.kind !== latest.kind || JSON.stringify(current.document) !== JSON.stringify(latest.document)) {
+      throw new Error("pi-codex-compact.json changed while saving; reopen settings and retry");
+    }
+    await rename(temporaryPath, path);
+  } finally {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+  }
+  return { kind: "loaded", path, settings, document };
+}
+function createCodexCompactSettingsRuntime(path = codexCompactSettingsPath()) {
+  let state = {
+    kind: "missing",
+    path,
+    settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+    document: {}
+  };
+  let queue = Promise.resolve();
+  const enqueue = (operation) => {
+    const result = queue.then(operation, operation);
+    queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+  return {
+    get: () => structuredClone(state),
+    reload: (signal) => enqueue(async () => {
+      state = await loadCodexCompactSettings(path, signal);
+      return structuredClone(state);
+    }),
+    update: (patch, signal) => enqueue(async () => {
+      state = await savePatch(path, patch, signal);
+      return structuredClone(state);
+    }),
+    flush: () => queue
+  };
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/codex-compact.ts
+var STATUS_KEY = "codex-compact";
+function isSupportedModel(model) {
+  return model?.provider === "openai-codex" && hasApi(model, "openai-codex-responses");
+}
+function activeCheckpoint(ctx) {
+  return latestCheckpoint(ctx.sessionManager.getBranch());
+}
+function isCheckpointCompatible(details, model) {
+  return isSupportedModel(model) && model.id === details.modelId;
+}
+function keptMessages(event) {
+  const leafId = event.branchEntries.at(-1)?.id ?? null;
+  const contextEntries = buildContextEntries(event.branchEntries, leafId);
+  const keptIndex = contextEntries.findIndex(
+    (entry) => entry.id === event.preparation.firstKeptEntryId
+  );
+  if (keptIndex < 0) {
+    throw new Error("Pi compaction cut point is not present in the active context");
+  }
+  return contextEntries.slice(keptIndex).flatMap(sessionEntryToContextMessages);
+}
+function activeTools(pi) {
+  const enabled = new Set(pi.getActiveTools());
+  return pi.getAllTools().filter((tool) => enabled.has(tool.name)).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+function projectedCurrentMessages(event, model) {
+  const leafId = event.branchEntries.at(-1)?.id ?? null;
+  const session = buildSessionContext(event.branchEntries, leafId);
+  const prior = latestCheckpoint(event.branchEntries)?.details;
+  if (!prior) return { messages: session.messages };
+  if (prior.modelId !== model.id) {
+    throw new Error("The active opaque checkpoint belongs to a different Codex model");
+  }
+  const projected = projectCheckpointContext(session.messages, prior);
+  if (!projected) {
+    throw new Error("The previous opaque checkpoint could not be projected safely");
+  }
+  return { messages: projected, prior };
+}
+function notifyFailure(ctx, error, settings) {
+  if (!ctx.hasUI || !settings.notifyOnFallback) return;
+  const message = error instanceof Error ? error.message : String(error);
+  ctx.ui.notify(`Codex remote compaction failed; using Pi compaction. ${message}`, "warning");
+}
+function sessionStillOwned(ctx, sessionId, signal) {
+  return !signal.aborted && ctx.sessionManager.getSessionId() === sessionId;
+}
+async function compactRemotely(pi, event, ctx, settings, fetch) {
+  const model = ctx.model;
+  if (!settings.enabled || !isSupportedModel(model)) return void 0;
+  const sessionId = ctx.sessionManager.getSessionId();
+  ctx.ui.setStatus(STATUS_KEY, "Codex remote compaction\u2026");
+  try {
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
+    if (!auth.ok || !auth.apiKey) {
+      throw new Error(auth.ok ? "OpenAI Codex OAuth token is unavailable" : auth.error);
+    }
+    const provider = ctx.modelRegistry.getProvider(model.provider);
+    if (!provider) throw new Error("OpenAI Codex provider is unavailable");
+    const current = projectedCurrentMessages(event, model);
+    const context = {
+      systemPrompt: ctx.getSystemPrompt(),
+      messages: convertToLlm(current.messages),
+      tools: activeTools(pi)
+    };
+    const response = await requestRemoteCompaction({
+      provider,
+      model,
+      context,
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+      env: auth.env,
+      signal: event.signal,
+      priorCheckpoint: current.prior ? {
+        marker: checkpointMarker(current.prior.checkpointId),
+        replacementHistory: current.prior.replacementHistory
+      } : void 0,
+      requestTimeoutMs: settings.requestTimeoutMs,
+      maxRetries: settings.maxRetries,
+      fetch
+    });
+    if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
+    const replacementHistory = buildReplacementHistory(response.promptInput, response.item, {
+      tokenBudget: settings.replacementTokenBudget
+    });
+    const details = createCheckpointDetails({
+      modelId: model.id,
+      replacementHistory,
+      keptMessages: keptMessages(event)
+    });
+    return {
+      compaction: {
+        summary: fallbackSummary(details.checkpointId),
+        firstKeptEntryId: event.preparation.firstKeptEntryId,
+        tokensBefore: event.preparation.tokensBefore,
+        usage: response.usage,
+        details
+      }
+    };
+  } catch (error) {
+    if (event.signal.aborted || ctx.sessionManager.getSessionId() !== sessionId) {
+      return { cancel: true };
+    }
+    notifyFailure(ctx, error, settings);
+    return void 0;
+  } finally {
+    if (ctx.sessionManager.getSessionId() === sessionId) ctx.ui.setStatus(STATUS_KEY, void 0);
+  }
+}
+function createCodexCompactExtension(options = {}) {
+  return (pi) => {
+    const providerWarnings = /* @__PURE__ */ new Set();
+    const settingsRuntime = options.settingsRuntime ?? createCodexCompactSettingsRuntime();
+    let sessionController = new AbortController();
+    let generation = 0;
+    pi.registerCommand("codex-compact", {
+      description: "Compact now or configure Codex Remote Compaction V2",
+      handler: async (_args, ctx) => {
+        const ownerGeneration = generation;
+        const controller = sessionController;
+        const { showCodexCompactMenu } = await import("./chunks/settings-menu-BLWCLVPZ.js");
+        if (ownerGeneration !== generation || controller.signal.aborted) return;
+        await showCodexCompactMenu(settingsRuntime, ctx, {
+          signal: controller.signal,
+          isCurrent: () => ownerGeneration === generation && !controller.signal.aborted
+        });
+      }
+    });
+    pi.on("session_start", async (_event, ctx) => {
+      sessionController.abort();
+      sessionController = new AbortController();
+      generation += 1;
+      const ownerGeneration = generation;
+      const sessionId = ctx.sessionManager.getSessionId();
+      providerWarnings.clear();
+      let state;
+      try {
+        state = await settingsRuntime.reload(sessionController.signal);
+      } catch (error) {
+        if (sessionController.signal.aborted || ownerGeneration !== generation) return;
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `Could not load pi-codex-compact.json; using defaults. ${error instanceof Error ? error.message : String(error)}`,
+            "warning"
+          );
+        }
+        return;
+      }
+      if (sessionController.signal.aborted || ownerGeneration !== generation || ctx.sessionManager.getSessionId() !== sessionId) {
+        return;
+      }
+      if (ctx.hasUI && state.kind === "invalid") {
+        ctx.ui.notify(
+          `Invalid pi-codex-compact.json; using defaults without overwriting it. ${state.issue}`,
+          "warning"
+        );
+      }
+    });
+    pi.on(
+      "session_before_compact",
+      (event, ctx) => compactRemotely(pi, event, ctx, settingsRuntime.get().settings, options.fetch)
+    );
+    pi.on("context", (event, ctx) => {
+      if (!settingsRuntime.get().settings.enabled) return void 0;
+      const checkpoint = activeCheckpoint(ctx);
+      if (!checkpoint || !isCheckpointCompatible(checkpoint.details, ctx.model)) return void 0;
+      const messages = projectCheckpointContext(event.messages, checkpoint.details);
+      return messages ? { messages } : void 0;
+    });
+    pi.on("before_provider_request", (event, ctx) => {
+      if (!settingsRuntime.get().settings.enabled) return void 0;
+      const checkpoint = activeCheckpoint(ctx);
+      if (!checkpoint || !isCheckpointCompatible(checkpoint.details, ctx.model)) return void 0;
+      const marker = checkpointMarker(checkpoint.details.checkpointId);
+      if (!hasCheckpointMarker(event.payload, marker)) return void 0;
+      return rewriteCheckpointMarker(event.payload, marker, checkpoint.details.replacementHistory);
+    });
+    pi.on("model_select", (event, ctx) => {
+      if (!settingsRuntime.get().settings.enabled) return;
+      const checkpoint = activeCheckpoint(ctx);
+      if (!checkpoint || isCheckpointCompatible(checkpoint.details, event.model)) return;
+      const key = `${ctx.sessionManager.getSessionId()}:${event.model.provider}:${event.model.id}`;
+      if (providerWarnings.has(key)) return;
+      providerWarnings.add(key);
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          "The active Codex checkpoint cannot replay on this model; Pi will expose only its fallback marker and retained recent messages.",
+          "warning"
+        );
+      }
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+      generation += 1;
+      sessionController.abort();
+      providerWarnings.clear();
+      ctx.ui.setStatus(STATUS_KEY, void 0);
+      await settingsRuntime.flush();
+    });
+  };
+}
+var codex_compact_default = createCodexCompactExtension();
+export {
+  codex_compact_default as default
+};
+//# sourceMappingURL=index.ts.map