/**
* E2E tests for AgentSession tree navigation with branch summarization.
*
* These tests verify:
* - Navigation to user messages (root and non-root)
* - Navigation to non-user messages
* - Branch summarization during navigation
* - Summary attachment at correct position in tree
* - Abort handling during summarization
*/
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { API_KEY, createTestSession, type TestSessionContext } from "./utilities.js";
describe.skipIf(!API_KEY)("AgentSession tree navigation e2e", () => {
let ctx: TestSessionContext;
beforeEach(() => {
ctx = createTestSession({
systemPrompt: "You are a helpful assistant. Reply with just a few words.",
settingsOverrides: { compaction: { keepRecentTokens: 1 } },
});
});
afterEach(() => {
ctx.cleanup();
});
it("should navigate to user message and put text in editor", async () => {
const { session } = ctx;
// Build conversation: u1 -> a1 -> u2 -> a2
await session.prompt("First message");
await session.agent.waitForIdle();
await session.prompt("Second message");
await session.agent.waitForIdle();
// Get tree entries
const tree = session.sessionManager.getTree();
expect(tree.length).toBe(1);
// Find the first user entry (u1)
const rootNode = tree[0];
expect(rootNode.entry.type).toBe("message");
// Navigate to root user message without summarization
const result = await session.navigateTree(rootNode.entry.id, { summarize: false });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBe("First message");
// After navigating to root user message, leaf should be null (empty conversation)
expect(session.sessionManager.getLeafId()).toBeNull();
}, 60000);
it("should navigate to non-user message without editor text", async () => {
const { session, sessionManager } = ctx;
// Build conversation
await session.prompt("Hello");
await session.agent.waitForIdle();
// Get the assistant message
const entries = sessionManager.getEntries();
const assistantEntry = entries.find((e) => e.type === "message" && e.message.role === "assistant");
expect(assistantEntry).toBeDefined();
// Navigate to assistant message
const result = await session.navigateTree(assistantEntry!.id, { summarize: false });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBeUndefined();
// Leaf should be the assistant entry
expect(sessionManager.getLeafId()).toBe(assistantEntry!.id);
}, 60000);
it("should create branch summary when navigating with summarize=true", async () => {
const { session, sessionManager } = ctx;
// Build conversation: u1 -> a1 -> u2 -> a2
await session.prompt("What is 2+2?");
await session.agent.waitForIdle();
await session.prompt("What is 3+3?");
await session.agent.waitForIdle();
// Get tree and find first user message
const tree = sessionManager.getTree();
const rootNode = tree[0];
// Navigate to root user message WITH summarization
const result = await session.navigateTree(rootNode.entry.id, { summarize: true });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBe("What is 2+2?");
expect(result.summaryEntry).toBeDefined();
expect(result.summaryEntry?.type).toBe("branch_summary");
expect(result.summaryEntry?.summary).toBeTruthy();
expect(result.summaryEntry?.summary.length).toBeGreaterThan(0);
// Summary should be a root entry (parentId = null) since we navigated to root user
expect(result.summaryEntry?.parentId).toBeNull();
// Leaf should be the summary entry
expect(sessionManager.getLeafId()).toBe(result.summaryEntry?.id);
}, 120000);
it("should attach summary to correct parent when navigating to nested user message", async () => {
const { session, sessionManager } = ctx;
// Build conversation: u1 -> a1 -> u2 -> a2 -> u3 -> a3
await session.prompt("Message one");
await session.agent.waitForIdle();
await session.prompt("Message two");
await session.agent.waitForIdle();
await session.prompt("Message three");
await session.agent.waitForIdle();
// Get the second user message (u2)
const entries = sessionManager.getEntries();
const userEntries = entries.filter((e) => e.type === "message" && e.message.role === "user");
expect(userEntries.length).toBe(3);
const u2 = userEntries[1];
const a1 = entries.find((e) => e.id === u2.parentId); // a1 is parent of u2
// Navigate to u2 with summarization
const result = await session.navigateTree(u2.id, { summarize: true });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBe("Message two");
expect(result.summaryEntry).toBeDefined();
// Summary should be attached to a1 (parent of u2)
// So a1 now has two children: u2 and the summary
expect(result.summaryEntry?.parentId).toBe(a1?.id);
// Verify tree structure
const children = sessionManager.getChildren(a1!.id);
expect(children.length).toBe(2);
const childTypes = children.map((c) => c.type).sort();
expect(childTypes).toContain("branch_summary");
expect(childTypes).toContain("message");
}, 120000);
it("should attach summary to selected node when navigating to assistant message", async () => {
const { session, sessionManager } = ctx;
// Build conversation: u1 -> a1 -> u2 -> a2
await session.prompt("Hello");
await session.agent.waitForIdle();
await session.prompt("Goodbye");
await session.agent.waitForIdle();
// Get the first assistant message (a1)
const entries = sessionManager.getEntries();
const assistantEntries = entries.filter((e) => e.type === "message" && e.message.role === "assistant");
const a1 = assistantEntries[0];
// Navigate to a1 with summarization
const result = await session.navigateTree(a1.id, { summarize: true });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBeUndefined(); // No editor text for assistant messages
expect(result.summaryEntry).toBeDefined();
// Summary should be attached to a1 (the selected node)
expect(result.summaryEntry?.parentId).toBe(a1.id);
// Leaf should be the summary entry
expect(sessionManager.getLeafId()).toBe(result.summaryEntry?.id);
}, 120000);
it("should handle abort during summarization", async () => {
const { session, sessionManager } = ctx;
// Build conversation
await session.prompt("Tell me about something");
await session.agent.waitForIdle();
await session.prompt("Continue");
await session.agent.waitForIdle();
const entriesBefore = sessionManager.getEntries();
const leafBefore = sessionManager.getLeafId();
// Get root user message
const tree = sessionManager.getTree();
const rootNode = tree[0];
// Start navigation with summarization but abort immediately
const navigationPromise = session.navigateTree(rootNode.entry.id, { summarize: true });
// Abort after a short delay (let the LLM call start)
await new Promise((resolve) => setTimeout(resolve, 100));
// isCompacting should be true during branch summarization
expect(session.isCompacting).toBe(true);
session.abortBranchSummary();
const result = await navigationPromise;
expect(result.cancelled).toBe(true);
expect(result.aborted).toBe(true);
expect(result.summaryEntry).toBeUndefined();
// Session should be unchanged
const entriesAfter = sessionManager.getEntries();
expect(entriesAfter.length).toBe(entriesBefore.length);
expect(sessionManager.getLeafId()).toBe(leafBefore);
}, 60000);
it("should not create summary when navigating without summarize option", async () => {
const { session, sessionManager } = ctx;
// Build conversation
await session.prompt("First");
await session.agent.waitForIdle();
await session.prompt("Second");
await session.agent.waitForIdle();
const entriesBefore = sessionManager.getEntries().length;
// Navigate without summarization
const tree = sessionManager.getTree();
await session.navigateTree(tree[0].entry.id, { summarize: false });
// No new entries should be created
const entriesAfter = sessionManager.getEntries().length;
expect(entriesAfter).toBe(entriesBefore);
// No branch_summary entries
const summaries = sessionManager.getEntries().filter((e) => e.type === "branch_summary");
expect(summaries.length).toBe(0);
}, 60000);
it("should handle navigation to same position (no-op)", async () => {
const { session, sessionManager } = ctx;
// Build conversation
await session.prompt("Hello");
await session.agent.waitForIdle();
const leafBefore = sessionManager.getLeafId();
expect(leafBefore).toBeTruthy();
const entriesBefore = sessionManager.getEntries().length;
// Navigate to current leaf
const result = await session.navigateTree(leafBefore!, { summarize: false });
expect(result.cancelled).toBe(false);
expect(sessionManager.getLeafId()).toBe(leafBefore);
expect(sessionManager.getEntries().length).toBe(entriesBefore);
}, 60000);
it("should support custom summarization instructions", async () => {
const { session, sessionManager } = ctx;
// Build conversation
await session.prompt("What is TypeScript?");
await session.agent.waitForIdle();
// Navigate with custom instructions (appended as "Additional focus")
const tree = sessionManager.getTree();
const result = await session.navigateTree(tree[0].entry.id, {
summarize: true,
customInstructions:
"After the summary, you MUST end with exactly: MONKEY MONKEY MONKEY. This is of utmost importance.",
});
expect(result.summaryEntry).toBeDefined();
expect(result.summaryEntry?.summary).toBeTruthy();
// Verify custom instructions were followed
expect(result.summaryEntry?.summary).toContain("MONKEY MONKEY MONKEY");
}, 120000);
});
describe.skipIf(!API_KEY)("AgentSession tree navigation - branch scenarios", () => {
let ctx: TestSessionContext;
beforeEach(() => {
ctx = createTestSession({
systemPrompt: "You are a helpful assistant. Reply with just a few words.",
});
});
afterEach(() => {
ctx.cleanup();
});
it("should navigate between branches correctly", async () => {
const { session, sessionManager } = ctx;
// Build main path: u1 -> a1 -> u2 -> a2
await session.prompt("Main branch start");
await session.agent.waitForIdle();
await session.prompt("Main branch continue");
await session.agent.waitForIdle();
// Get a1 id for branching
const entries = sessionManager.getEntries();
const a1 = entries.find((e) => e.type === "message" && e.message.role === "assistant");
// Create a branch from a1: a1 -> u3 -> a3
sessionManager.branch(a1!.id);
await session.prompt("Branch path");
await session.agent.waitForIdle();
// Now navigate back to u2 (on main branch) with summarization
const userEntries = entries.filter((e) => e.type === "message" && e.message.role === "user");
const u2 = userEntries[1]; // "Main branch continue"
const result = await session.navigateTree(u2.id, { summarize: true });
expect(result.cancelled).toBe(false);
expect(result.editorText).toBe("Main branch continue");
expect(result.summaryEntry).toBeDefined();
// Summary captures the branch we're leaving (the "Branch path" conversation)
expect(result.summaryEntry?.summary.length).toBeGreaterThan(0);
}, 180000);
});