@henryqw/pi-auto-compact 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # `@henryqw/pi-auto-compact`
 
-Pi extension that compacts context before it reaches 50% of current model context, then resumes current task.
+Pi extension that compacts context before it reaches 50% of current model context, then resumes current task. Requires Pi Coding Agent 0.80.7+.
 
 ## Install
 
@@ -28,23 +28,31 @@ pi remove npm:@henryqw/pi-auto-compact
 
 ## Configure
 
-Run `/auto-compact`, then enter threshold percentage. Config lives in `~/.pi/agent/config/pi-auto-compact.json`:
+Run `/auto-compact`, then choose:
+
+- `Model`: use current session model or select an available text model and its supported thinking level.
+- `Threshold`: set compaction percentage.
+
+Config lives in `~/.pi/agent/config/pi-auto-compact.json`:
 
 ```json
 {
-  "autoCompactThreshold": 50
+  "autoCompactThreshold": 50,
+  "compactionModel": "openai-codex/gpt-5.6-terra",
+  "compactionThinkingLevel": "max"
 }
 ```
 
-Threshold must be at least 25% and below 100%; lower values are not meaningful. Missing config defaults to 50%. Restart or `/reload` after manual edits; command changes apply immediately.
+`compactionModel` is optional and must name Pi-known `provider/model`; omit it to compact with current session model. `compactionThinkingLevel` accepts `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`, requires a dedicated model, and defaults to `off` when omitted. Threshold must be at least 25% and below 100%; lower values are not meaningful. Missing config defaults to 50%. Restart or `/reload` after manual edits; menu changes apply immediately.
 
 ## Behavior
 
 - Refuses activation with an error when Pi's effective `compaction.enabled` setting is not `false`; competing automatic compactors can start duplicate summaries.
-- Checks `turn_start`, tool-call `turn_end`, `context`, and resumed/forked `session_start`.
-- Uses Pi's default `ctx.compact()` summary and session persistence.
+- Checks `turn_start`, tool-call `turn_end`, `agent_end`, `context`, and resumed/forked `session_start`.
+- Uses Pi's native summary and session persistence; optional `compactionModel` runs automatic summaries with selected model and thinking level. Manual `/compact` keeps using current session model.
+- Falls back to current session model when configured compaction model is unavailable, cannot authenticate, or fails.
 - Keeps newest 15% as temporary emergency context while compaction runs.
-- Sends a follow-up message after compaction so task execution continues.
+- Sends a follow-up message after mid-task compaction so task execution continues; final-answer compaction stays idle.
 - Compacts above configured `autoCompactThreshold` percentage (50% by default).
 
 `ctx.compact()` aborts current low-level run. Extension hides that empty internal abort message, then starts new run with current task resume message. Other aborts and provider errors remain visible.

