codex-copilot-dx 0.6.13 → 0.6.15

package/src/model-cache.mjs

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export const MODEL_CACHE_SOFT_TTL_MS = 2 * 60 * 60 * 1000;
+export const MODEL_CACHE_HARD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const MODEL_CACHE_PROFILES = new Set(["codex", "claude"]);
 
 export function modelCachePath(home = os.homedir(), profile = "codex") {
@@ -23,40 +24,69 @@ export function isValidModelList(models) {
   return modelData(models) !== null;
 }
 
-export function loadModelCache({
+function normalizedTtl(value, fallback) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+export function loadModelCacheEntry({
   home = os.homedir(),
   profile = "codex",
   credentialFingerprint = "",
-  maxAgeMs = DEFAULT_MAX_AGE_MS,
+  softTtlMs = MODEL_CACHE_SOFT_TTL_MS,
+  hardTtlMs,
+  maxAgeMs,
   now = Date.now,
 } = {}) {
   try {
     const parsed = JSON.parse(fs.readFileSync(modelCachePath(home, profile), "utf8"));
     const savedAt = Date.parse(parsed.saved_at);
-    if (!Number.isFinite(savedAt) || now() - savedAt > maxAgeMs) return null;
+    if (!Number.isFinite(savedAt)) return null;
     const expectedFingerprint = String(credentialFingerprint || "").trim();
     if (expectedFingerprint && parsed.credential_fingerprint !== expectedFingerprint) return null;
     if (!isValidModelList(parsed.models)) return null;
-    return parsed.models;
+    const resolvedHardTtlMs = normalizedTtl(
+      hardTtlMs,
+      normalizedTtl(maxAgeMs, MODEL_CACHE_HARD_TTL_MS),
+    );
+    const resolvedSoftTtlMs = Math.min(
+      normalizedTtl(softTtlMs, MODEL_CACHE_SOFT_TTL_MS),
+      resolvedHardTtlMs,
+    );
+    const ageMs = Math.max(0, now() - savedAt);
+    if (ageMs > resolvedHardTtlMs) return null;
+    return {
+      models: parsed.models,
+      savedAtMs: savedAt,
+      ageMs,
+      state: ageMs > resolvedSoftTtlMs ? "stale" : "fresh",
+    };
   } catch {
     return null;
   }
 }
 
+export function loadModelCache(options = {}) {
+  return loadModelCacheEntry(options)?.models || null;
+}
+
 export function saveModelCache(models, {
   home = os.homedir(),
   profile = "codex",
   credentialFingerprint = "",
+  isCurrent = () => true,
+  now = Date.now,
 } = {}) {
   if (!isValidModelList(models)) return false;
+  if (typeof isCurrent === "function" && !isCurrent()) return false;
   const filePath = modelCachePath(home, profile);
   const tempPath = `${filePath}.${process.pid}.tmp`;
-  const payload = { saved_at: new Date().toISOString(), models };
+  const payload = { saved_at: new Date(now()).toISOString(), models };
   const fingerprint = String(credentialFingerprint || "").trim();
   if (fingerprint) payload.credential_fingerprint = fingerprint;
   fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
   try {
     fs.writeFileSync(tempPath, `${JSON.stringify(payload)}\n`, { mode: 0o600 });
+    if (typeof isCurrent === "function" && !isCurrent()) return false;
     fs.renameSync(tempPath, filePath);
     fs.chmodSync(filePath, 0o600);
     return true;

package/src/observability.mjs

@@ -116,11 +116,23 @@ function modelRegistryStatus(modelRegistry) {
   const modelData = Array.isArray(modelRegistry?.models)
     ? modelRegistry.models
     : modelRegistry?.models?.data;
-  return {
+  const result = {
     source: String(modelRegistry?.source || "built-in"),
     models: Array.isArray(modelData) ? modelData.length : 0,
     claude_models: Array.isArray(modelRegistry?.modelDefs) ? modelRegistry.modelDefs.length : 0,
   };
+  if (typeof modelRegistry?.cacheState === "string") {
+    const savedAtMs = Number(modelRegistry.cacheSavedAtMs);
+    result.cache_state = modelRegistry.cacheState;
+    result.cache_age_ms = Number.isFinite(savedAtMs) ? Math.max(0, Date.now() - savedAtMs) : null;
+    result.refresh_in_flight = modelRegistry.refreshInFlight === true;
+    result.generation = finiteRuntimeNumber(modelRegistry.generation);
+    result.last_error = typeof modelRegistry.lastError === "string" ? modelRegistry.lastError : null;
+    result.last_error_at_ms = Number.isFinite(modelRegistry.lastErrorAtMs)
+      ? modelRegistry.lastErrorAtMs
+      : null;
+  }
+  return result;
 }
 
 function finiteRuntimeNumber(value, fallback = 0) {

package/src/pm-studio-relay.mjs

@@ -445,11 +445,14 @@ export function createPmStudioRelayHandler(options = {}) {
       releaseRequest = releaseOnce(admission);
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const body = await readJsonBody(req, { admission, signal: abort.signal });
-      const modelType = modelRouter.classify(body?.model);
-      if (modelType === "unsupported_claude") {
+      const routePlan = modelRouter.plan(body?.model);
+      if (routePlan.disposition === "reject") {
         throw localError(400, "model_not_supported", "The requested Claude model is not enabled for PM Studio");
       }
-      if (modelType !== "claude") {
+      if (routePlan.disposition !== "relay"
+        || routePlan.origin !== "ccdx"
+        || routePlan.profile !== "claude"
+        || routePlan.protocol !== "openai-chat-completions") {
         throw localError(
           400,
           "native_route_required",

package/src/profile-model-runtime.mjs

@@ -1,6 +1,6 @@
 import {
   isValidModelList,
-  loadModelCache,
+  loadModelCacheEntry,
   saveModelCache,
 } from "./model-cache.mjs";
 import {
@@ -22,13 +22,48 @@ function parsedCatalog(result) {
   if (result?.status < 200 || result?.status >= 300) {
     throw new Error(`Copilot models returned HTTP ${result?.status}`);
   }
-  const models = JSON.parse(result.body);
+  let models;
+  try {
+    models = JSON.parse(result.body);
+  } catch {
+    throw new Error("Copilot models response was not valid JSON");
+  }
   if (!isValidModelList(models)) {
     throw new Error("Copilot models response contained no valid models");
   }
   return models;
 }
 
+function createModelRegistry() {
+  return {
+    modelDefs: undefined,
+    models: undefined,
+    source: "built-in",
+    cacheState: "none",
+    cacheSavedAtMs: null,
+    lastError: null,
+    lastErrorAtMs: null,
+    refreshInFlight: false,
+    generation: 0,
+  };
+}
+
+function sameModelDefs(left, right) {
+  if (left === right) return true;
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function safeRefreshError(error, { timedOut = false, timeoutMs } = {}) {
+  if (timedOut) return `Model refresh timed out after ${timeoutMs}ms`;
+  const raw = String(error?.message || error?.name || "Model refresh failed")
+    .replace(/[\u0000-\u001f\u007f]+/g, " ")
+    .replace(/\b(?:github_pat_|gh[pousr]_|copilot_)[A-Za-z0-9._-]+\b/gi, "<redacted>")
+    .replace(/\bBearer\s+\S+/gi, "Bearer <redacted>")
+    .trim();
+  return (raw || "Model refresh failed").slice(0, 240);
+}
+
 export function createProfileModelRuntime({
   codexClient,
   claudeClient = codexClient,
@@ -51,11 +86,13 @@ export function createProfileModelRuntime({
     throw new Error("Isolated Claude models require an isolated Claude client");
   }
 
-  const codexRegistry = { modelDefs: undefined, models: undefined, source: "built-in" };
+  const codexRegistry = createModelRegistry();
   const claudeRegistry = claudeMode === "inherited"
     ? codexRegistry
-    : { modelDefs: undefined, models: undefined, source: "built-in" };
+    : createModelRegistry();
   const customClaudeDefs = parseModelAliasEnv(env.CCDX_CLAUDE_MODEL_ALIASES);
+  const refreshFlights = new Map();
+  const refreshGenerations = new Map();
   const refreshTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0
     ? timeoutMs
     : DEFAULT_TIMEOUT_MS;
@@ -85,8 +122,9 @@ export function createProfileModelRuntime({
       ? customClaudeDefs.map((model) => ({ ...model }))
       : claudeDesktopModelDefsFromCopilotModels(models);
     if (discovered.length) {
+      const changed = !sameModelDefs(registry.modelDefs, discovered);
       registry.modelDefs = discovered;
-      notifyClaudeModels(discovered);
+      if (changed) notifyClaudeModels(discovered);
     }
     return registry.modelDefs;
   }
@@ -96,11 +134,13 @@ export function createProfileModelRuntime({
       ? String(claudeCredentialFingerprint || "").trim()
       : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return false;
-    const cached = loadModelCache({ home, profile, credentialFingerprint });
+    const cached = loadModelCacheEntry({ home, profile, credentialFingerprint });
     if (!cached) return false;
     try {
-      applyCatalog({ client, models: cached, registry, source: "cache", ownsClaudeModels });
-      return true;
+      applyCatalog({ client, models: cached.models, registry, source: "cache", ownsClaudeModels });
+      registry.cacheState = cached.state;
+      registry.cacheSavedAtMs = cached.savedAtMs;
+      return { loaded: true, stale: cached.state === "stale" };
     } catch {
       return false;
     }
@@ -131,13 +171,22 @@ export function createProfileModelRuntime({
     }
   }
 
-  function persist(models, profile) {
+  function persist(models, profile, registry, generation) {
     const credentialFingerprint = profile === "claude"
       ? String(claudeCredentialFingerprint || "").trim()
       : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return;
     try {
-      saveModelCache(models, { home, profile, credentialFingerprint });
+      const saved = saveModelCache(models, {
+        home,
+        profile,
+        credentialFingerprint,
+        isCurrent: () => refreshGenerations.get(profile) === generation,
+      });
+      if (saved) {
+        registry.cacheState = "fresh";
+        registry.cacheSavedAtMs = Date.now();
+      }
     } catch (error) {
       const label = profile === "codex" ? "Copilot" : "Claude Copilot";
       emit("warn", `Could not persist the ${label} model cache (${error.message})`);
@@ -162,12 +211,13 @@ export function createProfileModelRuntime({
     return profile === "claude" ? "built-in model list" : "no cached model list";
   }
 
-  async function refreshProfile({ client, profile, registry, ownsClaudeModels, checksCodex }) {
+  async function performRefresh({ client, profile, registry, ownsClaudeModels, checksCodex }, generation) {
     const controllerLabel = claudeMode === "inherited"
       ? ""
       : `${profile === "codex" ? "Codex" : "Claude"} `;
     try {
       const models = await requestCatalog(client);
+      if (refreshGenerations.get(profile) !== generation) return registry.modelDefs;
       if (checksCodex) checkCodexCatalog(models);
       const modelDefs = applyCatalog({
         client,
@@ -176,20 +226,44 @@ export function createProfileModelRuntime({
         source: "live",
         ownsClaudeModels,
       });
-      persist(models, profile);
+      persist(models, profile, registry, generation);
+      registry.lastError = null;
+      registry.lastErrorAtMs = null;
       if (ownsClaudeModels) logClaudeCatalog(modelDefs);
       return modelDefs;
     } catch (error) {
+      if (refreshGenerations.get(profile) !== generation) return registry.modelDefs;
       const fallback = fallbackLabel(registry, profile);
       const timedOut = error?.name === "AbortError" || error?.code === "ABORT_ERR";
+      const diagnostic = safeRefreshError(error, { timedOut, timeoutMs: refreshTimeoutMs });
+      registry.lastError = diagnostic;
+      registry.lastErrorAtMs = Date.now();
       const message = timedOut
         ? `${controllerLabel}model refresh timed out after ${refreshTimeoutMs}ms; using ${fallback}`
-        : `Could not refresh ${controllerLabel.toLowerCase()}model list; using ${fallback} (${error.message})`;
+        : `Could not refresh ${controllerLabel.toLowerCase()}model list; using ${fallback} (${diagnostic})`;
       emit("warn", message[0].toUpperCase() + message.slice(1));
       return registry.modelDefs;
     }
   }
 
+  function refreshProfile(options) {
+    const { profile, registry } = options;
+    const existing = refreshFlights.get(profile);
+    if (existing) return existing.promise;
+
+    const generation = (refreshGenerations.get(profile) || 0) + 1;
+    refreshGenerations.set(profile, generation);
+    registry.generation = generation;
+    registry.refreshInFlight = true;
+    const flight = { generation, promise: null };
+    refreshFlights.set(profile, flight);
+    flight.promise = performRefresh(options, generation).finally(() => {
+      if (refreshFlights.get(profile) === flight) refreshFlights.delete(profile);
+      if (refreshGenerations.get(profile) === generation) registry.refreshInFlight = false;
+    });
+    return flight.promise;
+  }
+
   function refreshCodex() {
     return refreshProfile({
       client: codexClient,

package/src/profile-routing.mjs

@@ -2,6 +2,7 @@ import {
   isClaudeCopilotCatalogEntry,
   isClaudeCopilotModel,
 } from "./models.mjs";
+import { createRoutePlan } from "./route-plan.mjs";
 
 function catalogData(catalog) {
   if (Array.isArray(catalog)) return catalog;
@@ -47,14 +48,51 @@ export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {})
     return { allowed, known };
   }
 
+  function classify(modelId) {
+    const id = String(modelId || "").trim();
+    const { allowed, known } = availability();
+    if (allowed.has(id)) return "claude";
+    if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
+    return "enterprise";
+  }
+
+  function plan(modelId) {
+    const id = String(modelId || "").trim();
+    const modelType = classify(id);
+    const protocol = "openai-chat-completions";
+    if (modelType === "claude") {
+      return createRoutePlan({
+        disposition: "relay",
+        origin: "ccdx",
+        profile: "claude",
+        protocol,
+        model: id,
+        surface: "pm-studio",
+      });
+    }
+    if (modelType === "unsupported_claude") {
+      return createRoutePlan({
+        disposition: "reject",
+        origin: "ccdx",
+        profile: "claude",
+        protocol,
+        model: id || "unknown",
+        surface: "pm-studio",
+      });
+    }
+    return createRoutePlan({
+      disposition: "native",
+      origin: "pm-studio-native",
+      profile: "enterprise",
+      protocol,
+      model: id || "unknown",
+      surface: "pm-studio",
+    });
+  }
+
   return Object.freeze({
-    classify(modelId) {
-      const id = String(modelId || "").trim();
-      const { allowed, known } = availability();
-      if (allowed.has(id)) return "claude";
-      if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
-      return "enterprise";
-    },
+    plan,
+    classify,
     allowedModels() {
       return [...availability().allowed.values()];
     },

package/src/response-history.mjs

@@ -202,13 +202,17 @@ export function responseHistoryMaterializedBytes(responseId) {
   return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
 }
 
-export function materializeResponseHistory(responseId, { assertActive } = {}) {
+export function materializeResponseHistory(responseId, { assertActive, routeMetadata } = {}) {
   assertActive?.();
   const { chain, rootId } = responseHistoryChain(responseId);
   const items = [];
   for (let index = 0; index < chain.length; index += 1) {
     if ((index & 63) === 0) assertActive?.();
     const entry = chain[chain.length - index - 1];
+    routeMetadata?.push({
+      affinity: entry.routeAffinity || null,
+      hasOpaque: entry.hasOpaque === true,
+    });
     items.push(...entry.inputItems, ...entry.outputItems);
   }
   assertActive?.();
@@ -218,11 +222,22 @@ export function materializeResponseHistory(responseId, { assertActive } = {}) {
   return materialized;
 }
 
-export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
+export function rememberResponseHistoryNode({
+  id,
+  parentId,
+  inputItems,
+  outputItems,
+  hasOpaque = false,
+  routeAffinity = null,
+  takeOwnership = false,
+}) {
   if (!id || !Array.isArray(inputItems)) return;
   clearResponsesToolOutputPartsCache(inputItems);
   clearResponsesToolOutputPartsCache(outputItems);
-  const bytes = jsonByteLength([inputItems, outputItems]);
+  const historyValue = routeAffinity
+    ? [inputItems, outputItems, { routeAffinity, hasOpaque: hasOpaque === true }]
+    : [inputItems, outputItems];
+  const bytes = jsonByteLength(historyValue);
   if (bytes > maxBytes) {
     if (histories.has(id)) removeSubtree(id);
     rememberEvictedId(id);
@@ -236,6 +251,8 @@ export function rememberResponseHistoryNode({ id, parentId, inputItems, outputIt
     rootId,
     inputItems: takeOwnership ? inputItems : cloneJson(inputItems),
     outputItems: takeOwnership ? outputItems : cloneJson(outputItems),
+    hasOpaque: hasOpaque === true,
+    routeAffinity: routeAffinity ? cloneJson(routeAffinity) : null,
     bytes,
   };
   const oldRootId = existing?.rootId;

package/src/responses-bridge.mjs

@@ -38,6 +38,23 @@ export function responsesBodyUsesCustomTools(body) {
     && body.input.some((item) => item?.type === "custom_tool_call" || item?.type === "custom_tool_call_output");
 }
 
+function chatCompatibilityError(kind, itemType) {
+  const type = typeof itemType === "string" && itemType ? itemType : "unknown";
+  const message = `Responses ${kind} type "${type}" cannot be represented by Chat Completions`;
+  const error = new Error(message);
+  error.statusCode = 400;
+  error.code = "ccdx_responses_chat_incompatible";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      item_type: type,
+    },
+  };
+  return error;
+}
+
 export function responsesToChat(body) {
   const messages = [];
   if (body.instructions) messages.push({ role: "system", content: body.instructions });
@@ -65,19 +82,36 @@ export function responsesToChat(body) {
   if (typeof body.input === "string") {
     messages.push({ role: "user", content: body.input });
   } else if (Array.isArray(body.input)) {
-    for (const item of body.input) {
-      if (item.type === "message") {
+    for (let index = 0; index < body.input.length; index += 1) {
+      const item = body.input[index];
+      const isEasyMessage = item?.type === undefined
+        && ["user", "assistant", "system", "developer"].includes(item?.role)
+        && Object.prototype.hasOwnProperty.call(item, "content");
+      if (item?.type === "message" || isEasyMessage) {
         messages.push({ role: item.role, content: messageContent(item.content) });
-      } else if (["input_image", "image_url", "image"].includes(item.type)) {
+      } else if (["input_image", "image_url", "image"].includes(item?.type)) {
         messages.push({ role: "user", content: messageContent([item]) });
-      } else if (item.type === "function_call") {
+      } else if (item?.type === "function_call") {
+        const toolCalls = [];
+        while (index < body.input.length && body.input[index]?.type === "function_call") {
+          const call = body.input[index];
+          toolCalls.push({
+            id: call.call_id || randomUUID(),
+            type: "function",
+            function: { name: call.name, arguments: call.arguments },
+          });
+          index += 1;
+        }
+        index -= 1;
         messages.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: item.call_id || randomUUID(), type: "function", function: { name: item.name, arguments: item.arguments } }],
+          tool_calls: toolCalls,
         });
-      } else if (item.type === "function_call_output") {
+      } else if (item?.type === "function_call_output") {
         messages.push({ role: "tool", tool_call_id: item.call_id, content: typeof item.output === "string" ? item.output : JSON.stringify(item.output) });
+      } else {
+        throw chatCompatibilityError("input item", item?.type);
       }
     }
   }
@@ -90,9 +124,10 @@ export function responsesToChat(body) {
   if (maxTok !== undefined) chatReq.max_completion_tokens = maxTok;
 
   if (body.tools?.length) {
+    const unsupportedTool = body.tools.find((tool) => tool?.type !== "function");
+    if (unsupportedTool) throw chatCompatibilityError("tool", unsupportedTool?.type);
     chatReq.tools = body.tools
       .map((tool) => {
-        if (tool?.type !== "function") return null;
         if (tool.function?.name) return cloneJson(tool);
         const fn = {
           name: tool.name,
@@ -112,6 +147,8 @@ export function responsesToChat(body) {
       chatReq.tool_choice = body.tool_choice;
     } else if (body.tool_choice?.type === "function" && body.tool_choice.name) {
       chatReq.tool_choice = { type: "function", function: { name: body.tool_choice.name } };
+    } else {
+      throw chatCompatibilityError("tool choice", body.tool_choice?.type);
     }
   }
   if (body.parallel_tool_calls !== undefined) chatReq.parallel_tool_calls = body.parallel_tool_calls;

package/src/responses-compaction.mjs

@@ -1,10 +1,6 @@
-import { randomUUID } from "node:crypto";
 import { httpError } from "./http-transport.mjs";
 
 const COMPACTION_TRIGGER_TYPE = "compaction_trigger";
-const RETAINED_MESSAGE_ROLES = new Set(["user", "assistant", "developer", "system"]);
-const RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
-const APPROX_BYTES_PER_TOKEN = 4;
 
 function compactionError(message) {
   const error = httpError(message, 502);
@@ -19,47 +15,6 @@ function compactionError(message) {
   return error;
 }
 
-function normalizeMessageContent(content) {
-  if (typeof content === "string") return [{ type: "input_text", text: content }];
-  if (!Array.isArray(content)) return [];
-  return content.map((part) => {
-    if (!part || typeof part !== "object") return part;
-    return part.type === "output_text"
-      ? { ...part, type: "input_text" }
-      : structuredClone(part);
-  });
-}
-
-function approximateTextTokens(content) {
-  return content.reduce((total, part) => {
-    if (part?.type !== "input_text" || typeof part.text !== "string") return total;
-    return total + Math.ceil(Buffer.byteLength(part.text) / APPROX_BYTES_PER_TOKEN);
-  }, 0);
-}
-
-function retainedMessages(inputItems) {
-  const kept = [];
-  let usedTokens = 0;
-  for (let index = inputItems.length - 1; index >= 0; index -= 1) {
-    const item = inputItems[index];
-    if (item?.type !== "message" || !RETAINED_MESSAGE_ROLES.has(item.role)) continue;
-
-    const content = normalizeMessageContent(item.content);
-    usedTokens += Math.max(approximateTextTokens(content), 1);
-    if (usedTokens > RETAINED_MESSAGE_TOKEN_BUDGET && kept.length > 0) break;
-
-    kept.push({
-      type: "message",
-      id: `msg_${randomUUID().replaceAll("-", "")}`,
-      status: item.status ?? "completed",
-      role: item.role,
-      content,
-      ...(item.phase !== undefined ? { phase: structuredClone(item.phase) } : {}),
-    });
-  }
-  return kept.reverse();
-}
-
 export function prepareResponsesCompactionRequest(reqContext) {
   const input = Array.isArray(reqContext?.body?.input) ? reqContext.body.input : [];
   const compactionInputItems = compactionInputWithoutTrigger(input);
@@ -74,7 +29,7 @@ export function compactionInputWithoutTrigger(input) {
     : [];
 }
 
-export function createResponsesCompactionResult(inputItems, generated) {
+export function createResponsesCompactionResult(_inputItems, generated) {
   if (!generated || typeof generated !== "object" || !generated.id || !Array.isArray(generated.output)) {
     throw compactionError("Copilot compaction returned an invalid response envelope");
   }
@@ -95,10 +50,6 @@ export function createResponsesCompactionResult(inputItems, generated) {
   return {
     ...generated,
     object: "response.compaction",
-    output: [
-      ...retainedMessages(Array.isArray(inputItems) ? inputItems : []),
-      ...compactionItems,
-    ],
   };
 }