@narumitw/pi-codex-compact 0.51.3 → 0.52.0

package/dist/index.ts

@@ -1,8 +1,11 @@
 // @generated by scripts/build-runtime.mjs; do not edit.
 // @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
 import {
-  usesCodexResponsesApi
-} from "./chunks/chunk-6TZ2L2BM.js";
+  RESPONSES_COMPACTION_APIS,
+  resolveCompactionRoute,
+  terminalText,
+  usesResponsesCompactionApi
+} from "./chunks/chunk-JYXZMCXD.js";
 
 // src/codex-compact.ts
 import {
@@ -17,6 +20,7 @@ import { createHash, randomUUID } from "node:crypto";
 
 // src/protocol.ts
 var MAX_SSE_BYTES = 8 * 1024 * 1024;
+var MAX_COMPACT_JSON_BYTES = 8 * 1024 * 1024;
 var MAX_COMPACTION_ITEM_BYTES = 2 * 1024 * 1024;
 var CodexCompactionProtocolError = class extends Error {
   constructor(message) {
@@ -141,6 +145,115 @@ async function collectCompactionSse(stream, options = {}) {
   }
   return { item: [...items.values()][0], completedResponse };
 }
+function isRetainedCompactContent(value) {
+  if (!isObject(value)) return false;
+  if (value.type === "input_text") return typeof value.text === "string";
+  if (value.type !== "input_image") return false;
+  if (value.detail !== void 0 && value.detail !== null && value.detail !== "auto" && value.detail !== "low" && value.detail !== "high" && value.detail !== "original") {
+    return false;
+  }
+  if (value.file_id !== void 0 && value.file_id !== null && typeof value.file_id !== "string" || value.image_url !== void 0 && value.image_url !== null && typeof value.image_url !== "string") {
+    return false;
+  }
+  return typeof value.file_id === "string" && value.file_id.length > 0 || typeof value.image_url === "string" && value.image_url.length > 0;
+}
+function isRetainedCompactMessage(value) {
+  return isObject(value) && value.role === "user" && (value.type === void 0 || value.type === "message") && Array.isArray(value.content) && value.content.length > 0 && value.content.every(isRetainedCompactContent);
+}
+function validateCompactedResponse(value, options = {}) {
+  if (!isObject(value) || !Array.isArray(value.output)) {
+    throw new CodexCompactionProtocolError("Responses Compact returned an invalid response object");
+  }
+  const maxBytes = options.maxBytes ?? MAX_COMPACT_JSON_BYTES;
+  const maxItemBytes = options.maxItemBytes ?? MAX_COMPACTION_ITEM_BYTES;
+  if (byteLength(value) > maxBytes) {
+    throw new CodexCompactionProtocolError("Responses Compact response exceeded the size limit");
+  }
+  if (value.output.length === 0) {
+    throw new CodexCompactionProtocolError("Responses Compact returned no output items");
+  }
+  const output = value.output.map((item2) => {
+    if (!isObject(item2)) {
+      throw new CodexCompactionProtocolError("Responses Compact returned a non-object output item");
+    }
+    if (byteLength(item2) > maxItemBytes) {
+      throw new CodexCompactionProtocolError(
+        "Responses Compact output item exceeded the size limit"
+      );
+    }
+    return structuredClone(item2);
+  });
+  const compactionItems = output.filter((item2) => item2.type === "compaction");
+  if (compactionItems.length !== 1 || output.at(-1)?.type !== "compaction") {
+    throw new CodexCompactionProtocolError(
+      "Responses Compact must return retained messages followed by one compaction item"
+    );
+  }
+  for (const item2 of output.slice(0, -1)) {
+    if (!isRetainedCompactMessage(item2)) {
+      throw new CodexCompactionProtocolError(
+        "Responses Compact returned an unsupported retained output item"
+      );
+    }
+  }
+  const item = validateCompactionItem(output.at(-1), maxItemBytes);
+  return { item, output: [...output.slice(0, -1), item], response: structuredClone(value) };
+}
+async function collectCompactResponse(response, options = {}) {
+  const maxBytes = options.maxBytes ?? MAX_COMPACT_JSON_BYTES;
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    const error = new CodexCompactionProtocolError(
+      "Responses Compact response exceeded the size limit"
+    );
+    await response.body?.cancel(error).catch(() => void 0);
+    throw error;
+  }
+  if (!response.body) {
+    throw new CodexCompactionProtocolError("Responses Compact response did not contain a body");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  const onAbort = () => {
+    void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => void 0);
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      if (options.signal?.aborted) throw new DOMException("Compaction aborted", "AbortError");
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > maxBytes) {
+        throw new CodexCompactionProtocolError(
+          "Responses Compact response exceeded the size limit"
+        );
+      }
+      chunks.push(value);
+    }
+    if (options.signal?.aborted) throw new DOMException("Compaction aborted", "AbortError");
+  } catch (error) {
+    await reader.cancel(error).catch(() => void 0);
+    throw error;
+  } finally {
+    options.signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(bytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    throw new CodexCompactionProtocolError("Responses Compact returned malformed JSON");
+  }
+  return validateCompactedResponse(parsed, options);
+}
 function markerTextFromItem(item) {
   if (!isObject(item) || item.role !== "user" || !Array.isArray(item.content)) return void 0;
   if (item.content.length !== 1) return void 0;
@@ -181,9 +294,17 @@ function appendCompactionTrigger(payload) {
   }
   return { ...payload, input: [...payload.input, { type: "compaction_trigger" }] };
 }
