@estebanforge/pi-antigravity-bridge 1.8.6 → 1.8.7

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.8.7] - 2026-10-21
+
+### Changed
+
+- **Consecutive `bridge_poll_result` polls collapse into one counted transcript line.** Each poll used to append its own display-only entry (observed live: 60 `Poll git_commit` entries from a single wait, flushed in bursts when the parked round-trip resolved). Poll events now fold into a single ♊︎-marked `agy-poll-run` entry per consecutive run (`♊︎ bridge_poll_result Poll git_commit (x30)`; expanded view shows the poll span) with a live dim status counter while a run is open. Runs close on a target switch, the next non-poll display event, turn end, and agent end. Bridge footer statuses (`agy-native`, `agy-usage`, the poll counter) now render muted, matching pi-hostname's dim treatment.
+
 ## [1.8.6] - 2026-10-20
 
 ### Changed

package/README.md

@@ -42,7 +42,7 @@ The bridge starts a localhost MCP server inside pi's process. The exposed catalo
 
 **Upstream pi APIs only.** Bridge calls park in the provider's round-trip store; the provider ends the pi assistant message with a `toolUse` stop reason for the real pi tool, pi executes it in its own loop (native cards, permissions, hooks), and the toolResult completes the parked MCP response on the next stream call.
 
-**Long calls don't die.** agy's MCP client abandons a `tools/call` request at a flat ~180s, which used to kill any pi tool that ran longer (a long peer review, a build, a commit preview waiting for you). A call still running after ~20 seconds now settles its HTTP request with a `STILL RUNNING` answer carrying a `callId` while pi keeps executing; agy fetches the result through the bridge-local `bridge_poll_result` tool and polls until it lands. Delegation-shaped tools (pi subagent/delegation tools, e.g. `subagent_run`, `agent_spawn`) hold the synchronous window 120s instead (issue #6: orchestrators expect a plain result across the 30-120s subagent range, and 120s stays under the 180s wall); `escalateLongTools` in config.json adds custom names. Escalated calls get their own 30-minute budget, so human-gated tools can take as long as the human takes. Fast calls stay fully synchronous and never see any of this. If a park does fail (abort, timeout, recycle), the late result is re-routed to agy as a follow-up prompt in the same conversation instead of being lost.
+**Long calls don't die.** agy's MCP client abandons a `tools/call` request at a flat ~180s, which used to kill any pi tool that ran longer (a long peer review, a build, a commit preview waiting for you). A call still running after ~20 seconds now settles its HTTP request with a `STILL RUNNING` answer carrying a `callId` while pi keeps executing; agy fetches the result through the bridge-local `bridge_poll_result` tool and polls until it lands. Delegation-shaped tools (pi subagent/delegation tools, e.g. `subagent_run`, `agent_spawn`) hold the synchronous window 120s instead (issue #6: orchestrators expect a plain result across the 30-120s subagent range, and 120s stays under the 180s wall); `escalateLongTools` in config.json adds custom names. Escalated calls get their own 30-minute budget, so human-gated tools can take as long as the human takes. Fast calls stay fully synchronous and never see any of this. If a park does fail (abort, timeout, recycle), the late result is re-routed to agy as a follow-up prompt in the same conversation instead of being lost. Consecutive polls render as ONE ♊︎-marked counted line (`♊︎ bridge_poll_result Poll git_commit (x30)`) instead of one entry per poll, with a live muted status counter while a run is open.
 
 **Recursion safety.** Only the provider's agy receives the extra `--add-dir`. `AskAntigravity` is also filtered from the exposed tool list. Its delegated `agy -p` spawns with just the workspace, and for the whole delegated run the bridge hides its global per-pid entries: disabled before the spawn, released only on process close or error - agy watches the config and hot-reloads MCP servers on file changes, so a mid-run re-enable would poke the live delegation back into pi. A cross-process marker (`suppression.json` in the bridge's extensions-data dir) coordinates concurrent delegations: entries come back only when no live delegation remains, a session starting mid-delegation registers its own entry disabled, and the session-start heal re-enables only once the last delegator is gone (dead entries pruned by pid liveness with a 24h age bound). The inner agy therefore sees no bridge and cannot re-enter pi. Foreign servers in the global config are never touched.
 

package/extensions/index.ts

@@ -48,6 +48,7 @@ import {
 	formatPollAnswer,
 	type NativeDisplayEvent,
 } from "../src/provider.js";
+import { PollRunFolder, type PollRunData } from "../src/poll-fold.js";
 import {
 	createShadowTool,
 	stripMarkerFields,
@@ -396,15 +397,52 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			}
 			return new Text(lines.join("\n"), 0, 0);
 		});
