Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/voice/__serial__/voice-context.test.ts

Raw
import type { AssistantMessage, Context } from "@earendil-works/pi-ai";
import {
	SessionManager,
	SettingsManager,
} from "@earendil-works/pi-coding-agent";
import { describe, expect, it } from "vitest";
import {
	assertVoiceRequestBudget,
	checkpointVoiceContext,
	voiceChildSettings,
	voiceContextHead,
} from "../src/voice-context.ts";

const assistant = (text = "reply"): AssistantMessage => ({
	role: "assistant",
	content: [{ type: "text", text }],
	api: "openai-responses",
	provider: "test",
	model: "test",
	timestamp: 1,
	usage: {
		input: 0,
		output: 0,
		cacheRead: 0,
		cacheWrite: 0,
		totalTokens: 0,
		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
	},
	stopReason: "stop",
});
const exchange = (manager: SessionManager, text: string) => {
	const id = manager.appendMessage({
		role: "user",
		content: text,
		timestamp: 1,
	});
	manager.appendMessage(assistant());
	return id;
};
const users = (manager: SessionManager) =>
	manager
		.buildSessionContext()
		.messages.filter((message) => message.role === "user");

describe("deterministic voice context", () => {
	it("caps each mechanically rebuilt section with explicit truncation", () => {
		const value = "x".repeat(20_000);
		const head = voiceContextHead({
			task: value,
			questions: value,
			users: value,
			results: value,
		});
		expect(head.match(/\[truncated\]/gu)).toHaveLength(4);
		expect(head.length).toBeLessThan(11_300);
		expect(head).toContain("Unaccepted Pi questions");
		expect(
			voiceContextHead({ task: [], questions: [], users: [], results: [] }),
		).not.toContain("[truncated]");
	});

	it("keeps exactly the newest 32 complete exchanges without deleting the archive", () => {
		const manager = SessionManager.inMemory();
		const ids = Array.from({ length: 40 }, (_, index) =>
			exchange(manager, `user-${index}`),
		);
		const count = manager.getEntryCount();
		const identity = manager.getSessionId();
		const window = checkpointVoiceContext(manager, "mechanical head");
		expect(window).toMatchObject({
			exchanges: 32,
			firstId: ids[8],
			omitted: 8,
		});
		expect(users(manager)).toHaveLength(32);
		expect(users(manager)[0]?.content).toBe("user-8");
		expect(manager.getEntryCount()).toBe(count + 1);
		expect(manager.getSessionId()).toBe(identity);
		expect(manager.getEntry(ids[0]!)?.type).toBe("message");
		expect(checkpointVoiceContext(manager, "refreshed head")).toMatchObject({
			omitted: 8,
			hasOmittedHistory: true,
		});
	});

	it("evicts whole exchanges under 64k and records omissions", () => {
		const manager = SessionManager.inMemory();
		for (let index = 0; index < 10; index++)
			exchange(manager, `${index}${"x".repeat(12_000)}`);
		const window = checkpointVoiceContext(manager, "head");
		expect(window.exchanges).toBe(5);
		expect(window.chars).toBeLessThanOrEqual(64_000);
		expect(manager.buildSessionContext().messages[0]).toMatchObject({
			role: "compactionSummary",
			summary: expect.stringContaining("[older complete exchanges omitted]"),
		});
	});

	it("keeps paired tool calls/results intact across repeated checkpoints", () => {
		const manager = SessionManager.inMemory();
		exchange(manager, "earlier");
		manager.appendMessage({
			role: "user",
			content: "use a tool",
			timestamp: 1,
		});
		manager.appendMessage({
			...assistant(),
			stopReason: "toolUse",
			content: [
				{
					type: "toolCall",
					id: "call",
					name: "voice_executor_state",
					arguments: {},
				},
			],
		});
		manager.appendMessage({
			role: "toolResult",
			toolCallId: "call",
			toolName: "voice_executor_state",
			content: [{ type: "text", text: "state" }],
			isError: false,
			timestamp: 1,
		});
		manager.appendMessage(assistant());
		checkpointVoiceContext(manager, "old head");
		checkpointVoiceContext(manager, "new head");
		const messages = manager.buildSessionContext().messages;
		expect(
			messages.filter((message) => message.role === "compactionSummary"),
		).toHaveLength(1);
		expect(
			messages.filter((message) => message.role === "toolResult"),
		).toHaveLength(1);
		expect(JSON.stringify(messages)).not.toContain("old head");
	});

	it("pins a large in-flight exchange until the next idle checkpoint", () => {
		const manager = SessionManager.inMemory();
		for (let index = 0; index < 32; index++)
			exchange(manager, `earlier-${index}`);
		checkpointVoiceContext(manager, "head");
		const current = manager.appendMessage({
			role: "user",
			content: "x".repeat(100_000),
			timestamp: 1,
		});
		expect(users(manager)).toHaveLength(33);
		expect(manager.buildSessionContext().messages.at(-1)).toMatchObject({
			content: "x".repeat(100_000),
		});
		manager.appendMessage(assistant());
		expect(checkpointVoiceContext(manager, "next head").exchanges).toBe(0);
		expect(manager.getEntry(current)).toBeDefined();
		expect(
			checkpointVoiceContext(manager, "another head").hasOmittedHistory,
		).toBe(true);
	});

	it("never replays an aborted orphan tool call or an invented result", () => {
		const manager = SessionManager.inMemory();
		exchange(manager, "earlier");
		manager.appendMessage({
			role: "user",
			content: "interrupted",
			timestamp: 1,
		});
		manager.appendMessage({
			...assistant(),
			stopReason: "aborted",
			content: [
				{
					type: "toolCall",
					id: "orphan",
					name: "voice_executor_dispatch",
					arguments: { text: "work" },
				},
			],
		});
		exchange(manager, "newer");
		expect(checkpointVoiceContext(manager, "head").exchanges).toBe(1);
		expect(users(manager).map((message) => message.content)).toEqual(["newer"]);
		expect(
			manager
				.getEntries()
				.some(
					(entry) =>
						entry.type === "message" &&
						entry.message.role === "assistant" &&
						entry.message.stopReason === "aborted",
				),
		).toBe(true);
	});

	it("respects retry context edits and replaces old model-generated summaries", () => {
		const manager = SessionManager.inMemory();
		const kept = exchange(manager, "kept");
		const failed = manager.appendMessage({
			...assistant("retry-me"),
			stopReason: "error",
		});
		manager.appendCompaction("old LLM summary", kept, 100);
		manager.appendContextEdit(failed, null);
		checkpointVoiceContext(manager, "mechanical head");
		const context = JSON.stringify(manager.buildSessionContext());
		expect(context).not.toContain("old LLM summary");
		expect(context).not.toContain("retry-me");
		expect(context).toContain("mechanical head");
	});

	it("disables auxiliary model work only through child-local in-memory settings", () => {
		const parent = SettingsManager.inMemory({
			compaction: { enabled: true },
			cacheWarming: "streaming",
		});
		const child = voiceChildSettings();
		expect(child.getCompactionEnabled()).toBe(false);
		expect(child.getCacheWarmingMode()).toBe("off");
		expect(parent.getCompactionEnabled()).toBe(true);
		expect(parent.getCacheWarmingMode()).toBe("streaming");
	});

	it("refuses oversized request pins instead of splitting or truncating data", () => {
		const context: Context = {
			messages: [{ role: "user", content: "x".repeat(100_000), timestamp: 1 }],
		};
		expect(() => assertVoiceRequestBudget(context)).not.toThrow();
		context.messages.push({
			role: "user",
			content: "y".repeat(160_000),
			timestamp: 1,
		});
		expect(() => assertVoiceRequestBudget(context)).toThrow(
			"context safety limit",
		);
		expect(context.messages).toHaveLength(2);
	});
});