+function expandRemoteCompactionPayload(payload, checkpoint) {
+  if (checkpoint) {
+    return rewriteCheckpointMarker(payload, checkpoint.marker, checkpoint.replacementHistory);
+  }
+  if (!isObject(payload) || !Array.isArray(payload.input)) {
+    throw new CodexCompactionProtocolError("Responses payload is missing an input array");
+  }
+  return structuredClone(payload);
+}
 function prepareRemoteCompactionPayload(payload, checkpoint) {
-  const expanded = checkpoint ? rewriteCheckpointMarker(payload, checkpoint.marker, checkpoint.replacementHistory) : payload;
-  return appendCompactionTrigger(expanded);
+  return appendCompactionTrigger(expandRemoteCompactionPayload(payload, checkpoint));
 }
 function hasCheckpointMarker(payload, marker) {
   return isObject(payload) && Array.isArray(payload.input) && payload.input.some((item) => markerTextFromItem(item) === marker);
@@ -191,11 +312,15 @@ function hasCheckpointMarker(payload, marker) {
 
 // src/checkpoint.ts
 var CHECKPOINT_KIND = "pi-codex-remote-compaction";
-var CHECKPOINT_VERSION = 1;
+var CHECKPOINT_VERSION = 2;
 var REPLACEMENT_TOKEN_BUDGET = 64e3;
 var REPLACEMENT_BYTE_BUDGET = 8 * 1024 * 1024;
 var MAX_MEDIA_ITEM_BYTES = 2 * 1024 * 1024;
+var MAX_CHECKPOINT_DETAILS_BYTES = 10 * 1024 * 1024;
+var MAX_CHECKPOINT_ID_LENGTH = 128;
 var MAX_PROVIDER_ID_LENGTH = 256;
+var MAX_MODEL_ID_LENGTH = 512;
+var MAX_KEPT_FINGERPRINTS = 1e5;
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -216,13 +341,13 @@ 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 a model using the openai-codex-responses API."
+    "@narumitw/pi-codex-compact with the same model and Responses API."
   ].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 the same model through a compatible Codex Responses provider.",
+    `Responses compaction checkpoint ${checkpointId} stores the older history opaquely.`,
+    "Full replay requires @narumitw/pi-codex-compact and the same model through a compatible Responses provider.",
     "Without them, only Pi's retained recent messages remain available."
   ].join(" ");
 }