+		// Collapsed poll runs: one ♊︎-marked counted line per consecutive poll
+		// burst instead of one entry per poll.
+		pi.registerEntryRenderer<PollRunData>("agy-poll-run", (entry, { expanded }, theme) => {
+			const run = entry.data;
+			const count = run?.count ?? 0;
+			const label = `Poll ${run?.target ?? "bridge call"} (x${count}${run?.state === "failed" ? ", failed" : ""})`;
+			const lines = [`♊︎ ${theme.fg("toolTitle", POLL_TOOL_NAME)} ${theme.fg("muted", label)}`];
+			if (expanded && run) {
+				const time = (iso: string): string => new Date(iso).toLocaleTimeString();
+				lines.push(theme.fg("dim", `${count} ${count === 1 ? "poll" : "polls"}, ${time(run.firstAt)} → ${time(run.lastAt)}`));
+			}
+			return new Text(lines.join("\n"), 0, 0);
+		});
 	}
 	let pendingNativeTools = 0;
+	const pollRuns = new PollRunFolder();
+	const closePollRun = (): void => {
+		const settled = pollRuns.flush();
+		if (settled) pi.appendEntry<PollRunData>("agy-poll-run", settled);
+		setDimStatus("agy-poll", undefined);
+	};
+	// Footer statuses render muted, matching pi-hostname's dim treatment.
+	const setDimStatus = (key: string, text: string | undefined): void => {
+		const ui = activeUi;
+		if (!ui) return;
+		ui.setStatus(key, text === undefined ? undefined : ui.theme.fg("dim", text));
+	};
 	const onNativeEvent = (event: NativeDisplayEvent): void => {
-		if (engine !== "acp" || event.mcpServer === "pi-bridge") return;
+		if (engine !== "acp") return;
+		// Polls are bridge-local (never get a genuine Pi card); the mcpServer
+		// tag is unreliable on these frames, so the tool name discriminates.
+		if (event.name === POLL_TOOL_NAME) {
+			const view = event.callId ? roundTrips.poll(event.callId) : undefined;
+			const switched = pollRuns.add(view?.name ?? "unknown call", view?.state ?? "running", new Date());
+			if (switched) pi.appendEntry<PollRunData>("agy-poll-run", switched);
+			const open = pollRuns.open;
+			setDimStatus("agy-poll", open ? `♊︎ bridge_poll_result → ${open.target} (x${open.count})` : undefined);
+			return;
+		}
+		closePollRun();
+		if (event.mcpServer === "pi-bridge") return;
 		// MCP calls through our own pi-bridge already have genuine Pi tool cards;
 		// only native Antigravity / other MCP events need display-only entries.
 		if (event.status === "started") {
 			pendingNativeTools++;
-			activeUi?.setStatus("agy-native", `agy ${event.name}… (${pendingNativeTools})`);
+			setDimStatus("agy-native", `agy ${event.name}… (${pendingNativeTools})`);
 			return;
 		}
 		pendingNativeTools = Math.max(0, pendingNativeTools - 1);
@@ -439,6 +477,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			outcome.status === "OK" ? "info" : "warn",
 		);
 		roundTrips.failAll(FAIL_REASON_TURN_END);
+		// Closes a poll run that no display event flushed.
+		closePollRun();
 		// Stamp live escalations with the ended turn's conversation: the park
 		// pass returns before the provider's store.set, so a first-turn park
 		// has no other record of where its result must be re-delivered.
