muonroi-cli 1.2.0

package/src/orchestrator/cleanup.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Integration tests for the cleanup -> extractSession -> /api/extract pipeline.
+ *
+ * EXTRACT-01: Agent.cleanup() calls extractSession which hits /api/extract on stub server
+ * EXTRACT-03: Agent.cleanup() completes within 2.5s even when stub has 3s latency
+ * D-05:       Agent.cleanup() completes normally when EE server is unreachable
+ *
+ * These tests call extractSession directly (the same function wired in Agent.cleanup)
+ * to validate the full HTTP pipeline without needing a real Agent instance.
+ */
+import type { ModelMessage } from "ai";
+import { afterAll, describe, expect, it } from "vitest";
+import { createEEClient } from "../ee/client.js";
+import { setDefaultEEClient } from "../ee/intercept.js";
+import { extractSession } from "../ee/extract-session.js";
+import { startStubEEServer } from "../__test-stubs__/ee-server.js";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function buildTestMessages(userCount: number): ModelMessage[] {
+  const msgs: ModelMessage[] = [];
+  for (let i = 0; i < userCount; i++) {
+    msgs.push({ role: "user", content: `Message ${i + 1}` } as unknown as ModelMessage);
+    msgs.push({ role: "assistant", content: `Response ${i + 1}` } as unknown as ModelMessage);
+  }
+  return msgs;
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("cleanup -> extractSession -> /api/extract integration", () => {
+  // Stub server started fresh per test via beforeEach / per-test setup
+  // afterAll cleanup is handled within each test using try/finally
+
+  it("Test 1 (EXTRACT-01): extractSession hits /api/extract on stub server with correct source", async () => {
+    const stub = await startStubEEServer();
+    const client = createEEClient({ baseUrl: `http://127.0.0.1:${stub.port}` });
+    setDefaultEEClient(client as any);
+
+    try {
+      // 6 user messages — exceeds 5-message threshold
+      await extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit", "session-abc");
+
+      expect(stub.calls.extract.length).toBe(1);
+      expect(stub.calls.extract[0].meta?.source).toBe("cli-exit");
+      expect(stub.calls.extract[0].projectPath).toBe("/tmp/test-project");
+    } finally {
+      setDefaultEEClient(null as any);
+      await stub.stop();
+    }
+  });
+
+  it("Test 2 (EXTRACT-03): extractSession completes within 2.5s against 3s-latency stub", async () => {
+    const stub = await startStubEEServer({ latencyMs: 3000 });
+    const client = createEEClient({ baseUrl: `http://127.0.0.1:${stub.port}` });
+    setDefaultEEClient(client as any);
+
+    try {
+      const start = Date.now();
+      // Should complete quickly because AbortSignal.timeout(2000) fires
+      await extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit");
+      const elapsed = Date.now() - start;
+
+      // AbortSignal(2000ms) fires and error is swallowed — must complete in < 2500ms
+      expect(elapsed).toBeLessThan(2500);
+      // Request was aborted before server responded — no extract calls logged
+      expect(stub.calls.extract.length).toBe(0);
+    } finally {
+      setDefaultEEClient(null as any);
+      await stub.stop();
+    }
+  });
+
+  it("Test 3 (D-05): extractSession resolves without throwing when EE server is unreachable", async () => {
+    // Point at port 1 — nothing listening there
+    const client = createEEClient({ baseUrl: "http://127.0.0.1:1" });
+    setDefaultEEClient(client as any);
+
+    try {
+      // Must resolve (not throw) even when server is unreachable
+      await expect(
+        extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit"),
+      ).resolves.toBeUndefined();
+    } finally {
+      setDefaultEEClient(null as any);
+    }
+  });
+});

package/src/orchestrator/compaction.test.ts

@@ -0,0 +1,134 @@
+import type { ModelMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { buildEffectiveTranscript, type PersistedCompaction } from "../storage/transcript-view";
+import {
+  COMPACTION_SUMMARY_HEADER,
+  createCompactionSummaryMessage,
+  findCutPoint,
+  prepareCompaction,
+  serializeConversation,
+  shouldCompactContext,
+} from "./compaction";
+
+function user(text: string): ModelMessage {
+  return { role: "user", content: text } as ModelMessage;
+}
+
+function assistantText(text: string): ModelMessage {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }],
+  } as ModelMessage;
+}
+
+function assistantToolCall(toolCallId: string, toolName: string, input: Record<string, unknown> = {}): ModelMessage {
+  return {
+    role: "assistant",
+    content: [{ type: "tool-call", toolCallId, toolName, input }],
+  } as ModelMessage;
+}
+
+function toolResult(toolCallId: string, toolName: string, output: unknown): ModelMessage {
+  return {
+    role: "tool",
+    content: [{ type: "tool-result", toolCallId, toolName, output }],
+  } as ModelMessage;
+}
+
+describe("compaction helpers", () => {
+  it("triggers when context exceeds reserved headroom", () => {
+    const settings = { reserveTokens: 100, keepRecentTokens: 40 };
+
+    expect(shouldCompactContext(901, 1000, settings)).toBe(true);
+    expect(shouldCompactContext(900, 1000, settings)).toBe(false);
+  });
+
+  it("never selects a tool-result message as the cut point", () => {
+    const messages = [
+      user("inspect this file"),
+      assistantToolCall("call-1", "read_file", { path: "src/index.ts" }),
+      toolResult("call-1", "read_file", "x".repeat(400)),
+      assistantText("I found the relevant section."),
+      user("continue"),
+    ];
+
+    const cutPoint = findCutPoint(messages, 0, 130);
+
+    expect(cutPoint.firstKeptIndex).not.toBe(2);
+    expect(messages[cutPoint.firstKeptIndex]?.role).not.toBe("tool");
+  });
+
+  it("detects split turns and captures the turn prefix for summarization", () => {
+    const messages = [
+      user("Refactor the session loader."),
+      assistantText("a".repeat(320)),
+      assistantText("recent status update"),
+    ];
+
+    const preparation = prepareCompaction(messages, "system prompt", {
+      reserveTokens: 100,
+      keepRecentTokens: 5,
+    });
+
+    expect(preparation).not.toBeNull();
+    expect(preparation?.isSplitTurn).toBe(true);
+    expect(preparation?.messagesToSummarize).toHaveLength(0);
+    expect(preparation?.turnPrefixMessages).toHaveLength(2);
+    expect(preparation?.keptMessages).toHaveLength(1);
+  });
+
+  it("excludes the previous summary message from new compaction input", () => {
+    const messages = [
+      createCompactionSummaryMessage("Earlier work"),
+      user("Handle migration edge cases"),
+      assistantText("I added the table and loader changes."),
+      user("Now wire the retry path"),
+    ];
+
+    const preparation = prepareCompaction(messages, "system prompt", {
+      reserveTokens: 100,
+      keepRecentTokens: 4,
+    });
+
+    expect(preparation).not.toBeNull();
+    expect(preparation?.previousSummary).toBe("Earlier work");
+    expect(preparation?.messagesToSummarize[0]).toEqual(user("Handle migration edge cases"));
+    expect(preparation?.messagesToSummarize.some((message) => message.role === "system")).toBe(false);
+  });
+
+  it("serializes tool results with truncation markers", () => {
+    const transcript = serializeConversation([user("Read the output"), toolResult("call-1", "bash", "x".repeat(2105))]);
+
+    expect(transcript).toContain("[Tool result]:");
+    expect(transcript).toContain("more characters truncated");
+  });
+
+  it("builds the effective transcript from the latest persisted checkpoint", () => {
+    const rawMessages = [
+      user("old request"),
+      assistantText("old answer"),
+      user("new request"),
+      assistantText("new answer"),
+      user("latest request"),
+    ];
+    const seqs = [1, 2, 3, 4, 5];
+    const timestamps = seqs.map((seq) => new Date(`2026-03-20T00:00:0${seq}.000Z`));
+    const checkpoint: PersistedCompaction = {
+      firstKeptSeq: 4,
+      summary: "Summarized old work",
+      tokensBefore: 1234,
+      createdAt: new Date("2026-03-20T00:00:10.000Z"),
+    };
+
+    const transcript = buildEffectiveTranscript(rawMessages, seqs, timestamps, checkpoint);
+
+    expect(transcript.messages).toHaveLength(3);
+    expect(transcript.seqs).toEqual([null, 4, 5]);
+    expect(transcript.messages[0]).toEqual(createCompactionSummaryMessage("Summarized old work"));
+    expect(
+      transcript.messages[0]?.role === "system" && typeof transcript.messages[0].content === "string"
+        ? transcript.messages[0].content
+        : "",
+    ).toContain(COMPACTION_SUMMARY_HEADER);
+  });
+});