@@ -235,7 +360,14 @@ function markerMessage(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 || typeof value.provider !== "string" || value.provider.length === 0 || value.provider.length > MAX_PROVIDER_ID_LENGTH || 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") {
+  try {
+    if (serializedBytes(value) > MAX_CHECKPOINT_DETAILS_BYTES) return void 0;
+  } catch {
+    return void 0;
+  }
+  const isVersionOne = value.version === 1 && value.api === "openai-codex-responses" && value.protocol === "remote-compaction-v2";
+  const isVersionTwo = value.version === CHECKPOINT_VERSION && RESPONSES_COMPACTION_APIS.includes(value.api) && (value.protocol === "remote-v2" || value.protocol === "responses-compact");
+  if (value.kind !== CHECKPOINT_KIND || !isVersionOne && !isVersionTwo || typeof value.checkpointId !== "string" || value.checkpointId.length < 8 || value.checkpointId.length > MAX_CHECKPOINT_ID_LENGTH || typeof value.provider !== "string" || value.provider.length === 0 || value.provider.length > MAX_PROVIDER_ID_LENGTH || typeof value.modelId !== "string" || value.modelId.length === 0 || value.modelId.length > MAX_MODEL_ID_LENGTH || !Array.isArray(value.replacementHistory) || !Array.isArray(value.keptMessageFingerprints) || value.keptMessageFingerprints.length > MAX_KEPT_FINGERPRINTS || typeof value.createdAt !== "string" || value.createdAt.length > 64) {
     return void 0;
   }
   if (value.replacementHistory.length === 0 || !value.replacementHistory.every(isObject2) || !value.keptMessageFingerprints.every(
@@ -249,7 +381,18 @@ function parseCheckpointDetails(value) {
   } catch {
     return void 0;
   }
-  return structuredClone(value);
+  return {
+    kind: CHECKPOINT_KIND,
+    version: CHECKPOINT_VERSION,
+    checkpointId: value.checkpointId,
+    provider: value.provider,
+    api: isVersionOne ? "openai-codex-responses" : value.api,
+    modelId: value.modelId,
+    protocol: isVersionOne ? "remote-v2" : value.protocol,
+    replacementHistory: structuredClone(value.replacementHistory),
+    keptMessageFingerprints: [...value.keptMessageFingerprints],
+    createdAt: value.createdAt
+  };
 }
 function latestCheckpoint(entries) {
   for (let index = entries.length - 1; index >= 0; index--) {
@@ -362,9 +505,9 @@ function createCheckpointDetails(input) {
     version: CHECKPOINT_VERSION,
     checkpointId: input.checkpointId ?? randomUUID(),
     provider: input.provider,
-    api: "openai-codex-responses",
+    api: input.api,
     modelId: input.modelId,
-    protocol: "remote-compaction-v2",
+    protocol: input.protocol,
     replacementHistory: structuredClone(input.replacementHistory),
     keptMessageFingerprints: input.keptMessages.map(fingerprintMessage),
     createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -374,22 +517,298 @@ function createCheckpointDetails(input) {
   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) {
+// src/remote-types.ts
+function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function abortError() {
   return new DOMException("Compaction aborted", "AbortError");
 }
-async function requestRemoteCompaction(request) {
+function assertPreparedInput(payload) {
+  if (!Array.isArray(payload.input) || !payload.input.every(isJsonObject)) {
+    throw new Error("Prepared compaction payload has invalid input items");
+  }
+  return structuredClone(payload.input);
+}
+
+// src/remote-shared.ts
+async function collectProviderUsage(stream, signal) {
+  let usage;
+  for await (const event of stream) {
+    if (signal.aborted) throw abortError();
+    if (event.type === "error") {
+      throw new Error(event.error.errorMessage ?? "Responses compaction request failed");
+    }
+    if (event.type === "done") usage = event.message.usage;
+  }
+  if (signal.aborted) throw abortError();
+  if (!usage) throw new Error("Responses provider stream ended without completion usage");
+  return usage;
+}
+
+// src/remote-compact.ts
+var OFFICIAL_COMPACT_FIELDS = [
+  "model",
+  "input",
+  "instructions",
+  "previous_response_id",
+  "prompt_cache_key",
+  "prompt_cache_retention",
+  "service_tier"
+];
+var CODEX_COMPACT_FIELDS = [
+  "model",
+  "input",
+  "instructions",
+  "tools",
+  "parallel_tool_calls",
+  "reasoning",
+  "service_tier",
+  "prompt_cache_key",
+  "text",
+  "access_programs"
+];
+function compactPayload(payload, api) {
+  const fields = api === "openai-codex-responses" ? CODEX_COMPACT_FIELDS : OFFICIAL_COMPACT_FIELDS;
+  const result = {};
+  for (const field of fields) {
+    if (Object.hasOwn(payload, field) && payload[field] !== void 0) {
+      result[field] = structuredClone(payload[field]);
+    }
+  }
+  if (typeof result.model !== "string" || result.model.length === 0) {
+    throw new CodexCompactionProtocolError("Responses payload is missing a model");
+  }
+  assertPreparedInput(result);
+  return result;
+}
+function requestUrl(input) {
+  return new URL(input instanceof Request ? input.url : String(input));
+}
+function responsesCompactUrl(input) {
+  const original = requestUrl(input);
+  if (!original.pathname.endsWith("/responses")) {
+    throw new CodexCompactionProtocolError(
+      "Provider request URL does not end with the Responses endpoint"
+    );
+  }
+  const compact = new URL(original);
+  compact.pathname = `${compact.pathname}/compact`;
+  if (compact.origin !== original.origin) {
+    throw new CodexCompactionProtocolError("Responses Compact URL changed origin");
+  }
+  return compact;
+}
+function mergedHeaders(input, init) {
+  const headers = new Headers(input instanceof Request ? input.headers : void 0);
+  new Headers(init?.headers).forEach((value, name) => {
+    headers.set(name, value);
+  });
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+  headers.set("accept", "application/json");
+  headers.set("content-type", "application/json");
+  return headers;
+}
+function mergedSignal(input, init, ownerSignal) {
+  const signals = [ownerSignal];
+  if (input instanceof Request) signals.push(input.signal);
+  if (init?.signal) signals.push(init.signal);
+  return signals.length === 1 ? ownerSignal : AbortSignal.any(signals);
+}
+function nonRetryableBridgeFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return Response.json(
+    {
+      error: {
+        message,
+        type: "invalid_request_error",
+        code: "invalid_compact_response"
+      }
+    },
+    { status: 400 }
+  );
+}
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function optionalUsageDetail(details, field) {
+  if (details === void 0 || details === null) return 0;
+  if (!isJsonObject(details)) {
+    throw new CodexCompactionProtocolError("Responses Compact response has invalid usage details");
+  }
+  const value = details[field];
+  if (value === void 0 || value === null) return 0;
+  if (!nonNegativeInteger(value)) {
+    throw new CodexCompactionProtocolError(
+      `Responses Compact response has invalid usage detail ${field}`
+    );
+  }
+  return value;
+}
+function validatedUsage(response) {
+  const usage = response.usage;
+  if (!isJsonObject(usage)) {
+    throw new CodexCompactionProtocolError("Responses Compact response is missing usage");
+  }
+  for (const field of ["input_tokens", "output_tokens", "total_tokens"]) {
+    if (!nonNegativeInteger(usage[field])) {
+      throw new CodexCompactionProtocolError(`Responses Compact response has invalid ${field}`);
+    }
+  }
+  const inputTokens = usage.input_tokens;
+  const outputTokens = usage.output_tokens;
+  const totalTokens = usage.total_tokens;
+  const cachedTokens = optionalUsageDetail(usage.input_tokens_details, "cached_tokens");
+  const cacheWriteTokens = optionalUsageDetail(usage.input_tokens_details, "cache_write_tokens");
+  const reasoningTokens = optionalUsageDetail(usage.output_tokens_details, "reasoning_tokens");
+  if (cachedTokens + cacheWriteTokens > inputTokens || reasoningTokens > outputTokens) {
+    throw new CodexCompactionProtocolError(
+      "Responses Compact response has inconsistent usage details"
+    );
+  }
+  if (totalTokens !== inputTokens + outputTokens) {
+    throw new CodexCompactionProtocolError(
+      "Responses Compact response has inconsistent total usage"
+    );
+  }
+  return structuredClone(usage);
+}
+function syntheticCompletion(result, payload) {
+  const completed = {
+    id: typeof result.response.id === "string" ? result.response.id : "resp_pi_compact_bridge",
+    object: "response",
+    created_at: typeof result.response.created_at === "number" ? result.response.created_at : Math.floor(Date.now() / 1e3),
+    status: "completed",
+    model: payload.model,
+    output: [],
+    parallel_tool_calls: false,
+    tool_choice: "auto",
+    tools: [],
+    usage: validatedUsage(result.response)
+  };
+  const events = [
+    { type: "response.created", response: { ...completed, status: "in_progress" } },
+    { type: "response.completed", response: completed }
+  ];
+  return new Response(events.map((event) => `data: ${JSON.stringify(event)}
+
+`).join(""), {
+    status: 200,
+    headers: { "content-type": "text/event-stream" }
+  });
+}
+async function requestResponsesCompact(request) {
+  if (request.signal.aborted) throw abortError();
+  let preparedPayload;
+  let sentInput;
+  let compactResult;
+  let bridgeError;
+  let dispatchInFlight = false;
+  let successfulResponses = 0;
+  const baseFetch = request.fetch ?? globalThis.fetch;
+  const bridgeFetch = async (input, init) => {
+    if (request.signal.aborted) throw abortError();
+    if (successfulResponses > 0) {
+      bridgeError = new CodexCompactionProtocolError(
+        "Provider dispatched again after Responses Compact succeeded"
+      );
+      return nonRetryableBridgeFailure(bridgeError);
+    }
+    if (dispatchInFlight) {
+      bridgeError = new CodexCompactionProtocolError(
+        "Provider dispatched overlapping Responses Compact requests"
+      );
+      return nonRetryableBridgeFailure(bridgeError);
+    }
+    if (!preparedPayload) {
+      bridgeError = new CodexCompactionProtocolError(
+        "Provider dispatched before exposing its request payload"
+      );
+      return nonRetryableBridgeFailure(bridgeError);
+    }
+    let compactUrl;
+    try {
+      compactUrl = responsesCompactUrl(input);
+    } catch (error) {
+      bridgeError = error;
+      return nonRetryableBridgeFailure(error);
+    }
+    const signal = mergedSignal(input, init, request.signal);
+    dispatchInFlight = true;
+    try {
+      const response = await baseFetch(compactUrl, {
+        ...init,
+        method: "POST",
+        headers: mergedHeaders(input, init),
+        body: JSON.stringify(preparedPayload),
+        signal
+      });
+      if (!response.ok) return response;
+      try {
+        const result = await collectCompactResponse(response, { signal });
+        successfulResponses += 1;
+        if (successfulResponses !== 1) {
+          throw new CodexCompactionProtocolError(
+            "Provider returned more than one successful Responses Compact response"
+          );
+        }
+        compactResult = result;
+        return syntheticCompletion(result, preparedPayload);
+      } catch (error) {
+        bridgeError = error;
+        return nonRetryableBridgeFailure(error);
+      }
+    } finally {
+      dispatchInFlight = false;
+    }
+  };
+  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: bridgeFetch,
+    onPayload: (payload) => {
+      if (preparedPayload) {
+        throw new CodexCompactionProtocolError(
+          "Provider exposed more than one compaction request payload"
+        );
+      }
+      const expanded = expandRemoteCompactionPayload(payload, request.priorCheckpoint);
+      preparedPayload = compactPayload(expanded, request.model.api);
+      sentInput = assertPreparedInput(preparedPayload);
+      return expanded;
+    }
+  });
+  let usage;
+  try {
+    usage = await collectProviderUsage(stream, request.signal);
+  } catch (error) {
+    if (bridgeError) throw bridgeError;
+    throw error;
+  }
+  if (request.signal.aborted) throw abortError();
+  if (bridgeError) throw bridgeError;
+  if (!preparedPayload || !sentInput || !compactResult || successfulResponses !== 1) {
+    throw new CodexCompactionProtocolError(
+      "Provider did not complete exactly one Responses Compact request"
+    );
+  }
+  return {
+    item: compactResult.item,
+    promptInput: sentInput,
+    compactedOutput: compactResult.output,
+    usage
+  };
+}
+
+// src/remote-v2.ts
+async function requestRemoteCompactionV2(request) {
   if (request.signal.aborted) throw abortError();
   let sentInput;
   const inspections = [];
@@ -421,35 +840,30 @@ async function requestRemoteCompaction(request) {
     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));
+      sentInput = assertPreparedInput(prepared).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 ?? "Codex remote compaction request failed");
-    }
-    if (event.type === "done") usage = event.message.usage;
-  }
-  if (request.signal.aborted) throw abortError();
-  if (!sentInput)
+  const usage = await collectProviderUsage(stream, request.signal);
+  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 (inspections.length !== 1) {
+    throw new CodexCompactionProtocolError(
+      `Provider exposed ${inspections.length} successful SSE responses; expected exactly one`
+    );
+  }
+  const inspection = await inspections[0];
   if (request.signal.aborted) throw abortError();
-  if (!inspection?.ok) throw inspection?.error ?? new Error("Remote compaction inspection failed");
+  if (!inspection.ok) throw inspection.error;
   return { item: inspection.value.item, promptInput: sentInput, usage };
 }
 