@@ -454,7 +494,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		pi.on("message_update", (event, ctx) => {
 			if (!ctx.hasUI || event.message.role !== "assistant" || event.message.provider !== "antigravity" || loadConfig().acp.usageEstimate === "off") return;
 			const { input, output } = event.message.usage;
-			const status = `ACP ≈ ${input} in / ${output} out`;
+			const status = ctx.ui.theme.fg("dim", `ACP ≈ ${input} in / ${output} out`);
 			if (status !== lastUsageStatus) {
 				lastUsageStatus = status;
 				ctx.ui.setStatus("agy-usage", status);
@@ -467,6 +507,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		pi.on("agent_end", (event, ctx) => {
 			clearUsageStatus(event, ctx);
 			pendingNativeTools = 0;
+			closePollRun();
 			if (ctx.hasUI) ctx.ui.setStatus("agy-native", undefined);
 		});
 		pi.on("session_shutdown", (event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.8.6",
+  "version": "1.8.7",
   "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. Use antigravity/* models in Pi. Full /model picker support. Models runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",

package/src/poll-fold.ts

@@ -0,0 +1,55 @@
+// Fold state machine for bridge_poll_result display events: consecutive
+// polls collapse into ONE counted transcript entry instead of one entry per
+// poll (observed live 2026-10-21: 60 "Poll git_commit" entries from a single
+// wait, all flushed in bursts when the parked round-trip resolved).
+//
+// Runs close on a target switch, on any non-poll display event, or at turn
+// end; the caller persists each closed run as an "agy-poll-run" entry.
+
+export interface PollRunData {
+	/** The pi tool the model kept polling, e.g. "git_commit". */
+	target: string;
+	count: number;
+	/** Strongest poll outcome seen: running < done < failed. Sticky so a
+	 *  still-running poll after a terminal one cannot downgrade the summary. */
+	state: "running" | "done" | "failed";
+	firstAt: string;
+	lastAt: string;
+}
+
+const STATE_RANK: Record<PollRunData["state"], number> = { running: 0, done: 1, failed: 2 };
+
+export class PollRunFolder {
+	#run: PollRunData | undefined;
+
+	/** The open run, for a live status-line counter. */
+	get open(): PollRunData | undefined {
+		return this.#run;
+	}
+
+	/** Fold one poll event. Returns a run to persist when this poll switched
+	 *  targets away from the open run; the new poll always starts or extends
+	 *  a run, so callers append the return value BEFORE reading `open`. */
+	add(target: string, state: PollRunData["state"], at: Date): PollRunData | undefined {
+		let closed: PollRunData | undefined;
+		if (this.#run && this.#run.target !== target) closed = this.#close();
+		if (!this.#run) {
+			this.#run = { target, count: 0, state: "running", firstAt: at.toISOString(), lastAt: at.toISOString() };
+		}
+		this.#run.count += 1;
+		this.#run.lastAt = at.toISOString();
+		if (STATE_RANK[state] > STATE_RANK[this.#run.state]) this.#run.state = state;
+		return closed;
+	}
+
+	/** Close and return the open run, if any. Idempotent. */
+	flush(): PollRunData | undefined {
+		return this.#run ? this.#close() : undefined;
+	}
+
+	#close(): PollRunData {
+		const run = this.#run as PollRunData;
+		this.#run = undefined;
+		return run;
+	}
+}

package/src/provider.ts

@@ -332,6 +332,9 @@ export interface NativeDisplayEvent {
 	name: string;
 	mcpServer?: string;
 	status: "started" | "completed" | "failed";
+	/** Bridge callId from the tool args (poll calls carry one); lets the
+	 *  extension resolve the polled pi tool via the escalation registry. */
+	callId?: string;
 	path?: string;
 	command?: string;
 	output?: string;
@@ -1143,10 +1146,16 @@ export function consumeActivity(
 			// model-facing result is produced. Persist a card only on completion.
 			if (feats.engine === "acp" && feats.onNativeEvent) {
 				try {
-					feats.onNativeEvent({ name: activity.name, mcpServer: activity.mcpServer, status: "started" });
+					feats.onNativeEvent({ name: activity.name, mcpServer: activity.mcpServer, status: "started", callId: callIdArg(activity.args) });
 				} catch { /* UI failure must not fail the generation. */ }
 			}
 			return "continue";
+/** Bridge callId arg of an MCP tool call (bridge_poll_result requires it). */
+function callIdArg(args: Record<string, unknown>): string | undefined {
+	const v = args.callId;
+	return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
 /** File-path argument of an ACP edit tool (observed: `file_path`); other
  *  tool kinds (execute, read) don't carry one. Returns undefined for
  *  non-edit tools. */
@@ -1183,7 +1192,7 @@ function acpEditFileArg(args: Record<string, unknown>): string | undefined {
 				let displayed = false;
 				try {
 					if (feats.onNativeEvent) {
-						feats.onNativeEvent({ name: activity.name, mcpServer: activity.mcpServer, status: "completed", path: file, command, output: activity.output, diff: diffText });
+						feats.onNativeEvent({ name: activity.name, mcpServer: activity.mcpServer, status: "completed", path: file, command, output: activity.output, diff: diffText, callId: callIdArg(activity.args) });
 						displayed = true;
 					}
 				} catch { /* A stale renderer must never fail the model turn. */ }