Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

test(coding-agent): consolidate session integration coverage (#499)

Sebastian Müller43738d518d64
diff --git a/packages/coding-agent/test/agent-session-branching.test.ts b/packages/coding-agent/test/agent-session-branching.test.ts
deleted file mode 100644
index fa12d5a871..0000000000
--- a/packages/coding-agent/test/agent-session-branching.test.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-/**
- * Tests for AgentSession forking behavior.
- *
- * These tests verify:
- * - Forking from a single message works
- * - Forking in --no-session mode (in-memory only)
- * - getUserMessagesForForking returns correct entries
- */
-
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getModel } from "@earendil-works/pi-ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { AgentSession } from "../src/core/agent-session.js";
-import {
- type AgentSessionRuntime,
- type CreateAgentSessionRuntimeFactory,
- createAgentSessionFromServices,
- createAgentSessionRuntime,
- createAgentSessionServices,
-} from "../src/core/agent-session-runtime.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { API_KEY } from "./utilities.js";
-
-describe.skipIf(!API_KEY)("AgentSession forking", () => {
- let session: AgentSession;
- let runtimeHost: AgentSessionRuntime;
- let tempDir: string;
- let sessionManager: SessionManager;
-
- beforeEach(() => {
- tempDir = join(tmpdir(), `pi-branching-test-${Date.now()}`);
- mkdirSync(tempDir, { recursive: true });
- });
-
- afterEach(async () => {
- if (runtimeHost) {
- await runtimeHost.dispose();
- }
- if (tempDir && existsSync(tempDir)) {
- rmSync(tempDir, { recursive: true });
- }
- });
-
- async function createSession(noSession: boolean = false) {
- const model = getModel("anthropic", "claude-sonnet-4-5")!;
- sessionManager = noSession ? SessionManager.inMemory(tempDir) : SessionManager.create(tempDir);
- const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
- authStorage.setRuntimeApiKey("anthropic", API_KEY!);
-
- const servicesOptions = {
- agentDir: tempDir,
- authStorage,
- resourceLoaderOptions: {
- noExtensions: true,
- noSkills: true,
- noPromptTemplates: true,
- noThemes: true,
- },
- };
- const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
- const services = await createAgentSessionServices({
- ...servicesOptions,
- cwd,
- });
- return {
- ...(await createAgentSessionFromServices({
- services,
- sessionManager,
- sessionStartEvent,
- model,
- tools: ["ipython", "bash", "edit"],
- })),
- services,
- diagnostics: services.diagnostics,
- };
- };
- runtimeHost = await createAgentSessionRuntime(createRuntime, {
- cwd: tempDir,
- agentDir: tempDir,
- sessionManager,
- });
- session = runtimeHost.session;
- session.subscribe(() => {});
- return session;
- }
-
- it("should allow forking from single message", async () => {
- await createSession();
-
- await session.prompt("Say hello");
- await session.agent.waitForIdle();
-
- const userMessages = session.getUserMessagesForForking();
- expect(userMessages.length).toBe(1);
- expect(userMessages[0].text).toBe("Say hello");
-
- const result = await runtimeHost.fork(userMessages[0].entryId);
- expect(result.cancelled).toBe(false);
- session = runtimeHost.session;
- expect(result.selectedText).toBe("Say hello");
-
- expect(session.messages.length).toBe(0);
- expect(session.sessionFile).not.toBeNull();
- expect(existsSync(session.sessionFile!)).toBe(false);
- });
-
- it("should support in-memory forking in --no-session mode", async () => {
- await createSession(true);
-
- expect(session.sessionFile).toBeUndefined();
-
- await session.prompt("Say hi");
- await session.agent.waitForIdle();
-
- const userMessages = session.getUserMessagesForForking();
- expect(userMessages.length).toBe(1);
- expect(session.messages.length).toBeGreaterThan(0);
-
- const result = await runtimeHost.fork(userMessages[0].entryId);
- expect(result.cancelled).toBe(false);
- session = runtimeHost.session;
- expect(result.selectedText).toBe("Say hi");
-
- expect(session.messages.length).toBe(0);
- expect(session.sessionFile).toBeUndefined();
- });
-
- it("should fork from middle of conversation", async () => {
- await createSession();
-
- await session.prompt("Say one");
- await session.agent.waitForIdle();
-
- await session.prompt("Say two");
- await session.agent.waitForIdle();
-
- await session.prompt("Say three");
- await session.agent.waitForIdle();
-
- const userMessages = session.getUserMessagesForForking();
- expect(userMessages.length).toBe(3);
-
- const secondMessage = userMessages[1];
- const result = await runtimeHost.fork(secondMessage.entryId);
- expect(result.cancelled).toBe(false);
- session = runtimeHost.session;
- expect(result.selectedText).toBe("Say two");
-
- expect(session.messages.length).toBe(2);
- expect(session.messages[0].role).toBe("user");
- expect(session.messages[1].role).toBe("assistant");
- }, 60000);
-});
diff --git a/packages/coding-agent/test/agent-session-compaction.test.ts b/packages/coding-agent/test/agent-session-compaction.test.ts
deleted file mode 100644
index f5ad816dd2..0000000000
--- a/packages/coding-agent/test/agent-session-compaction.test.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-/**
- * E2E tests for AgentSession compaction behavior.
- *
- * These tests use real LLM calls (no mocking) to verify:
- * - Manual compaction works correctly
- * - Session persistence during compaction
- * - Compaction entry is saved to session file
- */
-
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Agent } from "@earendil-works/pi-agent-core";
-import { getModel } from "@earendil-works/pi-ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AgentSession, type AgentSessionEvent } from "../src/core/agent-session.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-import { createIpythonTool } from "../src/index.js";
-import { API_KEY, createTestResourceLoader } from "./utilities.js";
-
-describe.skipIf(!API_KEY)("AgentSession compaction e2e", () => {
- let session: AgentSession;
- let tempDir: string;
- let sessionManager: SessionManager;
- let events: AgentSessionEvent[];
-
- beforeEach(() => {
- // Create temp directory for session files
- tempDir = join(tmpdir(), `pi-compaction-test-${Date.now()}`);
- mkdirSync(tempDir, { recursive: true });
-
- // Track events
- events = [];
- });
-
- afterEach(async () => {
- if (session) {
- session.dispose();
- }
- if (tempDir && existsSync(tempDir)) {
- rmSync(tempDir, { recursive: true });
- }
- });
-
- function createSession(inMemory = false) {
- const model = getModel("anthropic", "claude-sonnet-4-5")!;
- const agent = new Agent({
- getApiKey: () => API_KEY,
- initialState: {
- model,
- systemPrompt: "You are a helpful assistant. Be concise.",
- tools: [createIpythonTool(process.cwd())],
- },
- });
-
- sessionManager = inMemory ? SessionManager.inMemory() : SessionManager.create(tempDir);
- const settingsManager = SettingsManager.create(tempDir, tempDir);
- // Use minimal keepRecentTokens so small test conversations have something to summarize
- settingsManager.applyOverrides({ compaction: { keepRecentTokens: 1 } });
- const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
- const modelRegistry = ModelRegistry.create(authStorage);
-
- session = new AgentSession({
- agent,
- sessionManager,
- settingsManager,
- cwd: tempDir,
- modelRegistry,
- resourceLoader: createTestResourceLoader(),
- });
-
- // Subscribe to track events
- session.subscribe((event) => {
- events.push(event);
- });
-
- return session;
- }
-
- it("should trigger manual compaction via compact()", async () => {
- createSession();
-
- // Send a few prompts to build up history
- await session.prompt("What is 2+2? Reply with just the number.");
- await session.agent.waitForIdle();
-
- await session.prompt("What is 3+3? Reply with just the number.");
- await session.agent.waitForIdle();
-
- // Manually compact
- const result = await session.compact();
-
- expect(result.summary).toBeDefined();
- expect(result.summary.length).toBeGreaterThan(0);
- expect(result.tokensBefore).toBeGreaterThan(0);
-
- // Verify messages were compacted (should have summary + recent)
- const messages = session.messages;
- expect(messages.length).toBeGreaterThan(0);
-
- // First message should be the summary (a user message with summary content)
- const firstMsg = messages[0];
- expect(firstMsg.role).toBe("compactionSummary");
- }, 120000);
-
- it("should maintain valid session state after compaction", async () => {
- createSession();
-
- // Build up history
- await session.prompt("What is the capital of France? One word answer.");
- await session.agent.waitForIdle();
-
- await session.prompt("What is the capital of Germany? One word answer.");
- await session.agent.waitForIdle();
-
- // Compact
- await session.compact();
-
- // Session should still be usable
- await session.prompt("What is the capital of Italy? One word answer.");
- await session.agent.waitForIdle();
-
- // Should have messages after compaction
- expect(session.messages.length).toBeGreaterThan(0);
-
- // The agent should have responded
- const assistantMessages = session.messages.filter((m) => m.role === "assistant");
- expect(assistantMessages.length).toBeGreaterThan(0);
- }, 180000);
-
- it("should persist compaction to session file", async () => {
- createSession();
-
- await session.prompt("Say hello");
- await session.agent.waitForIdle();
-
- await session.prompt("Say goodbye");
- await session.agent.waitForIdle();
-
- // Compact
- await session.compact();
-
- // Load entries from session manager
- const entries = sessionManager.getEntries();
-
- // Should have a compaction entry
- const compactionEntries = entries.filter((e) => e.type === "compaction");
- expect(compactionEntries.length).toBe(1);
-
- const compaction = compactionEntries[0];
- expect(compaction.type).toBe("compaction");
- if (compaction.type === "compaction") {
- expect(compaction.summary.length).toBeGreaterThan(0);
- expect(typeof compaction.firstKeptEntryId).toBe("string");
- expect(compaction.tokensBefore).toBeGreaterThan(0);
- }
- }, 120000);
-
- it("should work with --no-session mode (in-memory only)", async () => {
- createSession(true); // in-memory mode
-
- // Send prompts
- await session.prompt("What is 2+2? Reply with just the number.");
- await session.agent.waitForIdle();
-
- await session.prompt("What is 3+3? Reply with just the number.");
- await session.agent.waitForIdle();
-
- // Compact should work even without file persistence
- const result = await session.compact();
-
- expect(result.summary).toBeDefined();
- expect(result.summary.length).toBeGreaterThan(0);
-
- // In-memory entries should have the compaction
- const entries = sessionManager.getEntries();
- const compactionEntries = entries.filter((e) => e.type === "compaction");
- expect(compactionEntries.length).toBe(1);
- }, 120000);
-
- it("should emit compaction events during manual compaction", async () => {
- createSession();
-
- // Build some history
- await session.prompt("Say hello");
- await session.agent.waitForIdle();
-
- // Manually trigger compaction and check events
- await session.compact();
-
- const compactionEvents = events.filter((e) => e.type === "compaction_start" || e.type === "compaction_end");
- expect(compactionEvents).toHaveLength(2);
- expect(compactionEvents[0]).toEqual({ type: "compaction_start", reason: "manual" });
- expect(compactionEvents[1]).toMatchObject({
- type: "compaction_end",
- reason: "manual",
- aborted: false,
- willRetry: false,
- });
-
- // Regular events should have been emitted
- const messageEndEvents = events.filter((e) => e.type === "message_end");
- expect(messageEndEvents.length).toBeGreaterThan(0);
- }, 120000);
-});
diff --git a/packages/coding-agent/test/agent-session-retry.test.ts b/packages/coding-agent/test/agent-session-retry.test.ts
deleted file mode 100644
index a8aa9e73a4..0000000000
--- a/packages/coding-agent/test/agent-session-retry.test.ts
+++ /dev/null
@@ -1,281 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Agent, type AgentEvent } from "@earendil-works/pi-agent-core";
-import { type AssistantMessage, type AssistantMessageEvent, EventStream, getModel } from "@earendil-works/pi-ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AgentSession } from "../src/core/agent-session.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-import { createTestResourceLoader } from "./utilities.js";
-
-class MockAssistantStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
- constructor() {
- super(
- (event) => event.type === "done" || event.type === "error",
- (event) => {
- if (event.type === "done") return event.message;
- if (event.type === "error") return event.error;
- throw new Error("Unexpected event type");
- },
- );
- }
-}
-
-function createAssistantMessage(text: string, overrides?: Partial<AssistantMessage>): AssistantMessage {
- return {
- role: "assistant",
- content: [{ type: "text", text }],
- api: "anthropic-messages",
- provider: "anthropic",
- model: "mock",
- usage: {
- input: 0,
- output: 0,
- cacheRead: 0,
- cacheWrite: 0,
- totalTokens: 0,
- cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
- },
- stopReason: "stop",
- timestamp: Date.now(),
- ...overrides,
- };
-}
-
-type SessionWithExtensionEmitHook = {
- _emitExtensionEvent: (event: AgentEvent) => Promise<void>;
-};
-
-describe("AgentSession retry", () => {
- let session: AgentSession;
- let tempDir: string;
-
- beforeEach(() => {
- tempDir = join(tmpdir(), `pi-retry-test-${Date.now()}`);
- mkdirSync(tempDir, { recursive: true });
- });
-
- afterEach(() => {
- if (session) {
- session.dispose();
- }
- if (tempDir && existsSync(tempDir)) {
- rmSync(tempDir, { recursive: true });
- }
- });
-
- function createSession(options?: { failCount?: number; maxRetries?: number; delayAssistantMessageEndMs?: number }) {
- const failCount = options?.failCount ?? 1;
- const maxRetries = options?.maxRetries ?? 3;
- const delayAssistantMessageEndMs = options?.delayAssistantMessageEndMs ?? 0;
- let callCount = 0;
-
- const model = getModel("anthropic", "claude-sonnet-4-5")!;
- const agent = new Agent({
- getApiKey: () => "test-key",
- initialState: { model, systemPrompt: "Test", tools: [] },
- streamFn: () => {
- callCount++;
- const stream = new MockAssistantStream();
- queueMicrotask(() => {
- if (callCount <= failCount) {
- const msg = createAssistantMessage("", {
- stopReason: "error",
- errorMessage: "overloaded_error",
- });
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "error", reason: "error", error: msg });
- } else {
- const msg = createAssistantMessage("Success");
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "done", reason: "stop", message: msg });
- }
- });
- return stream;
- },
- });
-
- const sessionManager = SessionManager.inMemory();
- const settingsManager = SettingsManager.create(tempDir, tempDir);
- const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
- const modelRegistry = ModelRegistry.create(authStorage, tempDir);
- authStorage.setRuntimeApiKey("anthropic", "test-key");
- settingsManager.applyOverrides({ retry: { enabled: true, maxRetries, baseDelayMs: 1 } });
-
- session = new AgentSession({
- agent,
- sessionManager,
- settingsManager,
- cwd: tempDir,
- modelRegistry,
- resourceLoader: createTestResourceLoader(),
- });
-
- if (delayAssistantMessageEndMs > 0) {
- const sessionWithHook = session as unknown as SessionWithExtensionEmitHook;
- const original = sessionWithHook._emitExtensionEvent.bind(sessionWithHook);
- sessionWithHook._emitExtensionEvent = async (event: AgentEvent) => {
- if (event.type === "message_end" && event.message.role === "assistant") {
- await new Promise((resolve) => setTimeout(resolve, delayAssistantMessageEndMs));
- }
- await original(event);
- };
- }
-
- return { session, getCallCount: () => callCount };
- }
-
- // Build a session whose stream fails `failCount` times with `errorMessage`, then succeeds.
- function createSessionWithError(errorMessage: string, options?: { failCount?: number; maxRetries?: number }) {
- const failCount = options?.failCount ?? 1;
- const maxRetries = options?.maxRetries ?? 3;
- let callCount = 0;
-
- const model = getModel("anthropic", "claude-sonnet-4-5")!;
- const agent = new Agent({
- getApiKey: () => "test-key",
- initialState: { model, systemPrompt: "Test", tools: [] },
- streamFn: () => {
- callCount++;
- const stream = new MockAssistantStream();
- queueMicrotask(() => {
- if (callCount <= failCount) {
- const msg = createAssistantMessage("", { stopReason: "error", errorMessage });
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "error", reason: "error", error: msg });
- } else {
- const msg = createAssistantMessage("Recovered after retry");
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "done", reason: "stop", message: msg });
- }
- });
- return stream;
- },
- });
-
- const sessionManager = SessionManager.inMemory();
- const settingsManager = SettingsManager.create(tempDir, tempDir);
- const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
- const modelRegistry = ModelRegistry.create(authStorage, tempDir);
- authStorage.setRuntimeApiKey("anthropic", "test-key");
- settingsManager.applyOverrides({ retry: { enabled: true, maxRetries, baseDelayMs: 1 } });
-
- session = new AgentSession({
- agent,
- sessionManager,
- settingsManager,
- cwd: tempDir,
- modelRegistry,
- resourceLoader: createTestResourceLoader(),
- });
-
- return { session, getCallCount: () => callCount };
- }
-
- it("retries provider network_error failures", async () => {
- const created = createSession({ failCount: 0 });
- let callCount = 0;
- const streamFn = () => {
- callCount++;
- const stream = new MockAssistantStream();
- queueMicrotask(() => {
- if (callCount === 1) {
- const msg = createAssistantMessage("", {
- stopReason: "error",
- errorMessage: "Provider finish_reason: network_error",
- });
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "error", reason: "error", error: msg });
- return;
- }
-
- const msg = createAssistantMessage("Recovered after retry");
- stream.push({ type: "start", partial: msg });
- stream.push({ type: "done", reason: "stop", message: msg });
- });
- return stream;
- };
- created.session.dispose();
-
- const model = getModel("anthropic", "claude-sonnet-4-5")!;
- const agent = new Agent({
- getApiKey: () => "test-key",
- initialState: { model, systemPrompt: "Test", tools: [] },
- streamFn,
- });
- const sessionManager = SessionManager.inMemory();
- const settingsManager = SettingsManager.create(tempDir, tempDir);
- const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
- const modelRegistry = ModelRegistry.create(authStorage, tempDir);
- authStorage.setRuntimeApiKey("anthropic", "test-key");
- settingsManager.applyOverrides({ retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } });
- session = new AgentSession({
- agent,
- sessionManager,
- settingsManager,
- cwd: tempDir,
- modelRegistry,
- resourceLoader: createTestResourceLoader(),
- });
-
- const events: string[] = [];
- session.subscribe((event) => {
- if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
- if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
- });
-
- await session.prompt("Test");
-
- expect(callCount).toBe(2);
- expect(events).toEqual(["start:1", "end:success=true"]);
- });
-
- // Provider errors are retried within the bounded retry budget (ENG-4390, ENG-4503).
- const transientProviderErrors: Array<[string, string]> = [
- ["content_filter finish_reason", "Provider finish_reason: content_filter"],
- ["empty provider response", "Provider returned an empty response"],
- ["cybersecurity policy flag", "Your request was flagged for cybersecurity risk and cannot be processed."],
- ["usage policy flag", "flagged as potentially violating our usage policy"],
- ["prose-form transient 5xx", "An error occurred while processing your request. You can retry your request."],
- ];
-
- for (const [name, errorMessage] of transientProviderErrors) {
- it(`retries transient provider error: ${name}`, async () => {
- const created = createSessionWithError(errorMessage, { failCount: 1 });
- const events: string[] = [];
- created.session.subscribe((event) => {
- if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
- if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
- });
-
- await created.session.prompt("Test");
-
- expect(created.getCallCount()).toBe(2);
- expect(events).toEqual(["start:1", "end:success=true"]);
- expect(created.session.isRetrying).toBe(false);
- });
- }
-
- it("bounds retries on a persistent content_filter block", async () => {
- const created = createSessionWithError("Provider finish_reason: content_filter", {
- failCount: 99,
- maxRetries: 2,
- });
- const events: string[] = [];
- created.session.subscribe((event) => {
- if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
- if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
- });
-
- await created.session.prompt("Test");
-
- expect(created.getCallCount()).toBe(3);
- expect(events).toContain("start:1");
- expect(events).toContain("start:2");
- expect(events).toContain("end:success=false");
- expect(created.session.isRetrying).toBe(false);
- });
-});
diff --git a/packages/coding-agent/test/suite/agent-session-compaction.test.ts b/packages/coding-agent/test/suite/agent-session-compaction.test.ts
index d84f188f6a..a2b19d82e2 100644
--- a/packages/coding-agent/test/suite/agent-session-compaction.test.ts
+++ b/packages/coding-agent/test/suite/agent-session-compaction.test.ts
@@ -95,6 +95,56 @@ describe("AgentSession compaction characterization", () => {
expect(harness.session.messages[0]?.role).toBe("compactionSummary");
});
+ it("compacts through the model summarizer, persists metadata, emits events, and remains usable", async () => {
+ const harness = await createHarness({
+ settings: { compaction: { keepRecentTokens: 1 } },
+ persistSession: true,
+ });
+ harnesses.push(harness);
+ harness.setResponses([
+ fauxAssistantMessage("one response"),
+ fauxAssistantMessage("two response"),
+ fauxAssistantMessage("model-generated summary"),
+ fauxAssistantMessage("model-generated turn summary"),
+ fauxAssistantMessage("still usable"),
+ ]);
+ await harness.session.prompt("one");
+ await harness.session.prompt("two");
+
+ const result = await harness.session.compact();
+ const entry = harness.sessionManager.getEntries().find((candidate) => candidate.type === "compaction");
+
+ expect(result.summary).toContain("model-generated summary");
+ expect(result.tokensBefore).toBeGreaterThan(0);
+ expect(result.firstKeptEntryId).toBeTruthy();
+ expect(entry).toMatchObject({
+ type: "compaction",
+ summary: expect.stringContaining("model-generated summary"),
+ firstKeptEntryId: result.firstKeptEntryId,
+ tokensBefore: result.tokensBefore,
+ fromHook: false,
+ });
+ expect(harness.session.messages[0]).toMatchObject({
+ role: "compactionSummary",
+ summary: expect.stringContaining("model-generated summary"),
+ });
+ expect(harness.eventsOfType("compaction_start")).toEqual([expect.objectContaining({ reason: "manual" })]);
+ expect(harness.eventsOfType("compaction_end")).toEqual([
+ expect.objectContaining({
+ reason: "manual",
+ result: expect.objectContaining({ tokensBefore: result.tokensBefore }),
+ aborted: false,
+ willRetry: false,
+ }),
+ ]);
+
+ await harness.session.prompt("after compaction");
+ expect(harness.session.messages.at(-1)).toMatchObject({
+ role: "assistant",
+ content: [{ type: "text", text: "still usable" }],
+ });
+ });
+
it("reschedules a pending post-compaction continuation after successful manual compaction", async () => {
vi.useFakeTimers();
const harness = await createHarness({
diff --git a/packages/coding-agent/test/suite/agent-session-retry-events.test.ts b/packages/coding-agent/test/suite/agent-session-retry-events.test.ts
index e14901b296..7ee3dd8adb 100644
--- a/packages/coding-agent/test/suite/agent-session-retry-events.test.ts
+++ b/packages/coding-agent/test/suite/agent-session-retry-events.test.ts
@@ -222,6 +222,33 @@ describe("AgentSession retry and event characterization", () => {
}
});
+ for (const [name, errorMessage] of [
+ ["network finish reason", "Provider finish_reason: network_error"],
+ ["content-filter finish reason", "Provider finish_reason: content_filter"],
+ ["empty response", "Provider returned an empty response"],
+ ["cybersecurity policy flag", "Your request was flagged for cybersecurity risk and cannot be processed."],
+ ["usage policy flag", "flagged as potentially violating our usage policy"],
+ ["prose-form transient 5xx", "An error occurred while processing your request. You can retry your request."],
+ ] as const) {
+ it(`retries ${name}`, async () => {
+ const harness = await createHarness({
+ settings: { retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } },
+ });
+ harnesses.push(harness);
+ harness.setResponses([
+ fauxAssistantMessage("", { stopReason: "error", errorMessage }),
+ fauxAssistantMessage("recovered"),
+ ]);
+
+ await harness.session.prompt("test");
+
+ expect(harness.faux.state.callCount).toBe(2);
+ expect(harness.eventsOfType("auto_retry_start").map((event) => event.attempt)).toEqual([1]);
+ expect(harness.eventsOfType("auto_retry_end").map((event) => event.success)).toEqual([true]);
+ expect(harness.session.isRetrying).toBe(false);
+ });
+ }
+
it("retries generic provider errors", async () => {
const harness = await createHarness({ settings: { retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } } });
harnesses.push(harness);
diff --git a/packages/coding-agent/test/suite/agent-session-runtime.test.ts b/packages/coding-agent/test/suite/agent-session-runtime.test.ts
index 5b54d98426..f96b2d78d9 100644
--- a/packages/coding-agent/test/suite/agent-session-runtime.test.ts
+++ b/packages/coding-agent/test/suite/agent-session-runtime.test.ts
@@ -50,6 +50,7 @@ describe("AgentSessionRuntime characterization", () => {
cwd?: string;
bootstrapModel?: boolean;
bootstrapThinkingLevel?: boolean;
+ inMemory?: boolean;
sessionConfig?: AgentSessionRuntimeConfig;
onCreateRuntime?: (options: Parameters<CreateAgentSessionRuntimeFactory>[0]) => void;
},
@@ -122,7 +123,9 @@ describe("AgentSessionRuntime characterization", () => {
const runtime = await createAgentSessionRuntime(createRuntime, {
cwd: tempDir,
agentDir: tempDir,
- sessionManager: SessionManager.create(tempDir, join(tempDir, "sessions")),
+ sessionManager: options?.inMemory
+ ? SessionManager.inMemory(tempDir)
+ : SessionManager.create(tempDir, join(tempDir, "sessions")),
sessionConfig: options?.sessionConfig,
});
await runtime.session.bindExtensions({});
@@ -502,6 +505,44 @@ describe("AgentSessionRuntime characterization", () => {
expect(events).toEqual([{ type: "session_before_fork", entryId: "missing-entry", position: "at" }]);
});
+ it("forks before a selected middle prompt and preserves its selection metadata", async () => {
+ const { runtime } = await createRuntimeForTest(() => {});
+ await runtime.session.prompt("Say one");
+ await runtime.session.prompt("Say two");
+ await runtime.session.prompt("Say three");
+ const userMessages = runtime.session.getUserMessagesForForking();
+ expect(userMessages.map((message) => message.text)).toEqual(["Say one", "Say two", "Say three"]);
+
+ const result = await runtime.fork(userMessages[1]!.entryId);
+
+ expect(result).toEqual({ cancelled: false, selectedText: "Say two" });
+ expect(
+ runtime.session.messages.map((message) =>
+ message.role === "user"
+ ? typeof message.content === "string"
+ ? message.content
+ : message.content
+ .filter((part): part is { type: "text"; text: string } => part.type === "text")
+ .map((part) => part.text)
+ .join("")
+ : message.role,
+ ),
+ ).toEqual(["Say one", "assistant"]);
+ expect(runtime.session.sessionFile).toBeDefined();
+ });
+
+ it("forks before the first prompt in-memory and preserves its selection metadata", async () => {
+ const { runtime } = await createRuntimeForTest(() => {}, { inMemory: true });
+ await runtime.session.prompt("Say one");
+ const userMessages = runtime.session.getUserMessagesForForking();
+
+ const result = await runtime.fork(userMessages[0]!.entryId);
+
+ expect(result).toEqual({ cancelled: false, selectedText: "Say one" });
+ expect(runtime.session.messages).toEqual([]);
+ expect(runtime.session.sessionFile).toBeUndefined();
+ });
+
it("duplicates the current active branch when forking at the current position", async () => {
const { runtime } = await createRuntimeForTest(() => {});
await runtime.session.prompt("hello");
@@ -543,78 +584,7 @@ describe("AgentSessionRuntime characterization", () => {
});
it("duplicates the current active branch in-memory when forking at the current position", async () => {
- const tempDir = join(tmpdir(), `pi-runtime-suite-in-memory-${Date.now()}-${Math.random().toString(36).slice(2)}`);
- mkdirSync(tempDir, { recursive: true });
-
- const faux = registerFauxProvider({
- models: [
- { id: "faux-1", reasoning: true },
- { id: "faux-2", reasoning: false },
- ],
- });
- faux.setResponses([fauxAssistantMessage("one"), fauxAssistantMessage("two"), fauxAssistantMessage("three")]);
-
- const authStorage = AuthStorage.inMemory();
- authStorage.setRuntimeApiKey(faux.getModel().provider, "faux-key");
-
- const runtimeOptions = {
- agentDir: tempDir,
- authStorage,
- model: faux.getModel(),
- resourceLoaderOptions: {
- extensionFactories: [
- (pi: ExtensionAPI) => {
- pi.registerProvider(faux.getModel().provider, {
- baseUrl: faux.getModel().baseUrl,
- apiKey: "faux-key",
- api: faux.api,
- models: faux.models.map((registeredModel) => ({
- id: registeredModel.id,
- name: registeredModel.name,
- api: registeredModel.api,
- reasoning: registeredModel.reasoning,
- input: registeredModel.input,
- cost: registeredModel.cost,
- contextWindow: registeredModel.contextWindow,
- maxTokens: registeredModel.maxTokens,
- })),
- });
- },
- ],
- noSkills: true,
- noPromptTemplates: true,
- noThemes: true,
- },
- };
- const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
- const services = await createAgentSessionServices({
- ...runtimeOptions,
- cwd,
- });
- return {
- ...(await createAgentSessionFromServices({
- services,
- sessionManager,
- sessionStartEvent,
- model: runtimeOptions.model,
- })),
- services,
- diagnostics: services.diagnostics,
- };
- };
- const runtime = await createAgentSessionRuntime(createRuntime, {
- cwd: tempDir,
- agentDir: tempDir,
- sessionManager: SessionManager.inMemory(tempDir),
- });
- await runtime.session.bindExtensions({});
- cleanups.push(async () => {
- await runtime.dispose();
- faux.unregister();
- if (existsSync(tempDir)) {
- rmSync(tempDir, { recursive: true, force: true });
- }
- });
+ const { runtime } = await createRuntimeForTest(() => {}, { inMemory: true });
await runtime.session.prompt("hello");
await runtime.session.prompt("again");