+// src/remote.ts
+function requestRemoteCompaction(request) {
+  return request.protocol === "responses-compact" ? requestResponsesCompact(request) : requestRemoteCompactionV2(request);
+}
+
 // src/settings.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:fs";
@@ -460,6 +874,7 @@ var CODEX_COMPACT_SETTINGS_FILE = "pi-codex-compact.json";
 var MAX_SETTINGS_BYTES = 64 * 1024;
 var DEFAULT_CODEX_COMPACT_SETTINGS = Object.freeze({
   enabled: true,
+  protocol: "auto",
   requestTimeoutMs: 3e5,
   maxRetries: 2,
   replacementTokenBudget: 64e3,
@@ -479,6 +894,9 @@ function validInteger(value, minimum, 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, "protocol") && value.protocol !== "auto" && value.protocol !== "remote-v2" && value.protocol !== "responses-compact") {
+    return void 0;
+  }
   if (Object.hasOwn(value, "notifyOnFallback") && typeof value.notifyOnFallback !== "boolean") {
     return void 0;
   }
@@ -489,6 +907,7 @@ function normalizeCodexCompactSettings(value) {
   }
   return {
     enabled: typeof value.enabled === "boolean" ? value.enabled : DEFAULT_CODEX_COMPACT_SETTINGS.enabled,
+    protocol: value.protocol === "remote-v2" || value.protocol === "responses-compact" ? value.protocol : DEFAULT_CODEX_COMPACT_SETTINGS.protocol,
     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,
@@ -608,7 +1027,7 @@ function activeCheckpoint(ctx) {
   return latestCheckpoint(ctx.sessionManager.getBranch());
 }
 function isCheckpointCompatible(details, model) {
-  return usesCodexResponsesApi(model) && model.id === details.modelId;
+  return usesResponsesCompactionApi(model) && model.api === details.api && model.id === details.modelId;
 }
 function keptMessages(event) {
   const leafId = event.branchEntries.at(-1)?.id ?? null;
@@ -622,20 +1041,25 @@ function keptMessages(event) {
   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
-  }));
+  const available = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
+  return pi.getActiveTools().flatMap((name) => {
+    const tool = available.get(name);
+    return 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);
   if (!prior) return { messages: session.messages };
-  if (prior.details.modelId !== model.id) {
-    throw new Error("The active opaque checkpoint belongs to a different Codex model");
+  if (prior.details.api !== model.api || prior.details.modelId !== model.id) {
+    throw new Error("The active opaque checkpoint belongs to a different Responses model");
   }
   const projected = projectCheckpointContext(session.messages, prior.details, prior.entry.summary);
   if (!projected) {
@@ -645,23 +1069,29 @@ function projectedCurrentMessages(event, model) {
 }
 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");
+  const message = terminalText(error instanceof Error ? error.message : String(error));
+  ctx.ui.notify(`Responses 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) {
+async function compactRemotely(pi, event, ctx, settings, ownerSignal, fetch) {
   const model = ctx.model;
-  if (!settings.enabled || !usesCodexResponsesApi(model)) return void 0;
+  const route = resolveCompactionRoute(model, settings);
+  if (route.kind === "native" || !usesResponsesCompactionApi(model)) return void 0;
+  const signal = AbortSignal.any([event.signal, ownerSignal]);
+  if (signal.aborted) return { cancel: true };
   const sessionId = ctx.sessionManager.getSessionId();
-  ctx.ui.setStatus(STATUS_KEY, "Codex remote compaction\u2026");
+  ctx.ui.setStatus(
+    STATUS_KEY,
+    route.protocol === "remote-v2" ? "Responses Remote V2\u2026" : "Responses Compact API\u2026"
+  );
   try {
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-    if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
+    if (!sessionStillOwned(ctx, sessionId, signal)) return { cancel: true };
     if (!auth.ok) throw new Error(auth.error);
     const provider = ctx.modelRegistry.getProvider(model.provider);
-    if (!provider) throw new Error("The active Codex Responses provider is unavailable");
+    if (!provider) throw new Error("The active Responses provider is unavailable");
     const current = projectedCurrentMessages(event, model);
     const context = {
       systemPrompt: ctx.getSystemPrompt(),
@@ -672,10 +1102,11 @@ async function compactRemotely(pi, event, ctx, settings, fetch) {
       provider,
       model,
       context,
+      protocol: route.protocol,
       apiKey: auth.apiKey,
       headers: auth.headers,
       env: auth.env,
-      signal: event.signal,
+      signal,
       priorCheckpoint: current.prior ? {
         marker: checkpointMarker(current.prior.checkpointId),
         replacementHistory: current.prior.replacementHistory
@@ -684,13 +1115,17 @@ async function compactRemotely(pi, event, ctx, settings, fetch) {
       maxRetries: settings.maxRetries,
       fetch
     });
-    if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
-    const replacementHistory = buildReplacementHistory(response.promptInput, response.item, {
-      tokenBudget: settings.replacementTokenBudget
-    });
+    if (!sessionStillOwned(ctx, sessionId, signal)) return { cancel: true };
+    const replacementHistory = buildReplacementHistory(
+      response.compactedOutput?.slice(0, -1) ?? response.promptInput,
+      response.item,
+      { tokenBudget: settings.replacementTokenBudget }
+    );
     const details = createCheckpointDetails({
       provider: model.provider,
+      api: route.api,
       modelId: model.id,
+      protocol: route.protocol,
       replacementHistory,
       keptMessages: keptMessages(event)
     });
@@ -704,7 +1139,7 @@ async function compactRemotely(pi, event, ctx, settings, fetch) {
       }
     };
   } catch (error) {
-    if (event.signal.aborted || ctx.sessionManager.getSessionId() !== sessionId) {
+    if (signal.aborted || ctx.sessionManager.getSessionId() !== sessionId) {
       return { cancel: true };
     }
     notifyFailure(ctx, error, settings);
@@ -720,11 +1155,12 @@ function createCodexCompactExtension(options = {}) {
     let sessionController = new AbortController();
     let generation = 0;
     pi.registerCommand("codex-compact", {
-      description: "Compact now or configure Codex Remote Compaction V2",
-      handler: async (_args, ctx) => {
+      description: "Compact now or configure Responses compaction",
+      handler: async (args, ctx) => {
+        if (args.trim()) throw new Error("Usage: /codex-compact");
         const ownerGeneration = generation;
         const controller = sessionController;
-        const { showCodexCompactMenu } = await import("./chunks/settings-menu-PEDLURUH.js");
+        const { showCodexCompactMenu } = await import("./chunks/settings-menu-VYQ6ABCP.js");
         if (ownerGeneration !== generation || controller.signal.aborted) return;
         await showCodexCompactMenu(settingsRuntime, ctx, {
           signal: controller.signal,
@@ -746,7 +1182,7 @@ function createCodexCompactExtension(options = {}) {
         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)}`,
+            `Could not load pi-codex-compact.json; using defaults. ${terminalText(error instanceof Error ? error.message : String(error))}`,
             "warning"
           );
         }
@@ -757,14 +1193,21 @@ function createCodexCompactExtension(options = {}) {
       }
       if (ctx.hasUI && state.kind === "invalid") {
         ctx.ui.notify(
-          `Invalid pi-codex-compact.json; using defaults without overwriting it. ${state.issue}`,
+          `Invalid pi-codex-compact.json; using defaults without overwriting it. ${terminalText(state.issue ?? "unknown validation error")}`,
           "warning"
         );
       }
     });
     pi.on(
       "session_before_compact",
-      (event, ctx) => compactRemotely(pi, event, ctx, settingsRuntime.get().settings, options.fetch)
+      (event, ctx) => compactRemotely(
+        pi,
+        event,
+        ctx,
+        settingsRuntime.get().settings,
+        sessionController.signal,
+        options.fetch
+      )
     );
     pi.on("context", (event, ctx) => {
       if (!settingsRuntime.get().settings.enabled) return void 0;
@@ -794,7 +1237,7 @@ function createCodexCompactExtension(options = {}) {
       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.",
+          "The active Responses checkpoint cannot replay on this model; Pi will expose only its fallback marker and retained recent messages.",
           "warning"
         );
       }