pi-compact-tools 0.6.3 → 0.7.7

package/extensions/compact-tools-runtime.ts

@@ -9,32 +9,26 @@ import type {
 } from "./compact-tools-types.ts";
 
 const MAX_TRACKED_ROWS = 2_000;
-const SPINNING_ROWS_KEY = Symbol.for("pi.compact-tools.spinning-rows");
+const INDICATOR_INTERVAL_MS = 45;
 const EXECUTION_TIMINGS_KEY = Symbol.for("pi.compact-tools.execution-timings");
 
 type ExecutionTiming = { startedAt: number; endedAt?: number };
-type TrackedRow = { state: RowState; name: CompactToolName; invalidate: () => void };
 type TimedExecute = (...args: any[]) => Promise<AgentToolResult<unknown>>;
 type SharedState = typeof globalThis & {
-	[SPINNING_ROWS_KEY]?: Set<RowState>;
 	[EXECUTION_TIMINGS_KEY]?: Map<string, ExecutionTiming>;
 };
 
 export class ToolRuntime {
 	private configValue = DEFAULT_CONFIG;
 	private configRevision: object = {};
-	private animateRows = false;
-	private readonly spinningRows = new Set<RowState>();
 	private readonly executionTimings: Map<string, ExecutionTiming>;
-	private readonly trackedRows = new Map<string, TrackedRow>();
+	private readonly indicatorInvalidators = new Map<string, () => void>();
+	private indicatorFrame = 0;
+	private indicatorTimer: ReturnType<typeof setInterval> | undefined;
 
 	constructor() {
 		const shared = globalThis as SharedState;
-		for (const state of shared[SPINNING_ROWS_KEY] ?? []) {
-			if (state.timer) clearInterval(state.timer);
-		}
 		this.executionTimings = shared[EXECUTION_TIMINGS_KEY] ?? new Map<string, ExecutionTiming>();
-		shared[SPINNING_ROWS_KEY] = this.spinningRows;
 		shared[EXECUTION_TIMINGS_KEY] = this.executionTimings;
 	}
 
@@ -42,14 +36,8 @@ export class ToolRuntime {
 		return this.configValue;
 	}
 
-	get animatesRows(): boolean {
-		return this.animateRows;
-	}
-
-	configure(config: CompactToolsConfig, animateRows: boolean): void {
-		this.reset(false);
+	configure(config: CompactToolsConfig): void {
 		this.configValue = config;
-		this.animateRows = animateRows;
 		this.configRevision = {};
 	}
 
@@ -58,40 +46,35 @@ export class ToolRuntime {
 	}
 
 	reset(clearTimings: boolean): void {
-		for (const state of this.spinningRows) this.stopSpinner(state);
-		this.trackedRows.clear();
+		this.stopIndicators();
 		if (clearTimings) this.clearTimings();
 	}
 
-	track(ctx: RenderContext, name: CompactToolName, state: RowState): void {
-		this.trackedRows.delete(ctx.toolCallId);
-		this.trackedRows.set(ctx.toolCallId, { state, name, invalidate: ctx.invalidate });
-		if (this.trackedRows.size <= MAX_TRACKED_ROWS) return;
-		const oldest = this.trackedRows.keys().next().value;
-		if (oldest !== undefined) this.trackedRows.delete(oldest);
-	}
-
-	toggleTrackedRows(): "expanded" | "collapsed" | undefined {
-		const rows: TrackedRow[] = [];
-		for (const row of this.trackedRows.values()) {
-			if (this.configValue.auto_compact[row.name] && row.state.hasResult) rows.push(row);
+	syncIndicator(toolCallId: string, running: boolean, invalidate: () => void): number {
+		if (!running) {
+			this.removeIndicator(toolCallId);
+			return 0;
 		}
-		if (rows.length === 0) return undefined;
-		const expand = rows.some(({ state }) => !state.expanded);
-		for (const { state, invalidate } of rows) {
-			state.expanded = expand;
-			invalidate();
+		this.indicatorInvalidators.set(toolCallId, invalidate);
+		if (!this.indicatorTimer) {
+			this.indicatorTimer = setInterval(() => {
+				this.indicatorFrame++;
+				for (const requestRender of this.indicatorInvalidators.values()) requestRender();
+			}, INDICATOR_INTERVAL_MS);
+			this.indicatorTimer.unref?.();
 		}
-		return expand ? "expanded" : "collapsed";
+		return this.indicatorFrame;
 	}
 
 	syncExpansion(state: RowState, hostExpanded: boolean, name: CompactToolName): boolean {
-		const initialized = this.initializeExpansion(state, name);
-		if (initialized || state.lastHostExpanded === undefined) {
-			state.lastHostExpanded = hostExpanded;
-		} else if (state.lastHostExpanded !== hostExpanded) {
+		const initialized = this.initializeExpansion(state, name, hostExpanded);
+		if (!initialized && state.lastHostExpanded !== hostExpanded) {
 			state.lastHostExpanded = hostExpanded;
-			state.expanded = !state.expanded;
+			state.expanded = hostExpanded;
+			// A non-auto-compacted row collapses back to its bounded preview. Hiding it
+			// here removes the clicked row from under the pointer, so the next click can
+			// accidentally hit the Thinking block that moved into the same coordinates.
+			state.preview = !hostExpanded && !this.configValue.auto_compact[name];
 		}
 		return state.expanded ?? false;
 	}
@@ -111,8 +94,8 @@ export class ToolRuntime {
 		const started = !ctx.argsComplete || ctx.executionStarted || running;
 		if (started && state.startedAt === undefined) state.startedAt = Date.now();
 		if (finished && state.startedAt !== undefined && state.endedAt === undefined) state.endedAt = Date.now();
+		if (finished) this.removeIndicator(ctx.toolCallId);
 		this.persistTiming(state, ctx.toolCallId);
-		this.syncSpinner(state, running, ctx.invalidate);
 		return state;
 	}
 
@@ -133,37 +116,28 @@ export class ToolRuntime {
 		};
 	}
 
-	private initializeExpansion(state: RowState, name: CompactToolName): boolean {
-		if (state.configRevision === this.configRevision) return false;
-		state.configRevision = this.configRevision;
-		state.expanded = !this.configValue.auto_compact[name];
-		return true;
+	private removeIndicator(toolCallId: string): void {
+		this.indicatorInvalidators.delete(toolCallId);
+		if (this.indicatorInvalidators.size > 0 || !this.indicatorTimer) return;
+		clearInterval(this.indicatorTimer);
+		this.indicatorTimer = undefined;
+		this.indicatorFrame = 0;
 	}
 
-	private stopSpinner(state: RowState): void {
-		if (state.timer) clearInterval(state.timer);
-		state.timer = undefined;
-		this.spinningRows.delete(state);
+	private stopIndicators(): void {
+		if (this.indicatorTimer) clearInterval(this.indicatorTimer);
+		this.indicatorTimer = undefined;
+		this.indicatorInvalidators.clear();
+		this.indicatorFrame = 0;
 	}
 
-	private syncSpinner(state: RowState, running: boolean, invalidate: () => void): void {
-		const spinner = this.configValue.spinner;
-		if (!running || !this.animateRows || spinner.frames.length < 2) {
-			this.stopSpinner(state);
-			return;
-		}
-		if (state.timer) return;
-		state.frame ??= 0;
-		state.timer = setInterval(() => {
-			state.frame = ((state.frame ?? 0) + 1) % spinner.frames.length;
-			try {
-				invalidate();
-			} catch {
-				this.stopSpinner(state);
-			}
-		}, spinner.intervalMs);
-		state.timer.unref?.();
-		this.spinningRows.add(state);
+	private initializeExpansion(state: RowState, name: CompactToolName, hostExpanded = false): boolean {
+		if (state.configRevision === this.configRevision) return false;
+		state.configRevision = this.configRevision;
+		state.lastHostExpanded = hostExpanded;
+		state.expanded = hostExpanded;
+		state.preview = !hostExpanded && !this.configValue.auto_compact[name];
+		return true;
 	}
 
 	private restoreTiming(state: RowState, toolCallId: string): boolean {