Function compactMessages

src/utils/compaction.ts:134–193

(
  messages: Message[],
  options: {
    keepLastTurns?: number;
    summarize: (msgs: Message[]) => Promise<string>;
  },
)

}

/**
 * Compact a message list by summarizing all but the most recent `keepLast` turns.
 * A "turn" is a user message + everything until the next user message.
 *
 * The caller provides a `summarize` callback that runs an LLM call on the
 * messages-to-summarize and returns the summary text.
 */
export async function compactMessages(
  messages: Message[],
  options: {
    keepLastTurns?: number;
    summarize: (msgs: Message[]) => Promise<string>;
  },
): Promise<CompactionResult> {
  const keepLastTurns = options.keepLastTurns ?? 6;
  const before = estimateTokens(messages);

  const system = messages.filter(m => m.role === 'system');
  const nonSystem = messages.filter(m => m.role !== 'system');

  // Group into turn-groups: user msg starts each group
  const groups: Message[][] = [];
  let cur: Message[] = [];
  for (const m of nonSystem) {
    if (m.role === 'user' && cur.length > 0) {
      groups.push(cur);
      cur = [m];
    } else {
      cur.push(m);
    }
  }
  if (cur.length > 0) groups.push(cur);

  if (groups.length <= keepLastTurns) {
    // Nothing to do
    return { messages, before, after: before, turnsCompacted: 0 };
  }

  const toSummarize = groups.slice(0, groups.length - keepLastTurns).flat();
  const toKeep = groups.slice(groups.length - keepLastTurns).flat();
  const turnsCompacted = groups.length - keepLastTurns;

  // Filter out existing summary messages from the to-summarize set
  // and keep ALL system messages (including any prior summary) so the new
  // summary CAN reference them.
  const summarizationInput = buildCompactionRequest(toSummarize);
  let summaryText: string;
  try {
    summaryText = await options.summarize(summarizationInput);
  } catch (e: any) {
    logger.warn('Compaction summarization failed; returning original messages', { err: e?.message });
    return { messages, before, after: before, turnsCompacted: 0 };
  }
  // Refuse to trade real history for an empty summary.
  //
  // Compaction DELETES the summarized turns. A throw is handled above, but a summarizer can
  // also succeed and return nothing useful: an aborted stream (the caller's loop does
  // `if (signal?.aborted) break` and returns ''), a provider sending an empty body, a local