@henryqw/pi-auto-compact 0.3.0 → 1.0.2

package/README.md

@@ -1,13 +1,22 @@
 # `@henryqw/pi-auto-compact`
 
-Pi extension that compacts context before it reaches 50% of current model context, then resumes current task. Requires Pi Coding Agent 0.80.7+.
+Compact context before it hits the configured threshold, then resume the current task.
 
 ## Install
 
 ```bash
+pi install npm:@henryqw/pi-task-models
 pi install npm:@henryqw/pi-auto-compact
 ```
 
+Requires Pi Coding Agent 0.84.2+.
+
+## With
+
+| Package | Why |
+| --- | --- |
+| `@henryqw/pi-task-models` | Required. Shared model profiles for compaction routes. |
+
 Disable Pi's built-in auto-compaction in `~/.pi/agent/settings.json`:
 
 ```json
@@ -18,51 +27,44 @@ Disable Pi's built-in auto-compaction in `~/.pi/agent/settings.json`:
 }
 ```
 
-Restart Pi after installation or settings changes. Trusted project settings in `.pi/settings.json` must not override `compaction.enabled` back to `true`. Manual `/compact` remains available.
-
-Remove with:
+Restart Pi after install or settings changes. Trusted project settings in `.pi/settings.json` must not set `compaction.enabled` back to `true`.
 
-```bash
-pi remove npm:@henryqw/pi-auto-compact
-```
+## Use
 
-## Configure
+| Surface | Type | Purpose |
+| --- | --- | --- |
+| `/auto-compact` | command | Set the compaction threshold. |
 
-Run `/auto-compact`, then choose:
+Refuses to activate unless effective `compaction.enabled` is `false`. Checks `turn_start`, tool-call `turn_end`, `agent_end`, `context`, and resumed or forked `session_start`. Tries the assigned profile primary, then fallback; if neither route works, the current session model still compacts. After mid-task compaction, a follow-up message continues the current task.
 
-- `Model`: use current session model or select an available text model and its supported thinking level.
-- `Threshold`: set compaction percentage.
+## Config
 
-Config lives in `~/.pi/agent/config/pi-auto-compact.json`:
+`~/.pi/agent/config/pi-auto-compact.json`
 
 ```json
 {
-  "autoCompactThreshold": 50,
-  "compactionModel": "openai-codex/gpt-5.6-terra",
-  "compactionThinkingLevel": "max"
+  "autoCompactThreshold": 50
 }
 ```
 
-`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.
+Threshold must be at least 25 and below 100. Missing config defaults to 50. Model routes live in `~/.pi/agent/config/pi-task-models.json`. Malformed shared task-model config is reported and left unchanged.
 
-## Behavior
+## Remove
 
-- 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`, `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 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.
+```bash
+pi remove npm:@henryqw/pi-auto-compact
+```
 
 ## Development
 
 ```bash