package/src/orchestrator/compaction.ts

@@ -0,0 +1,487 @@
+import { generateText, type ModelMessage } from "ai";
+import type { ProviderFactory as LegacyProvider } from "../providers/runtime.js";
+import { resolveModelRuntime } from "../providers/runtime.js";
+import { containsEncryptedReasoning } from "./reasoning";
+
+export interface CompactionSettings {
+  reserveTokens: number;
+  keepRecentTokens: number;
+}
+
+export interface CutPointResult {
+  firstKeptIndex: number;
+  turnStartIndex: number;
+  isSplitTurn: boolean;
+}
+
+export interface PreparedCompaction {
+  previousSummary?: string;
+  messagesToSummarize: ModelMessage[];
+  turnPrefixMessages: ModelMessage[];
+  keptMessages: ModelMessage[];
+  firstKeptIndex: number;
+  isSplitTurn: boolean;
+  tokensBefore: number;
+  settings: CompactionSettings;
+}
+
+const TOOL_RESULT_MAX_CHARS = 2000;
+const MIN_KEPT_TOKENS_ON_RETRY = 4000;
+
+export const DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
+export const POST_TURN_MIN_TOKENS = 2_000;
+export const COMPACTION_SUMMARY_HEADER = "[Context checkpoint summary]";
+
+const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant.
+
+Do not continue the conversation. Do not answer any questions from the conversation.
+Only output a structured checkpoint summary that another coding agent can use to continue the work.`;
+
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this exact format:
+
+## Goal
+[What the user is trying to accomplish]
+
+## Constraints & Preferences
+- [Requirements, preferences, or constraints]
+- [(none) if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed work]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Any active blockers]
+
+## Key Decisions
+- **[Decision]**: [Rationale]
+
+## Next Steps
+1. [The next action to take]
+
+## Critical Context
+- [Important details needed to continue]
+- [(none) if not applicable]
+
+Keep it concise, but preserve exact file paths, function names, and error messages.`;
+
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are new conversation messages to incorporate into the existing summary provided below.
+
+Update the existing structured summary with new information. Rules:
+- Preserve still-relevant information from the previous summary
+- Add new progress, decisions, and critical context
+- Move completed items from "In Progress" to "Done" when appropriate
+- Update "Next Steps" based on the current state
+- Preserve exact file paths, function names, and error messages
+
+Use the exact same section structure as the existing summary format.`;
+
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the early prefix of a single turn that was too large to keep in full. The recent suffix is still available.
+
+Summarize only what is needed so another coding agent can understand the retained suffix.
+
+Use this exact format:
+
+## Original Request
+[What the user asked for in this turn]
+
+## Early Progress
+- [Key work done before the kept suffix]
+
+## Context For Suffix
+- [Information needed to understand the kept recent messages]`;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function getTextParts(content: unknown): string[] {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    if (part.type === "text" && typeof part.text === "string") {
+      parts.push(part.text);
+      continue;
+    }
+    if (part.type === "reasoning" && typeof part.text === "string") {
+      if (!containsEncryptedReasoning(part.text)) {
+        parts.push(part.text);
+      }
+      continue;
+    }
+    if (part.type === "reasoning" && typeof part.reasoning === "string") {
+      if (!containsEncryptedReasoning(part.reasoning)) {
+        parts.push(part.reasoning);
+      }
+    }
+  }
+  return parts;
+}
+
+function stringifyForSummary(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+function truncateForSummary(text: string, maxChars = TOOL_RESULT_MAX_CHARS): string {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n\n[... ${text.length - maxChars} more characters truncated]`;
+}
+
+function extractUserContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    if (part.type === "text" && typeof part.text === "string") {
+      parts.push(part.text);
+      continue;
+    }
+    if (part.type === "image") {
+      parts.push("[Image]");
+      continue;
+    }
+    if (part.type === "file") {
+      const filename = typeof part.filename === "string" ? part.filename : null;
+      parts.push(filename ? `[File: ${filename}]` : "[File]");
+    }
+  }
+  return parts.join("\n");
+}
+
+function extractAssistantText(content: unknown): string {
+  return getTextParts(content).join("\n");
+}
+
+function extractToolCallText(content: unknown): string[] {
+  if (!Array.isArray(content)) return [];
+
+  const toolCalls: string[] = [];
+  for (const part of content) {
+    if (!isRecord(part) || part.type !== "tool-call") continue;
+    const toolName = typeof part.toolName === "string" ? part.toolName : "tool";
+    const input = isRecord(part.input) ? part.input : {};
+    const args = Object.entries(input)
+      .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+      .join(", ");
+    toolCalls.push(`${toolName}(${args})`);
+  }
+  return toolCalls;
+}
+
+function extractToolResultText(content: unknown): string[] {
+  if (!Array.isArray(content)) return [];
+
+  const toolResults: string[] = [];
+  for (const part of content) {
+    if (!isRecord(part) || part.type !== "tool-result") continue;
+    toolResults.push(truncateForSummary(stringifyForSummary(part.output)));
+  }
+  return toolResults;
+}
+
+export function createCompactionSummaryMessage(summary: string): ModelMessage {
+  return {
+    role: "system",
+    content: `${COMPACTION_SUMMARY_HEADER}\n${summary.trim()}`,
+  };
+}
+
+export function isCompactionSummaryMessage(message: ModelMessage | undefined): boolean {
+  return message?.role === "system" && typeof message.content === "string"
+    ? message.content.startsWith(COMPACTION_SUMMARY_HEADER)
+    : false;
+}
+
+export function getCompactionSummaryText(message: ModelMessage | undefined): string | null {
+  if (!isCompactionSummaryMessage(message) || typeof message?.content !== "string") {
+    return null;
+  }
+  return message.content.slice(COMPACTION_SUMMARY_HEADER.length).trim();
+}
+
+export function estimateMessageTokens(message: ModelMessage): number {
+  let chars = 0;
+
+  switch (message.role) {
+    case "user":
+      chars += extractUserContent(message.content).length;
+      break;
+    case "assistant":
+      chars += extractAssistantText(message.content).length;
+      chars += extractToolCallText(message.content).join("; ").length;
+      break;
+    case "tool":
+      chars += extractToolResultText(message.content).join("\n").length;
+      break;
+    case "system":
+      chars +=
+        typeof message.content === "string" ? message.content.length : getTextParts(message.content).join("\n").length;
+      break;
+    default:
+      chars += stringifyForSummary((message as { content?: unknown }).content).length;
+      break;
+  }
+
+  return Math.ceil(chars / 4);
+}
+
+export function estimateConversationTokens(systemPrompt: string, messages: ModelMessage[], inFlightText = ""): number {
+  const systemTokens = Math.ceil((systemPrompt.length + inFlightText.length) / 4);
+  return systemTokens + messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+}
+
+export function shouldCompactContext(
+  contextTokens: number,
+  contextWindow: number,
+  settings: CompactionSettings,
+): boolean {
+  return contextTokens > contextWindow - settings.reserveTokens;
+}
+
+function isValidCutPoint(message: ModelMessage): boolean {
+  return message.role !== "tool";
+}
+
+function findTurnStartIndex(messages: ModelMessage[], entryIndex: number, startIndex: number): number {
+  for (let i = entryIndex; i >= startIndex; i--) {
+    if (messages[i]?.role === "user") {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export function findCutPoint(messages: ModelMessage[], startIndex: number, keepRecentTokens: number): CutPointResult {
+  const cutPoints: number[] = [];
+  for (let i = startIndex; i < messages.length; i++) {
+    if (isValidCutPoint(messages[i])) {
+      cutPoints.push(i);
+    }
+  }
+
+  if (cutPoints.length === 0) {
+    return { firstKeptIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+  }
+
+  let accumulatedTokens = 0;
+  let cutIndex = cutPoints[0];
+
+  for (let i = messages.length - 1; i >= startIndex; i--) {
+    accumulatedTokens += estimateMessageTokens(messages[i]);
+    if (accumulatedTokens >= keepRecentTokens) {
+      cutIndex = cutPoints.find((index) => index >= i) ?? cutPoints[cutPoints.length - 1];
+      break;
+    }
+  }
+
+  const cutMessage = messages[cutIndex];
+  const isUserMessage = cutMessage?.role === "user";
+  const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(messages, cutIndex, startIndex);
+
+  return {
+    firstKeptIndex: cutIndex,
+    turnStartIndex,
+    isSplitTurn: !isUserMessage && turnStartIndex !== -1,
+  };
+}
+
+export function prepareCompaction(
+  messages: ModelMessage[],
+  systemPrompt: string,
+  settings: CompactionSettings,
+): PreparedCompaction | null {
+  const previousSummary = getCompactionSummaryText(messages[0]) ?? undefined;
+  const boundaryStart = previousSummary ? 1 : 0;
+  if (boundaryStart >= messages.length) {
+    return null;
+  }
+
+  const cutPoint = findCutPoint(messages, boundaryStart, settings.keepRecentTokens);
+  const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptIndex;
+  const messagesToSummarize = messages.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
+  const turnPrefixMessages = cutPoint.isSplitTurn
+    ? messages.slice(cutPoint.turnStartIndex, cutPoint.firstKeptIndex)
+    : [];
+  const keptMessages = messages.slice(cutPoint.firstKeptIndex);
+  const tokensBefore = estimateConversationTokens(systemPrompt, messages);
+
+  if (keptMessages.length === 0) {
+    return null;
+  }
+
+  if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
+    return null;
+  }
+
+  return {
+    previousSummary,
+    messagesToSummarize,
+    turnPrefixMessages,
+    keptMessages,
+    firstKeptIndex: cutPoint.firstKeptIndex,
+    isSplitTurn: cutPoint.isSplitTurn,
+    tokensBefore,
+    settings,
+  };
+}
+
+export function relaxCompactionSettings(settings: CompactionSettings): CompactionSettings {
+  return {
+    ...settings,
+    keepRecentTokens: Math.max(MIN_KEPT_TOKENS_ON_RETRY, Math.floor(settings.keepRecentTokens / 2)),
+  };
+}
+
+export function serializeConversation(messages: ModelMessage[]): string {
+  const parts: string[] = [];
+
+  for (const message of messages) {
+    if (isCompactionSummaryMessage(message)) {
+      const summary = getCompactionSummaryText(message);
+      if (summary) {
+        parts.push(`[Previous summary]: ${summary}`);
+      }
+      continue;
+    }
+
+    if (message.role === "user") {
+      const content = extractUserContent(message.content).trim();
+      if (content) parts.push(`[User]: ${content}`);
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      const text = extractAssistantText(message.content).trim();
+      const toolCalls = extractToolCallText(message.content);
+      if (text) parts.push(`[Assistant]: ${text}`);
+      if (toolCalls.length > 0) parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+      continue;
+    }
+
+    if (message.role === "tool") {
+      const results = extractToolResultText(message.content);
+      for (const result of results) {
+        if (result.trim()) parts.push(`[Tool result]: ${result}`);
+      }
+      continue;
+    }
+
+    if (message.role === "system") {
+      const content =
+        typeof message.content === "string" ? message.content.trim() : getTextParts(message.content).join("\n").trim();
+      if (content) parts.push(`[System]: ${content}`);
+    }
+  }
+
+  return parts.join("\n\n");
+}
+
+async function summarizeConversation(
+  provider: LegacyProvider,
+  modelId: string,
+  messages: ModelMessage[],
+  reserveTokens: number,
+  customInstructions?: string,
+  previousSummary?: string,
+  promptOverride?: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const serialized = serializeConversation(messages);
+  const promptParts = [serialized];
+
+  if (previousSummary) {
+    promptParts.push(`Existing summary:\n${previousSummary}`);
+  }
+
+  const basePrompt = promptOverride ?? (previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT);
+  promptParts.push(basePrompt);
+
+  if (customInstructions?.trim()) {
+    promptParts.push(`Additional focus: ${customInstructions.trim()}`);
+  }
+
+  const runtime = resolveModelRuntime(provider, modelId);
+  const { text } = await generateText({
+    model: runtime.model,
+    system: SUMMARIZATION_SYSTEM_PROMPT,
+    prompt: promptParts.filter(Boolean).join("\n\n"),
+    abortSignal: signal,
+    maxRetries: 0,
+    temperature: 0.2,
+    ...(runtime.modelInfo?.supportsMaxOutputTokens === false
+      ? {}
+      : { maxOutputTokens: Math.max(512, Math.floor(reserveTokens * 0.8)) }),
+    ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
+  });
+
+  return text.trim();
+}
+
+export async function generateCompactionSummary(
+  provider: LegacyProvider,
+  modelId: string,
+  preparation: PreparedCompaction,
+  customInstructions?: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const { messagesToSummarize, turnPrefixMessages, isSplitTurn, previousSummary, settings } = preparation;
+
+  if (isSplitTurn && turnPrefixMessages.length > 0) {
+    const [historySummary, prefixSummary] = await Promise.all([
+      messagesToSummarize.length > 0
+        ? summarizeConversation(
+            provider,
+            modelId,
+            messagesToSummarize,
+            settings.reserveTokens,
+            customInstructions,
+            previousSummary,
+            undefined,
+            signal,
+          )
+        : Promise.resolve(previousSummary?.trim() || ""),
+      summarizeConversation(
+        provider,
+        modelId,
+        turnPrefixMessages,
+        settings.reserveTokens,
+        undefined,
+        undefined,
+        TURN_PREFIX_SUMMARIZATION_PROMPT,
+        signal,
+      ),
+    ]);
+
+    if (historySummary && prefixSummary) {
+      return `${historySummary}\n\n---\n\n${prefixSummary}`;
+    }
+    return (historySummary || prefixSummary).trim();
+  }
+
+  return summarizeConversation(
+    provider,
+    modelId,
+    messagesToSummarize,
+    settings.reserveTokens,
+    customInstructions,
+    previousSummary,
+    undefined,
+    signal,
+  );
+}