@@ -26,7 +26,9 @@ import {
2626 import { type AgentEvent, runAgentLoop, type ToolHandler } from "./agent.ts";
2727 import {
2828 appendMessage,
29+ computeSessionStats,
2930 createSession,
31+ loadCompactedModelMessages,
3032 loadMessages,
3133 openDatabase,
3234 } from "./session.ts";
@@ -2078,6 +2080,497 @@ describe("agent loop", () => {
20782080 }
20792081 });
20802082
2083+ test("text-only image sanitization does not trigger unnecessary compaction from stale assistant usage", async () => {
2084+ const api = "test/text-only-image-compaction";
2085+ const sourceId = "test-text-only-image-compaction";
2086+ const model: Model<string> = {
2087+ id: api,
2088+ name: "Text Only Image Compaction Model",
2089+ api,
2090+ provider: "test",
2091+ baseUrl: "http://localhost:0",
2092+ reasoning: false,
2093+ input: ["text"],
2094+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
2095+ contextWindow: 1_500,
2096+ maxTokens: 4_096,
2097+ };
2098+ const compactionRequests: Message[][] = [];
2099+ const mainRequests: Message[][] = [];
2100+
2101+ const buildProviderStream = (context: Context) => {
2102+ const isCompaction = (context.systemPrompt ?? "").includes(
2103+ "You summarize earlier conversation context for a coding agent.",
2104+ );
2105+ if (isCompaction) {
2106+ compactionRequests.push(structuredClone(context.messages));
2107+ } else {
2108+ mainRequests.push(structuredClone(context.messages));
2109+ }
2110+
2111+ const stream = createAssistantMessageEventStream();
2112+ const finalMessage = fauxAssistantMessage("done");
2113+ queueMicrotask(() => {
2114+ stream.push({ type: "done", reason: "stop", message: finalMessage });
2115+ stream.end(finalMessage);
2116+ });
2117+ return stream;
2118+ };
2119+
2120+ registerApiProvider(
2121+ {
2122+ api,
2123+ stream: (_model, context) => buildProviderStream(context),
2124+ streamSimple: (_model, context) => buildProviderStream(context),
2125+ },
2126+ sourceId,
2127+ );
2128+
2129+ try {
2130+ const session = createSession(db, { cwd: tmp });
2131+ const firstUser = makeUser("inspect the screenshot");
2132+ const firstTurn = appendMessage(db, session.id, firstUser);
2133+ const imageResult = makeImageToolResultMessage(1);
2134+ appendMessage(db, session.id, imageResult, firstTurn);
2135+ const historicalAssistant: AssistantMessage = {
2136+ ...fauxAssistantMessage("historical reply"),
2137+ api,
2138+ provider: "test",
2139+ model: api,
2140+ usage: {
2141+ ...ZERO_USAGE,
2142+ input: 2_400,
2143+ totalTokens: 2_400,
2144+ cost: { ...ZERO_USAGE.cost },
2145+ },
2146+ };
2147+ appendMessage(db, session.id, historicalAssistant, firstTurn);
2148+ const currentUser = makeUser("continue without using vision");
2149+ const turn = appendMessage(db, session.id, currentUser);
2150+
2151+ const result = await runAgentLoop({
2152+ db,
2153+ sessionId: session.id,
2154+ turn,
2155+ model,
2156+ systemPrompt: "Test",
2157+ tools: [],
2158+ toolHandlers: new Map(),
2159+ messages: [firstUser, imageResult, historicalAssistant, currentUser],
2160+ cwd: tmp,
2161+ });
2162+
2163+ expect(result.stopReason).toBe("stop");
2164+ expect(compactionRequests).toEqual([]);
2165+ expect(mainRequests).toHaveLength(1);
2166+ const sanitizedImageResult = mainRequests[0]?.[1];
2167+ if (
2168+ !sanitizedImageResult ||
2169+ sanitizedImageResult.role !== "toolResult" ||
2170+ !Array.isArray(sanitizedImageResult.content)
2171+ ) {
2172+ throw new Error("Expected the sanitized image tool result in context");
2173+ }
2174+ expect(sanitizedImageResult.content).toEqual([
2175+ {
2176+ type: "text",
2177+ text: "[Image omitted from model context because the active model does not support image input.]",
2178+ },
2179+ ]);
2180+ } finally {
2181+ unregisterApiProviders(sourceId);
2182+ }
2183+ });
2184+
2185+ test("context_compacted events and persisted session stats include hidden summary usage", async () => {
2186+ const api = "test/context-compaction-usage";
2187+ const sourceId = "test-context-compaction-usage";
2188+ const model: Model<string> = {
2189+ id: api,
2190+ name: "Context Compaction Usage Model",
2191+ api,
2192+ provider: "test",
2193+ baseUrl: "http://localhost:0",
2194+ reasoning: false,
2195+ input: ["text"],
2196+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
2197+ contextWindow: 250,
2198+ maxTokens: 4096,
2199+ };
2200+ const events: AgentEvent[] = [];
2201+ let compactionCallCount = 0;
2202+ let compactionInput = 0;
2203+ let compactionOutput = 0;
2204+ let compactionCost = 0;
2205+
2206+ const buildProviderStream = (context: Context) => {
2207+ const isCompaction = (context.systemPrompt ?? "").includes(
2208+ "You summarize earlier conversation context for a coding agent.",
2209+ );
2210+ const stream = createAssistantMessageEventStream();
2211+ const finalMessage = isCompaction
2212+ ? {
2213+ ...fauxAssistantMessage(`summary ${++compactionCallCount}`),
2214+ usage: {
2215+ input: 123,
2216+ output: 45,
2217+ cacheRead: 0,
2218+ cacheWrite: 0,
2219+ totalTokens: 168,
2220+ cost: {
2221+ input: 1,
2222+ output: 2,
2223+ cacheRead: 0,
2224+ cacheWrite: 0,
2225+ total: 3,
2226+ },
2227+ },
2228+ }
2229+ : {
2230+ ...fauxAssistantMessage("done"),
2231+ usage: {
2232+ input: 10,
2233+ output: 2,
2234+ cacheRead: 0,
2235+ cacheWrite: 0,
2236+ totalTokens: 12,
2237+ cost: {
2238+ input: 0.1,
2239+ output: 0.2,
2240+ cacheRead: 0,
2241+ cacheWrite: 0,
2242+ total: 0.3,
2243+ },
2244+ },
2245+ };
2246+
2247+ if (isCompaction) {
2248+ compactionInput += finalMessage.usage.input;
2249+ compactionOutput += finalMessage.usage.output;
2250+ compactionCost += finalMessage.usage.cost.total;
2251+ }
2252+
2253+ queueMicrotask(() => {
2254+ stream.push({ type: "done", reason: "stop", message: finalMessage });
2255+ stream.end(finalMessage);
2256+ });
2257+
2258+ return stream;
2259+ };
2260+
2261+ registerApiProvider(
2262+ {
2263+ api,
2264+ stream: (_model, context) => buildProviderStream(context),
2265+ streamSimple: (_model, context) => buildProviderStream(context),
2266+ },
2267+ sourceId,
2268+ );
2269+
2270+ try {
2271+ const session = createSession(db, { cwd: tmp });
2272+ const messages: Message[] = [];
2273+ let turn = 0;
2274+
2275+ for (let index = 0; index < 7; index += 1) {
2276+ const userMsg = makeUser(`request ${index} ${"x".repeat(380)}`);
2277+ turn = appendMessage(db, session.id, userMsg);
2278+ messages.push(userMsg);
2279+ }
2280+
2281+ const result = await runAgentLoop({
2282+ db,
2283+ sessionId: session.id,
2284+ turn,
2285+ model,
2286+ systemPrompt: "Test",
2287+ tools: [],
2288+ toolHandlers: new Map(),
2289+ messages,
2290+ cwd: tmp,
2291+ onEvent: (event) => events.push(event),
2292+ });
2293+
2294+ expect(result.stopReason).toBe("stop");
2295+ const compactionEvents = events.filter(
2296+ (
2297+ event,
2298+ ): event is Extract<AgentEvent, { type: "context_compacted" }> => {
2299+ return event.type === "context_compacted";
2300+ },
2301+ );
2302+ expect(compactionEvents.length).toBe(compactionCallCount);
2303+ expect(compactionEvents.length).toBeGreaterThan(0);
2304+ expect(compactionEvents.at(-1)?.stats).toEqual({
2305+ totalInput: compactionInput,
2306+ totalOutput: compactionOutput,
2307+ totalCost: compactionCost,
2308+ });
2309+ expect(computeSessionStats(db, session.id)).toEqual({
2310+ totalInput: compactionInput + 10,
2311+ totalOutput: compactionOutput + 2,
2312+ totalCost: compactionCost + 0.3,
2313+ });
2314+ } finally {
2315+ unregisterApiProviders(sourceId);
2316+ }
2317+ });
2318+
2319+ test("context compaction summarizes older messages without re-compacting earlier summaries", async () => {
2320+ const api = "test/context-compaction";
2321+ const sourceId = "test-context-compaction";
2322+ const model: Model<string> = {
2323+ id: api,
2324+ name: "Context Compaction Model",
2325+ api,
2326+ provider: "test",
2327+ baseUrl: "http://localhost:0",
2328+ reasoning: false,
2329+ input: ["text"],
2330+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
2331+ contextWindow: 250,
2332+ maxTokens: 4096,
2333+ };
2334+ const compactionRequests: Message[][] = [];
2335+ const mainRequests: Message[][] = [];
2336+ let compactionCallCount = 0;
2337+
2338+ const buildProviderStream = (context: Context) => {
2339+ const isCompaction = (context.systemPrompt ?? "").includes(
2340+ "You summarize earlier conversation context for a coding agent.",
2341+ );
2342+ if (isCompaction) {
2343+ compactionRequests.push(structuredClone(context.messages));
2344+ compactionCallCount += 1;
2345+ } else {
2346+ mainRequests.push(structuredClone(context.messages));
2347+ }
2348+
2349+ const stream = createAssistantMessageEventStream();
2350+ const finalMessage = isCompaction
2351+ ? fauxAssistantMessage(`summary ${compactionCallCount}`)
2352+ : fauxAssistantMessage("done");
2353+
2354+ queueMicrotask(() => {
2355+ stream.push({ type: "done", reason: "stop", message: finalMessage });
2356+ stream.end(finalMessage);
2357+ });
2358+
2359+ return stream;
2360+ };
2361+
2362+ registerApiProvider(
2363+ {
2364+ api,
2365+ stream: (_model, context) => buildProviderStream(context),
2366+ streamSimple: (_model, context) => buildProviderStream(context),
2367+ },
2368+ sourceId,
2369+ );
2370+
2371+ try {
2372+ const session = createSession(db, { cwd: tmp });
2373+ const messages: Message[] = [];
2374+ let turn = 0;
2375+
2376+ for (let index = 0; index < 7; index += 1) {
2377+ const label =
2378+ index === 6 ? "current request" : `earlier request ${index}`;
2379+ const userMsg = makeUser(`${label} ${"x".repeat(380)}`);
2380+ turn = appendMessage(db, session.id, userMsg);
2381+ messages.push(userMsg);
2382+ }
2383+
2384+ const result = await runAgentLoop({
2385+ db,
2386+ sessionId: session.id,
2387+ turn,
2388+ model,
2389+ systemPrompt: "Test",
2390+ tools: [],
2391+ toolHandlers: new Map(),
2392+ messages,
2393+ cwd: tmp,
2394+ });
2395+
2396+ expect(result.stopReason).toBe("stop");
2397+ expect(compactionRequests.length).toBeGreaterThanOrEqual(2);
2398+ expect(mainRequests).toHaveLength(1);
2399+
2400+ const firstInstruction = compactionRequests[0]?.at(-1);
2401+ if (!firstInstruction || firstInstruction.role !== "user") {
2402+ throw new Error("Expected the first compaction instruction message");
2403+ }
2404+ if (typeof firstInstruction.content !== "string") {
2405+ throw new Error("Expected the first compaction instruction to be text");
2406+ }
2407+ expect(firstInstruction.content).toContain("Current user request:");
2408+ expect(firstInstruction.content).toContain("current request");
2409+
2410+ const secondCompaction = compactionRequests[1]!;
2411+ expect(
2412+ secondCompaction.some(
2413+ (message) =>
2414+ message.role === "user" &&
2415+ typeof message.content === "string" &&
2416+ message.content.includes("summary 1"),
2417+ ),
2418+ ).toBe(false);
2419+
2420+ const compactedContext = mainRequests[0]!;
2421+ const summaryMessages = compactedContext.filter(
2422+ (message): message is UserMessage =>
2423+ message.role === "user" &&
2424+ typeof message.content === "string" &&
2425+ message.content.includes("<system-message>"),
2426+ );
2427+ expect(summaryMessages.length).toBeGreaterThan(0);
2428+ expect(summaryMessages[0]!.content).toContain("summary 1");
2429+ expect(summaryMessages[0]!.content).toContain(session.id);
2430+ expect(summaryMessages[0]!.content).toContain(":memory:");
2431+ expect(
2432+ compactedContext.some(
2433+ (message) =>
2434+ message.role === "user" &&
2435+ typeof message.content === "string" &&
2436+ message.content.includes("earlier request 0"),
2437+ ),
2438+ ).toBe(false);
2439+ expect(
2440+ loadMessages(db, session.id).some(
2441+ (message) =>
2442+ message.role === "user" &&
2443+ typeof message.content === "string" &&
2444+ message.content.includes("earlier request 0"),
2445+ ),
2446+ ).toBe(true);
2447+ expect(
2448+ loadCompactedModelMessages(db, session.id).some(
2449+ (message) =>
2450+ message.role === "user" &&
2451+ typeof message.content === "string" &&
2452+ message.content.includes("<system-message>"),
2453+ ),
2454+ ).toBe(true);
2455+ } finally {
2456+ unregisterApiProviders(sourceId);
2457+ }
2458+ });
2459+
2460+ test("repeated compactions stay anchored to the active user request after that request is compacted", async () => {
2461+ const api = "test/context-compaction-anchor";
2462+ const sourceId = "test-context-compaction-anchor";
2463+ const model: Model<string> = {
2464+ id: api,
2465+ name: "Context Compaction Anchor Model",
2466+ api,
2467+ provider: "test",
2468+ baseUrl: "http://localhost:0",
2469+ reasoning: false,
2470+ input: ["text"],
2471+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
2472+ contextWindow: 250,
2473+ maxTokens: 4096,
2474+ };
2475+ const currentRequestAnchor = "current request anchor";
2476+ const compactionInstructions: string[] = [];
2477+ let compactionCallCount = 0;
2478+
2479+ const buildProviderStream = (context: Context) => {
2480+ const isCompaction = (context.systemPrompt ?? "").includes(
2481+ "You summarize earlier conversation context for a coding agent.",
2482+ );
2483+ if (isCompaction) {
2484+ const instruction = context.messages.at(-1);
2485+ if (
2486+ instruction?.role === "user" &&
2487+ typeof instruction.content === "string"
2488+ ) {
2489+ compactionInstructions.push(instruction.content);
2490+ }
2491+ compactionCallCount += 1;
2492+ }
2493+
2494+ const stream = createAssistantMessageEventStream();
2495+ const finalMessage = isCompaction
2496+ ? fauxAssistantMessage(`summary ${compactionCallCount}`)
2497+ : fauxAssistantMessage("done");
2498+
2499+ queueMicrotask(() => {
2500+ stream.push({ type: "done", reason: "stop", message: finalMessage });
2501+ stream.end(finalMessage);
2502+ });
2503+
2504+ return stream;
2505+ };
2506+
2507+ registerApiProvider(
2508+ {
2509+ api,
2510+ stream: (_model, context) => buildProviderStream(context),
2511+ streamSimple: (_model, context) => buildProviderStream(context),
2512+ },
2513+ sourceId,
2514+ );
2515+
2516+ try {
2517+ const session = createSession(db, { cwd: tmp });
2518+ const currentRequest = `${currentRequestAnchor} ${"x".repeat(380)}`;
2519+ const userMsg = makeUser(currentRequest);
2520+ const turn = appendMessage(db, session.id, userMsg);
2521+ const messages: Message[] = [userMsg];
2522+
2523+ for (let index = 0; index < 6; index += 1) {
2524+ const assistantMessage: AssistantMessage = {
2525+ ...fauxAssistantMessage(`assistant ${index} ${"a".repeat(380)}`),
2526+ api,
2527+ provider: "test",
2528+ model: api,
2529+ usage: {
2530+ ...ZERO_USAGE,
2531+ input: 250,
2532+ totalTokens: 250,
2533+ cost: { ...ZERO_USAGE.cost },
2534+ },
2535+ };
2536+ const toolResultMessage: Message = {
2537+ role: "toolResult",
2538+ toolCallId: `call-${index}`,
2539+ toolName: "shell",
2540+ content: [{ type: "text", text: `tool ${index} ${"t".repeat(380)}` }],
2541+ isError: false,
2542+ timestamp: Date.now() + 100 + index,
2543+ };
2544+
2545+ appendMessage(db, session.id, assistantMessage, turn);
2546+ appendMessage(db, session.id, toolResultMessage, turn);
2547+ messages.push(assistantMessage, toolResultMessage);
2548+ }
2549+
2550+ const result = await runAgentLoop({
2551+ db,
2552+ sessionId: session.id,
2553+ turn,
2554+ model,
2555+ systemPrompt: "Test",
2556+ tools: [],
2557+ toolHandlers: new Map(),
2558+ messages,
2559+ cwd: tmp,
2560+ });
2561+
2562+ expect(result.stopReason).toBe("stop");
2563+ expect(compactionCallCount).toBeGreaterThanOrEqual(2);
2564+ expect(compactionInstructions).toHaveLength(compactionCallCount);
2565+ for (const instruction of compactionInstructions) {
2566+ expect(instruction).toContain("Current user request:");
2567+ expect(instruction).toContain(currentRequestAnchor);
2568+ }
2569+ } finally {
2570+ unregisterApiProviders(sourceId);
2571+ }
2572+ });
2573+
20812574 test("stopReason 'length' returns without looping", async () => {
20822575 faux.setResponses([
20832576 fauxAssistantMessage("Partial response that hit the token limit", {