@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

package/src/eval/__tests__/heartbeat.test.ts

@@ -1,84 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { EVAL_HEARTBEAT_OP, setBridgeHeartbeatIntervalMs, withBridgeHeartbeat } from "../heartbeat";
-import type { JsStatusEvent } from "../js/shared/types";
-
-describe("withBridgeHeartbeat", () => {
-	afterEach(() => {
-		setBridgeHeartbeatIntervalMs();
-	});
-
-	it("pumps heartbeat events on cadence while the operation is pending, then stops", async () => {
-		setBridgeHeartbeatIntervalMs(20);
-		const events: JsStatusEvent[] = [];
-
-		const value = await withBridgeHeartbeat(
-			event => events.push(event),
-			async () => {
-				await Bun.sleep(130);
-				return "done";
-			},
-		);
-
-		expect(value).toBe("done");
-		// ~6 ticks fit in 130ms at a 20ms cadence; assert it ticked repeatedly
-		// without pinning the exact count (scheduler jitter).
-		expect(events.length).toBeGreaterThanOrEqual(3);
-		expect(events.every(event => event.op === EVAL_HEARTBEAT_OP)).toBe(true);
-
-		// The interval is cleared once the operation settles: no further ticks.
-		const settledCount = events.length;
-		await Bun.sleep(80);
-		expect(events.length).toBe(settledCount);
-	});
-
-	it("emits a heartbeat immediately so a bridge call extends the budget at once", async () => {
-		// Interval far longer than the operation: the only beat that can fire is
-		// the immediate one at call start. It must still reach the sink.
-		setBridgeHeartbeatIntervalMs(10_000);
-		const events: JsStatusEvent[] = [];
-
-		await withBridgeHeartbeat(
-			event => events.push(event),
-			async () => {
-				await Bun.sleep(30);
-				return "done";
-			},
-		);
-
-		expect(events.length).toBe(1);
-		expect(events[0]?.op).toBe(EVAL_HEARTBEAT_OP);
-	});
-
-	it("runs the operation without emitting when no status sink is wired", async () => {
-		setBridgeHeartbeatIntervalMs(5);
-		let ran = 0;
-
-		const value = await withBridgeHeartbeat(undefined, async () => {
-			ran++;
-			await Bun.sleep(40);
-			return 42;
-		});
-
-		expect(value).toBe(42);
-		expect(ran).toBe(1);
-	});
-
-	it("clears the heartbeat even when the operation throws", async () => {
-		setBridgeHeartbeatIntervalMs(15);
-		const events: JsStatusEvent[] = [];
-
-		await expect(
-			withBridgeHeartbeat(
-				event => events.push(event),
-				async () => {
-					await Bun.sleep(60);
-					throw new Error("boom");
-				},
-			),
-		).rejects.toThrow("boom");
-
-		const afterThrow = events.length;
-		await Bun.sleep(60);
-		expect(events.length).toBe(afterThrow);
-	});
-});

package/src/eval/heartbeat.ts

@@ -1,74 +0,0 @@
-/**
- * Keepalive for in-flight host-side eval bridge calls.
- *
- * The eval watchdog ({@link ../tools/eval IdleTimeout}) caps a cell's `timeout`
- * as a wall-clock budget on the cell's *own* work, but pauses that budget while
- * a host-side `agent()`/`parallel()` (via `runSubprocess`) or `llm()` (a single
- * completion) call is in flight. Those calls are the only thing that re-arms the
- * watchdog — and they can run for long stretches with **no** status of their own
- * (a subagent's time-to-first-token on a reasoning model, a long quiet nested
- * tool, or the entire body of a oneshot `llm()` call). Without a keepalive the
- * watchdog would mistake that delegated work for the cell stalling and abort it
- * mid-flight, killing the subagent.
- *
- * {@link withBridgeHeartbeat} bridges that gap by emitting a synthetic
- * {@link EVAL_HEARTBEAT_OP} status event immediately when the call begins and
- * then on a fixed cadence until it settles. The event rides the same
- * `emitStatus → onStatus` channel both runtimes already forward, so it re-arms
- * the watchdog without any new plumbing. The heartbeat is the *sole* signal that
- * extends the budget: consumers MUST treat it as a pure keepalive — bump the
- * watchdog and drop it (never persist or render it) — see the executor display
- * sinks and the eval tool's `onStatus` handler. Every other status event
- * (compute helpers, `log()`/`phase()`, tool results) counts against the budget.
- */
-import type { JsStatusEvent } from "./js/shared/types";
-
-/**
- * Synthetic status op emitted purely to keep the eval idle watchdog alive while
- * a host-side bridge call is in flight. Carries no payload.
- */
-export const EVAL_HEARTBEAT_OP = "heartbeat";
-
-/**
- * Heartbeat cadence. Comfortably below the default 30s idle budget (and the
- * larger budgets long fanouts run under), so a working bridge call always bumps
- * the watchdog before it expires, while a genuine stall is still bounded once
- * the call settles and the heartbeat stops.
- */
-const HEARTBEAT_INTERVAL_MS = 5_000;
-
-let heartbeatIntervalMs = HEARTBEAT_INTERVAL_MS;
-
-/**
- * Test seam: override the heartbeat cadence so integration tests can exercise
- * the keepalive within a sub-second idle budget. Pass no value to restore the
- * production default.
- */
-export function setBridgeHeartbeatIntervalMs(ms?: number): void {
-	heartbeatIntervalMs = ms === undefined ? HEARTBEAT_INTERVAL_MS : Math.max(1, Math.floor(ms));
-}
-
-/**
- * Run {@link operation}, pumping {@link EVAL_HEARTBEAT_OP} status events through
- * {@link emitStatus} — one immediately, then on a fixed cadence — until it
- * settles. The immediate beat pauses the watchdog the instant the call begins,
- * so a bridge call that starts close to the budget edge (after the cell already
- * spent most of it computing) is not aborted before the first interval tick. A
- * no-op wrapper when no `emitStatus` sink is wired (the heartbeat would reach
- * nobody).
- */
-export async function withBridgeHeartbeat<T>(
-	emitStatus: ((event: JsStatusEvent) => void) | undefined,
-	operation: () => Promise<T>,
-): Promise<T> {
-	if (!emitStatus) return operation();
-	emitStatus({ op: EVAL_HEARTBEAT_OP });
-	const timer = setInterval(() => emitStatus({ op: EVAL_HEARTBEAT_OP }), heartbeatIntervalMs);
-	// Never keep the event loop alive for the heartbeat alone.
-	timer.unref?.();
-	try {
-		return await operation();
-	} finally {
-		clearInterval(timer);
-	}
-}