-npm test
-npm run pack:check
-npm run test:live
+npm test --workspace @henryqw/pi-auto-compact
+npm run typecheck --workspace @henryqw/pi-auto-compact
+npm run pack:check --workspace @henryqw/pi-auto-compact
 ```
 
-`test:live` uses real Pi plus authenticated model access. It disables Pi's built-in auto-compaction, sets a temporary 12K context window, sends a large prompt, and verifies extension compaction, automatic resume, persisted resume message, and assistant response. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.
+`test:live` needs real Pi plus authenticated model access. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.
+
+```bash
+npm run test:live --workspace @henryqw/pi-auto-compact
+```

package/extensions/auto-compact.ts

@@ -10,10 +10,14 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import {
+	orderedProfileRoutes,
+	readTaskModelsConfig,
+	resolveTaskModelRoute,
+	type ResolvedTaskRoute,
+} from "@henryqw/pi-task-models";
 
 type AgentMessage = Parameters<typeof estimateTokens>[0];
-type ThinkingLevel = NonNullable<Parameters<typeof compact>[6]>;
-type TextModel = ReturnType<ExtensionContext["modelRegistry"]["getAvailable"]>[number];
 
 /**
  * Proactive compaction runs at four points:
@@ -27,43 +31,18 @@ type TextModel = ReturnType<ExtensionContext["modelRegistry"]["getAvailable"]>[n
  */
 const DEFAULT_COMPACT_THRESHOLD_PERCENT = 50;
 const MIN_COMPACT_THRESHOLD_PERCENT = 25;
-const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const AUTO_COMPACT_TASK = "pi-auto-compact/autoCompact";
+const DEFAULT_AUTO_COMPACT_PROFILE = "balanced" as const;
 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 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 {
@@ -77,26 +56,11 @@ function readConfig(): Config {
 	if (!value || typeof value !== "object" || Array.isArray(value)) {
 		throw new Error("Config must be an object.");
 	}
-	const config = value as Record<string, unknown>;
-	const threshold = config.autoCompactThreshold ?? DEFAULT_COMPACT_THRESHOLD_PERCENT;
+	const threshold = (value as Record<string, unknown>).autoCompactThreshold ?? DEFAULT_COMPACT_THRESHOLD_PERCENT;
 	if (!isValidThreshold(threshold)) {
 		throw new Error(`autoCompactThreshold must be at least ${MIN_COMPACT_THRESHOLD_PERCENT} and below 100.`);
 	}
-	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,
-	};
+	return { autoCompactThreshold: threshold };
 }
 
 function writeConfig(config: Config): void {
@@ -105,6 +69,31 @@ function writeConfig(config: Config): void {
 	writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
 }
 
+function configuredTaskRoutes(ctx: ExtensionContext): ResolvedTaskRoute[] | undefined {
+	let config;
+	try {
+		config = readTaskModelsConfig();
+	} catch {
+		ctx.ui.notify("Couldn't read task model config; using current session model.", "error");
+		return undefined;
+	}
+
+	const profileName = config.tasks[AUTO_COMPACT_TASK] ?? DEFAULT_AUTO_COMPACT_PROFILE;
+	const profile = config.profiles[profileName];
+	if (!profile) {
+		ctx.ui.notify(`Task model profile ${profileName} is not configured; using current session model.`, "error");
+		return [];
+	}
+
+	const routes = orderedProfileRoutes(profile)
+		.map((route) => resolveTaskModelRoute(ctx, route))
+		.filter((route): route is ResolvedTaskRoute => route !== undefined);
+	if (!routes.length) {
+		ctx.ui.notify(`No usable ${profileName} task model route; using current session model.`, "error");
+	}
+	return routes;
+}
+
 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))
@@ -176,8 +165,6 @@ function hasToolCall(message: AgentMessage): boolean {
 export default function (pi: ExtensionAPI) {
 	let active = false;
 	let autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
-	let compactionModel: string | undefined;
-	let compactionThinkingLevel: ThinkingLevel | undefined;
 	// Prevent lifecycle hooks from starting duplicate summaries.
 	let compactionPending = false;
 	let compactionAbortExpected = false;
@@ -268,7 +255,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("auto-compact", {
-		description: "configure automatic compaction",
+		description: "configure automatic compaction threshold",
 		handler: async (args, ctx) => {
 			if (args.trim()) {
 				ctx.ui.notify("Usage: /auto-compact", "error");
@@ -282,57 +269,6 @@ export default function (pi: ExtensionAPI) {
 				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: ${config.autoCompactThreshold}`,
@@ -350,7 +286,12 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			if (!save({ ...config, autoCompactThreshold: threshold })) return;
+			try {
+				writeConfig({ autoCompactThreshold: threshold });
+			} catch {
+				ctx.ui.notify("Couldn't save pi-auto-compact config.", "error");
+				return;
+			}
 			autoCompactThreshold = threshold;
 			ctx.ui.notify(`Auto-compact threshold set to ${threshold}%.`, "info");
 		},
@@ -360,14 +301,9 @@ export default function (pi: ExtensionAPI) {
 	// activation unless effective global/project settings disable it.
 	pi.on("session_start", (event, ctx) => {
 		try {
-			const config = readConfig();
-			autoCompactThreshold = config.autoCompactThreshold;
-			compactionModel = config.compactionModel;
-			compactionThinkingLevel = config.compactionThinkingLevel;
+			autoCompactThreshold = readConfig().autoCompactThreshold;
 		} catch {
 			autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
-			compactionModel = undefined;
-			compactionThinkingLevel = undefined;
 			ctx.ui.notify("Couldn't read pi-auto-compact config; using 50%.", "error");
 		}
 
@@ -403,44 +339,35 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		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;
-		}
+		const routes = configuredTaskRoutes(ctx);
+		if (!routes?.length) 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;
+		for (const route of routes) {
+			try {
+				const auth = await ctx.modelRegistry.getApiKeyAndHeaders(route.model);
+				if (!auth.ok) continue;
+
+				const requestModel = auth.baseUrl ? { ...route.model, baseUrl: auth.baseUrl } : route.model;
+				return {
+					compaction: await compact(
+						event.preparation,
+						requestModel,
+						auth.apiKey,
+						withoutDeletedHeaders(auth.headers),
+						event.customInstructions,
+						event.signal,
+						route.thinkingLevel,
+						undefined,
+						auth.env,
+					),
+				};
+			} catch {
+				if (event.signal.aborted) 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");
-			}
+		if (!event.signal.aborted) {
+			ctx.ui.notify("Configured task model routes failed; using current session model.", "error");
 		}
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.3.0",
+  "version": "1.0.2",
   "description": "Proactively compact Pi context at a configurable threshold and resume the current task.",
   "keywords": [
     "pi-package",
@@ -25,7 +25,8 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.80.7"
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2"
   },
   "repository": {
     "type": "git",
@@ -42,5 +43,8 @@
     "extensions": [
       "./extensions"
     ]
+  },
+  "dependencies": {
+    "@henryqw/pi-task-models": "^0.1.0"
   }
 }