package/extensions/auto-compact.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import {
+	compact,
 	estimateTokens,
 	getAgentDir,
 	SettingsManager,
@@ -11,25 +12,59 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 
 type AgentMessage = Parameters<typeof estimateTokens>[0];
+type ThinkingLevel = NonNullable<Parameters<typeof compact>[6]>;
+type TextModel = ReturnType<ExtensionContext["modelRegistry"]["getAvailable"]>[number];
 
 /**
- * Proactive compaction runs at three points:
+ * Proactive compaction runs at four points:
  * - turn_start: catch sessions already over threshold before next request.
  * - turn_end: catch growth caused by tool results before next LLM turn.
+ * - agent_end: catch growth from the final provider turn.
  * - context: last-resort guard with a temporary keep-recent context.
  *
- * Pi's ctx.compact() aborts active low-level run internally. Its completion
- * callback sends follow-up user message, which resumes task after summary.
+ * Pi's ctx.compact() aborts active low-level run internally. Mid-task
+ * compaction sends a follow-up user message to resume work after summary.
  */
 const DEFAULT_COMPACT_THRESHOLD_PERCENT = 50;
 const MIN_COMPACT_THRESHOLD_PERCENT = 25;
+const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 const configPath = () => join(getAgentDir(), "config", "pi-auto-compact.json");
 
+type Config = {
+	autoCompactThreshold: number;
+	compactionModel?: string;
+	compactionThinkingLevel?: ThinkingLevel;
+};
+
+type ModelReference = { provider: string; modelId: string };
+
 function isValidThreshold(value: unknown): value is number {
 	return typeof value === "number" && Number.isFinite(value) && value >= MIN_COMPACT_THRESHOLD_PERCENT && value < 100;
 }
 
-function readConfig(): { autoCompactThreshold: number } {
+function isValidThinkingLevel(value: unknown): value is ThinkingLevel {
+	return typeof value === "string" && THINKING_LEVELS.includes(value as ThinkingLevel);
+}
+
+function supportedThinkingLevels(model: TextModel): ThinkingLevel[] {
+	if (!model.reasoning) return ["off"];
+	return THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		return mapped !== null && ((level !== "xhigh" && level !== "max") || mapped !== undefined);
+	});
+}
+
+function parseModelReference(value: unknown): ModelReference | undefined {
+	if (typeof value !== "string") return undefined;
+	const separator = value.indexOf("/");
+	if (separator <= 0 || separator === value.length - 1) return undefined;
+
+	const provider = value.slice(0, separator).trim();
+	const modelId = value.slice(separator + 1).trim();
+	return provider && modelId ? { provider, modelId } : undefined;
+}
+
+function readConfig(): Config {
 	let value: unknown;
 	try {
 		value = JSON.parse(readFileSync(configPath(), "utf8"));
@@ -42,21 +77,43 @@ function readConfig(): { autoCompactThreshold: number } {
 	if (!value || typeof value !== "object" || Array.isArray(value)) {
 		throw new Error("Config must be an object.");
 	}
-	const threshold = (value as Record<string, unknown>).autoCompactThreshold ?? DEFAULT_COMPACT_THRESHOLD_PERCENT;
+	const config = value as Record<string, unknown>;
+	const threshold = config.autoCompactThreshold ?? DEFAULT_COMPACT_THRESHOLD_PERCENT;
 	if (!isValidThreshold(threshold)) {
 		throw new Error(`autoCompactThreshold must be at least ${MIN_COMPACT_THRESHOLD_PERCENT} and below 100.`);
 	}
-	return { autoCompactThreshold: threshold };
+	if (config.compactionModel !== undefined && !parseModelReference(config.compactionModel)) {
+		throw new Error("compactionModel must be a provider/model string.");
+	}
+	const thinkingLevel = config.compactionThinkingLevel;
+	if (thinkingLevel !== undefined && !isValidThinkingLevel(thinkingLevel)) {
+		throw new Error("compactionThinkingLevel is invalid.");
+	}
+	if (thinkingLevel !== undefined && config.compactionModel === undefined) {
+		throw new Error("compactionThinkingLevel requires compactionModel.");
+	}
+	return {
+		autoCompactThreshold: threshold,
+		compactionModel: typeof config.compactionModel === "string" ? config.compactionModel.trim() : undefined,
+		compactionThinkingLevel: thinkingLevel,
+	};
 }
 
-function writeConfig(autoCompactThreshold: number): void {
+function writeConfig(config: Config): void {
 	const file = configPath();
 	mkdirSync(dirname(file), { recursive: true });
-	writeFileSync(file, `${JSON.stringify({ autoCompactThreshold }, null, 2)}\n`);
+	writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+function withoutDeletedHeaders(headers: Record<string, string | null> | undefined): Record<string, string> | undefined {
+	return headers
+		? Object.fromEntries(Object.entries(headers).filter((entry): entry is [string, string] => entry[1] !== null))
+		: undefined;
 }
 
 // Emergency context guard keeps recent messages while default compaction runs.
 const KEEP_RECENT_PERCENT = 15;
+const COMPACTION_INSTRUCTIONS = "Preserve current task to be resumed after compaction.";
 const RESUME_MESSAGE = "Auto-compact ran. Continue the current task.";
 const COMPACTION_ABORT_ERROR = "This operation was aborted";
 const ACTIVATION_ERROR =
@@ -119,16 +176,20 @@ function hasToolCall(message: AgentMessage): boolean {
 export default function (pi: ExtensionAPI) {
 	let active = false;
 	let autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
-	// Prevent turn_start, turn_end, and context from starting duplicate summaries.
+	let compactionModel: string | undefined;
+	let compactionThinkingLevel: ThinkingLevel | undefined;
+	// Prevent lifecycle hooks from starting duplicate summaries.
 	let compactionPending = false;
 	let compactionAbortExpected = false;
 
-	const runCompaction = (ctx: ExtensionContext) => {
+	const runCompaction = (ctx: ExtensionContext, resumeTask = true) => {
 		compactionAbortExpected = Boolean(ctx.signal && !ctx.signal.aborted);
 		ctx.compact({
+			customInstructions: COMPACTION_INSTRUCTIONS,
 			onComplete: () => {
 				compactionPending = false;
 				compactionAbortExpected = false;
+				if (!resumeTask) return;
 				// Pi may flush queued input during compaction_end. Wait one macrotask
 				// before checking idle, otherwise follow-up can race that flush.
 				setImmediate(() => {
@@ -142,14 +203,14 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	const compactIfNeeded = (ctx: ExtensionContext) => {
+	const compactIfNeeded = (ctx: ExtensionContext, resumeTask = true) => {
 		if (!active || compactionPending) return;
 
 		const usage = ctx.getContextUsage();
 		if (usage?.percent == null || usage.percent <= autoCompactThreshold) return;
 
 		compactionPending = true;
-		runCompaction(ctx);
+		runCompaction(ctx, resumeTask);
 	};
 
 	// Hide only empty abort produced when ctx.compact() cancels active run.
@@ -176,12 +237,14 @@ export default function (pi: ExtensionAPI) {
 	// Pre-turn catches resumed/queued work before provider request starts.
 	pi.on("turn_start", (_event, ctx) => compactIfNeeded(ctx));
 
-	// Only tool-call turns need mid-run compaction. Final answers should not
-	// receive an unsolicited continuation message.
+	// Only tool-call turns need mid-run compaction.
 	pi.on("turn_end", (event, ctx) => {
 		if (hasToolCall(event.message)) compactIfNeeded(ctx);
 	});
 
+	// Catch threshold crossings caused by the final provider turn.
+	pi.on("agent_end", (_event, ctx) => compactIfNeeded(ctx, false));
+
 	// Runs before every provider request. Temporary truncation protects request
 	// size while asynchronous default compaction summarizes persisted history.
 	pi.on("context", (event, ctx) => {
@@ -205,19 +268,75 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("auto-compact", {
-		description: "set automatic compaction threshold",
-		handler: async (_args, ctx) => {
-			let current: number;
+		description: "configure automatic compaction",
+		handler: async (args, ctx) => {
+			if (args.trim()) {
+				ctx.ui.notify("Usage: /auto-compact", "error");
+				return;
+			}
+
+			let config: Config;
 			try {
-				current = readConfig().autoCompactThreshold;
+				config = readConfig();
 			} catch {
 				ctx.ui.notify("Couldn't read pi-auto-compact config.", "error");
 				return;
 			}
+			const save = (next: Config) => {
+				try {
+					writeConfig(next);
+					return true;
+				} catch {
+					ctx.ui.notify("Couldn't save pi-auto-compact config.", "error");
+					return false;
+				}
+			};
+
+			const thresholdOption = `Threshold · ${config.autoCompactThreshold}%`;
+			const modelOption = `Model · ${config.compactionModel
+				? `${config.compactionModel} (${config.compactionThinkingLevel ?? "off"})`
+				: "current session"}`;
+			const setting = await ctx.ui.select("Configure auto-compact", [modelOption, thresholdOption]);
+			if (!setting) return;
+
+			if (setting === modelOption) {
+				const models = ctx.modelRegistry
+					.getAvailable()
+					.filter((model) => model.input.includes("text"))
+					.sort((a, b) => `${a.provider}/${a.id}`.localeCompare(`${b.provider}/${b.id}`));
+				const currentModel = "Current session model";
+				const selected = await ctx.ui.select("Auto-compact model", [
+					currentModel,
+					...models.map((model) => `${model.provider}/${model.id}`),
+				]);
+				if (!selected) return;
+
+				if (selected === currentModel) {
+					if (!save({ ...config, compactionModel: undefined, compactionThinkingLevel: undefined })) return;
+					compactionModel = undefined;
+					compactionThinkingLevel = undefined;
+					ctx.ui.notify("Auto-compact model set to current session model.", "info");
+					return;
+				}
+
+				const model = models.find((candidate) => `${candidate.provider}/${candidate.id}` === selected);
+				if (!model) return;
+				const thinkingLevels = supportedThinkingLevels(model);
+				const thinkingLevel = thinkingLevels.length === 1
+					? thinkingLevels[0]
+					: await ctx.ui.select(`Thinking level · ${selected}`, thinkingLevels);
+				if (!isValidThinkingLevel(thinkingLevel)) return;
+
+				if (!save({ ...config, compactionModel: selected, compactionThinkingLevel: thinkingLevel })) return;
+				compactionModel = selected;
+				compactionThinkingLevel = thinkingLevel;
+				ctx.ui.notify(`Auto-compact model set to ${selected} (${thinkingLevel}).`, "info");
+				return;
+			}
 
 			const input = await ctx.ui.input(
-				`Auto-compact threshold (%) · current: ${current}`,
-				"Enter a number above 0 and below 100",
+				`Auto-compact threshold (%) · current: ${config.autoCompactThreshold}`,
+				"Enter a number at least 25 and below 100",
 			);
 			if (input === undefined) return;
 
@@ -231,12 +350,7 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			try {
-				writeConfig(threshold);
-			} catch {
-				ctx.ui.notify("Couldn't save pi-auto-compact config.", "error");
-				return;
-			}
+			if (!save({ ...config, autoCompactThreshold: threshold })) return;
 			autoCompactThreshold = threshold;
 			ctx.ui.notify(`Auto-compact threshold set to ${threshold}%.`, "info");
 		},
@@ -246,9 +360,14 @@ export default function (pi: ExtensionAPI) {
 	// activation unless effective global/project settings disable it.
 	pi.on("session_start", (event, ctx) => {
 		try {
-			autoCompactThreshold = readConfig().autoCompactThreshold;
+			const config = readConfig();
+			autoCompactThreshold = config.autoCompactThreshold;
+			compactionModel = config.compactionModel;
+			compactionThinkingLevel = config.compactionThinkingLevel;
 		} catch {
 			autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
+			compactionModel = undefined;
+			compactionThinkingLevel = undefined;
 			ctx.ui.notify("Couldn't read pi-auto-compact config; using 50%.", "error");
 		}
 
@@ -260,4 +379,68 @@ export default function (pi: ExtensionAPI) {
 		// Resume/fork can load an already-large session before first turn.
 		if (event.reason === "resume" || event.reason === "fork") compactIfNeeded(ctx);
 	});
+
+	pi.on("session_before_compact", async (event, ctx) => {
+		if (
+			!active ||
+			!compactionPending ||
+			event.customInstructions !== COMPACTION_INSTRUCTIONS
+		) return;
+
+		// Pi omits details from prior extension compactions when preparing next run.
+		const previous = [...event.branchEntries].reverse().find((entry) => entry.type === "compaction");
+		if (previous?.details && typeof previous.details === "object") {
+			const details = previous.details as { readFiles?: unknown; modifiedFiles?: unknown };
+			if (Array.isArray(details.readFiles)) {
+				for (const path of details.readFiles) {
+					if (typeof path === "string") event.preparation.fileOps.read.add(path);
+				}
+			}
+			if (Array.isArray(details.modifiedFiles)) {
+				for (const path of details.modifiedFiles) {
+					if (typeof path === "string") event.preparation.fileOps.edited.add(path);
+				}
+			}
+		}
+
+		if (!compactionModel) return;
+		const reference = parseModelReference(compactionModel);
+		if (!reference) return;
+		const model = ctx.modelRegistry.find(reference.provider, reference.modelId);
+		if (!model) {
+			ctx.ui.notify("Configured compaction model not found; using current session model.", "error");
+			return;
+		}
+		if (compactionThinkingLevel && !supportedThinkingLevels(model).includes(compactionThinkingLevel)) {
+			ctx.ui.notify("Configured thinking level is unsupported; using current session model.", "error");
+			return;
+		}
+
+		try {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+			if (!auth.ok) {
+				ctx.ui.notify("Couldn't authenticate configured compaction model; using current session model.", "error");
+				return;
+			}
+
+			const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+			return {
+				compaction: await compact(
+					event.preparation,
+					requestModel,
+					auth.apiKey,
+					withoutDeletedHeaders(auth.headers),
+					event.customInstructions,
+					event.signal,
+					compactionThinkingLevel,
+					undefined,
+					auth.env,
+				),
+			};
+		} catch {
+			if (!event.signal.aborted) {
+				ctx.ui.notify("Configured compaction model failed; using current session model.", "error");
+			}
+		}
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Proactively compact Pi context at a configurable threshold and resume the current task.",
   "keywords": [
     "pi-package",
@@ -25,7 +25,7 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": ">=0.80.7"
   },
   "repository": {
     "type": "git",