@estebanforge/pi-antigravity-bridge 1.3.0 → 1.3.2

package/extensions/index.ts

@@ -2,9 +2,8 @@
 //
 // Registers Gemini (via the agy CLI) as a pi model provider so it shows up in
 // the /model picker as antigravity/gemini-*. When selected, pi routes each turn
-// through streamSimple, which spawns `agy -p`, polls the conversation SQLite DB
-// agy writes, decodes the protobuf step payloads, and streams the agent text
-// back into pi's TUI.
+// through streamSimple, which feeds the persistent stream-json driver process
+// and streams the agent text back into pi's TUI.
 //
 // Architectural wall (cannot be worked around - see PLAN.md):
 //   agy runs its OWN closed tool loop against --add-dir. pi's read/write/edit/
@@ -301,7 +300,6 @@ function statusText(ctx: AgyCommandCtx): string {
 		`  tool thinking: ${config.defaultThinking}`,
 		`  sessions:      ${ctx.store.size} bound`,
 		`  config:        ${CONFIG_PATH}`,
-		`  engine:        ${config.engine}`,
 		`  bridge tools:  ${config.bridgeTools}`,
 		`  digest:        ${config.digest ? "on" : "off"}`,
 		"",
@@ -352,7 +350,6 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				const port = ctx.getMcpPort();
 				const lines = [
 					"Antigravity doctor (no tokens spent)",
-					`  engine:        ${config.engine}`,
 					`  bridge:        ${config.bridgeTools}${port ? ` (port ${port})` : " (not running)"}`,
 					`  driver:        ${snap.state}${snap.pid ? ` pid=${snap.pid}` : ""}${snap.conversationId ? ` conv=${snap.conversationId.slice(0, 8)}` : ""}`,
 					`  driver stats:  spawns=${snap.stats.spawns} turns=${snap.stats.turns} reused=${snap.stats.reused} recycles=${snap.stats.recycles}${snap.stats.lastRecycleReason ? ` (last: ${snap.stats.lastRecycleReason})` : ""}`,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.3.0",
-  "description": "Streaming Gemini provider for pi, built on the agy CLI. Registers antigravity/* models in pi's /model picker via SQLite polling + protobuf decode of agy's conversation DBs.",
+  "version": "1.3.2",
+  "description": "Streaming Gemini provider for pi, built on the agy CLI. Registers antigravity/* models in pi's /model picker; drives agy through its stream-json protocol (persistent process, tool round-trips, live usage).",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -30,8 +30,6 @@
     "build": "tsc --noEmit",
     "test": "vitest run",
     "prepublishOnly": "npm run build && npm test",
-    "run-agy": "tsx scripts/run-agy.ts",
-    "decode-db": "tsx scripts/decode-db.ts",
     "smoke:pi": "bash scripts/smoke-in-pi.sh"
   },
   "files": [

package/src/config.ts

@@ -24,7 +24,6 @@ const CONFIG_PATH = path.join(
 
 export type AgyMode = "accept-edits" | "plan";
 export type ThinkingTier = "low" | "medium" | "high";
-export type AgyEngine = "stream-json" | "legacy-sqlite";
 export type BridgeTools = "none" | "mcp" | "all";
 
 export interface AgyConfig {
@@ -39,11 +38,6 @@ export interface AgyConfig {
 	defaultModel: string;
 	/** AskAntigravity tool: default thinking tier when the alias names none. */
 	defaultThinking: ThinkingTier;
-	/** Turn engine. "stream-json" (default): one persistent agy process fed
-	 *  NDJSON user events; enables live toolUse round-trips, native usage, and
-	 *  conversation binding from the init event. "legacy-sqlite": the old
-	 *  spawn-`agy -p`-and-poll-SQLite path, kept as a fallback for one release. */
-	engine: AgyEngine;
 	/** Set after the one-time notice about a leftover legacy invokeTool patch
 	 *  on the installed pi. The notice never repeats; /agy patch-cleanup is
 	 *  always available. */
@@ -73,7 +67,6 @@ const DEFAULTS: AgyConfig = {
 	skipPermissions: true,
 	defaultModel: "flash",
 	defaultThinking: "medium",
-	engine: "stream-json",
 	bridgeTools: "mcp",
 	digest: false,
 };
@@ -120,11 +113,6 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 	const defaultThinking: ThinkingTier =
 		thinkRaw === "low" || thinkRaw === "high" ? thinkRaw : "medium";
 
-	const engine: AgyEngine =
-		process.env.AGY_ENGINE === "legacy-sqlite" || file.engine === "legacy-sqlite"
-			? "legacy-sqlite"
-			: "stream-json";
-
 	const bridgeRaw = (process.env.AGY_BRIDGE_TOOLS ?? file.bridgeTools ?? DEFAULTS.bridgeTools).toLowerCase();
 	const bridgeTools: BridgeTools =
 		bridgeRaw === "none" || bridgeRaw === "all" ? bridgeRaw : "mcp";
@@ -138,7 +126,6 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		skipPermissions,
 		defaultModel,
 		defaultThinking,
-		engine,
 		bridgeTools,
 		digest,
 		patchCleanupNotified: file.patchCleanupNotified === true,

package/src/provider.ts

@@ -29,7 +29,6 @@ import {
 	type Usage,
 } from "@earendil-works/pi-ai";
 import type { Api } from "@earendil-works/pi-ai";
-import { runAgyTurn, type AgyEvent, type AgyRunOptions } from "./runner.js";
 import { AgyDriver, type DriverActivity, type TurnHandle } from "./driver.js";
 import { toPiUsage } from "./stream-events.js";
 import { mapAgyToolToNative } from "./native-tools.js";
@@ -245,11 +244,8 @@ export interface BlockState {
 export interface StreamSimpleDeps {
 	entries: AgyModelEntry[];
 	store: SessionStore;
-	/** Override the agy turn runner (tests inject a scripted event source).
-	 *  Defaults to the real runAgyTurn. Legacy engine only. */
-	runAgyTurn?: typeof runAgyTurn;
-	/** Persistent stream-json engine. When set (and config.engine selects it),
-	 *  turns run on the driver and bridge calls park as toolUse round-trips. */
+	/** Persistent stream-json driver. Turns run on the driver and bridge
+	 *  calls park as toolUse round-trips. Required with roundTrips. */
 	driver?: AgyDriver;
 	roundTrips?: ToolRoundTrips;
 	/** Replay store for the display-only antigravity wrapper tool. Required
@@ -692,13 +688,12 @@ async function runTurnDriver(
 export function createStreamSimple(
 	deps: StreamSimpleDeps,
 ): (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream {
-	const { entries, store, runAgyTurn: runFn = runAgyTurn, driver, roundTrips } = deps;
+	const { entries, store, driver, roundTrips } = deps;
 
 	return function streamSimple(model, context, options) {
 		const stream = createAssistantMessageEventStream();
 		// Fire the async turn; return the stream synchronously per pi's contract.
-		const config = loadConfig();
-		if (driver && roundTrips && config.engine === "stream-json") {
+		if (driver && roundTrips) {
 			void runTurnDriver(stream, model, context, options, entries, store, {
 				driver,
 				roundTrips,
@@ -706,183 +701,16 @@ export function createStreamSimple(
 				nativeActive: deps.nativeActive,
 			});
 		} else {
-			void runTurn(stream, model, context, options, entries, store, runFn);
+			// Miswired extension: no driver means no engine. Fail the turn visibly
+			// instead of silently producing an empty assistant message.
+			const partial = newAssistant(model);
+			const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
+			finalize(stream, blocks, "error", "antigravity driver not configured");
 		}
 		return stream;
 	};
 }
 
-async function runTurn(
-	stream: AssistantMessageEventStream,
-	model: Model<Api>,
-	context: Context,
-	options: SimpleStreamOptions | undefined,
-	entries: AgyModelEntry[],
-	store: SessionStore,
-	runFn: typeof runAgyTurn,
-): Promise<void> {
-	const partial = newAssistant(model);
-	const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
-
-	// Direct emit helpers. agy streams deltas that may not align to line
-	// boundaries; pi's TUI renders partial lines fine, so we append and push
-	// each delta straight through (no filtering, no buffering).
-	const appendTextDelta = (delta: string): void => {
-		appendText(stream, blocks, delta);
-	};
-	const appendThinkingDelta = (delta: string): void => {
-		appendThinking(stream, blocks, delta);
-	};
-
-	// Signal the turn has begun IMMEDIATELY. pi's native Working indicator is
-	// driven by the stream's start event (isStreaming). Without this, agy's
-	// initial thinking seconds (before it emits any step) show nothing and the
-	// UI looks frozen. Lazy start (on first content) was the old behavior.
-	ensureStarted(stream, blocks);
-
-	const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-	const key = sessionKey(options, cwd);
-	const existing = store.get(key);
-	const messageCount = context.messages.length;
-
-	const prompt = extractUserPrompt(context);
-	if (!prompt) {
-		finalize(stream, blocks, "error", "No user message to send to agy.");
-		return;
-	}
-
-	// Runtime config (mode, permissions, digest). Loaded fresh each turn so
-	// /agy toggles take effect immediately without a reload.
-	const config = loadConfig();
-
-	// G1: inject a delta digest of pi-side context agy was not spawned for
-	// (compaction summaries, other-provider turns), gated on config.digest:
-	// the digest changes every turn and defeats agy's prompt cache. agy keeps
-	// its own history; see docs/PI-BRIDGE-GAPS.md (G1).
-	const watermark = existing?.lastMessageCount ?? 0;
-	const digest = config.digest ? buildContextDigest(context.messages, watermark) : "";
-	const fullPrompt = digest ? `${DIGEST_PREAMBLE}\n\n${digest}\n\n---\n\n${prompt}` : prompt;
-
-	// Resolve the pi model id to its catalog entry. On a miss, fall through to
-	// the id itself  -  agy will likely reject, but the error reaches the user
-	// instead of a silent no-op.
-	const entry = entries.find((e) => e.id === model.id) ?? null;
-	const agyModel = entry?.full ?? model.id;
-
-
-	// Effort-driven bases always need --effort (a base slug is invalid on its
-	// own); fixed models never get it (agy rejects --effort for them). For an
-	// effort-driven base we clamp pi's level to the tiers agy offers it.
-	const effort = entry?.efforts?.length ? toAgyEffort(options?.reasoning, entry.efforts) : undefined;
-
-	const runOpts: AgyRunOptions = {
-		cwd,
-		model: agyModel,
-		mode: config.mode,
-		skipPermissions: config.skipPermissions,
-		effort,
-		prompt: fullPrompt,
-		conversationId: existing?.conversationId ?? null,
-		baseStepIdx: existing?.lastStepIdx ?? -1,
-		timeoutMin: DEFAULT_TIMEOUT_MIN,
-		signal: options?.signal,
-	};
-
-	// G8: per-turn diff context for agy's file edits (write_to_file et al.).
-	// Turn-scoped so concurrent turns never share OLD-content caches.
-	const diffCtx = new TurnDiffContext(createExecGitOps());
-
-	const onEvent = (event: AgyEvent) => {
-		switch (event.kind) {
-			case "text":
-				appendTextDelta(event.text);
-				break;
-			case "thinking":
-				appendThinkingDelta(event.text);
-				break;
-			case "tool": {
-				// G8: if agy wrote a file, surface a git-sourced diff; else the plain
-				// tool label. Always shown (agy's own tool loop, surfaced for visibility).
-				const edit = parseEditToolInput(event.inputJson ?? "");
-				if (edit) {
-					const absFile = path.isAbsolute(edit.file) ? edit.file : path.resolve(cwd, edit.file);
-					const outcome = diffCtx.diffEdit(absFile, edit.content);
-					const label = edit.description ?? path.basename(absFile);
-					appendThinkingDelta(`[agy edit: ${label}]\n`);
-					if (outcome.text) appendThinkingDelta(`${outcome.text}\n`);
-				} else {
-					appendThinkingDelta(`[agy tool: ${event.name}]\n`);
-				}
-				break;
-			}
-			case "title":
-				// Conversation title metadata  -  not streamed to the user.
-				break;
-		}
-	};
-
-	let result;
-	try {
-		result = await runFn(runOpts, onEvent);
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		finalize(stream, blocks, "error", `agy failed to start: ${msg}`);
-		return;
-	}
-
-	// Persist for the next turn (resume). Only bind when we actually discovered
-	// an id  -  a discovery miss shouldn't clobber a prior good binding.
-	// Persist for the next turn (resume). Only bind when we actually discovered
-	// an id  -  a discovery miss shouldn't clobber a prior good binding. The
-	// lastMessageCount watermark advances on a successful bind even if the turn
-	// later aborted or timed out: the prompt (digest included) was handed to
-	// agy at spawn, so its DB has seen that context. Guarding this on
-	// exitCode===0 would re-inject stale deltas after retryable failures.
-	if (result.conversationId) {
-		store.set(key, {
-			conversationId: result.conversationId,
-			lastStepIdx: result.lastIdx,
-			lastMessageCount: messageCount,
-		});
-	}
-
-	if (result.aborted) {
-		finalize(stream, blocks, "aborted", "Operation aborted");
-		return;
-	}
-	if (result.timedOut) {
-		const note = `agy exceeded the ${runOpts.timeoutMin}m timeout`;
-		finalize(stream, blocks, "error", note);
-		return;
-	}
-	if (result.exitCode !== 0) {
-		const detail = result.stderr.trim() || `agy exited with status ${result.exitCode}`;
-		finalize(stream, blocks, "error", detail);
-		return;
-	}
-
-	// Discovery miss: agy exited cleanly but we never bound a conversation id
-	// this turn (ambiguous snapshot, DB not created in time, or a prior session
-	// whose id failed CONV_ID_RE and silently fell through to fresh discovery).
-	// Guard on whether we bound THIS turn, not on whether a prior session
-	// existed - otherwise a corrupt existing entry re-opens the silent-empty-
-	// success hole the first review closed.
-	if (!result.conversationId) {
-		const detail =
-			"agy exited cleanly but its conversation database could not be bound. " +
-			"The run may have partially applied edits with no visible output.";
-		finalize(stream, blocks, "error", detail);
-		return;
-	}
-
-	// Success. If no text ever streamed (agy did only tool work, or returned
-	// empty), emit an empty text block so pi has a well-formed assistant turn.
-	if (blocks.textIdx === null && blocks.thinkingIdx === null) {
-		ensureTextOpen(stream, blocks);
-	}
-	finalize(stream, blocks, "stop");
-}
-
 /** Signal the start of the assistant turn exactly once. `start` is
  *  turn-level (analogous to Anthropic's message_start), not per-block  -  the
  *  per-block signals are text_start / thinking_start. */

package/src/poller.ts

@@ -1,202 +0,0 @@
-// Read-only poller over an agy conversation SQLite DB.
-//
-// Opens ~/.gemini/antigravity-cli/conversations/<uuid>.db read-only and reads
-// newly-appended rows from the `steps` table on each poll. Uses node:sqlite
-// (built into Node >= 22.5; this machine is 26.5.0) so there is no native
-// dependency to ship. The caller drives a 250ms poll loop.
-//
-// Coalescing: agy's writer commits through its own connection, so we use
-// SQLite's `PRAGMA data_version` to skip the SELECT when nothing has changed
-// since the last poll (agy-acp pattern). data_version bumps on every commit
-// by another connection  -  cheap and exact.
-
-import fs from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import { toUint8 } from "./protobuf.js";
-
-/** A raw step row as read from the DB. payload is the undecoded step_payload
- *  BLOB; callers pass it to the protobuf extractor. */
-export interface Step {
-	idx: number;
-	stepType: number;
-	status: number;
-	payload: Uint8Array;
-}
-
-const SELECT_STEPS =
-	"SELECT idx, step_type, status, step_payload FROM steps WHERE idx > ? ORDER BY idx";
-const SELECT_STEP_AT =
-	"SELECT idx, step_type, status, step_payload FROM steps WHERE idx = ?";
-
-const HAS_STEPS =
-	"SELECT COUNT(*) > 0 AS present FROM sqlite_master WHERE type='table' AND name='steps'";
-
-/** Open the DB read-only. Returns null when the file doesn't exist yet or
- *  lacks a steps table (agy hasn't created/flushed it). Throws are swallowed
- *  so a transient lock or half-written file is retried on the next poll. */
-function openReadOnly(dbPath: string): DatabaseSync | null {
-	if (!fs.existsSync(dbPath)) return null;
-	try {
-		const db = new DatabaseSync(dbPath, { readOnly: true });
-		const row = db.prepare(HAS_STEPS).get() as { present?: number } | undefined;
-		if (!row?.present) {
-			db.close();
-			return null;
-		}
-		return db;
-	} catch {
-		return null;
-	}
-}
-
-/** A reusable read handle on one conversation's steps table.
- *
- * Keeps one DB connection + prepared statement open for the life of a turn,
- * so the poll loop isn't re-opening the file each tick. `poll()` returns only
- * rows newer than the last one seen, advancing an internal cursor.
- *
- * A row whose payload fails to materialize (torn read while agy is mid-write)
- * is dropped, not thrown  -  its idx is NOT advanced past, so it's retried on
- * the next poll once the write settles. (agy-acp database.ts pattern.) */
-export class ConversationPoller {
-
-	private db: DatabaseSync | null = null;
-	private selectStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private selectAtStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private dataVersionStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private lastDataVersion: number | null = null;
-	private _lastIdx: number;
-
-	constructor(
-		private readonly dbPath: string,
-		baseStepIdx = -1,
-	) {
-		this._lastIdx = baseStepIdx;
-		this.db = openReadOnly(dbPath);
-		if (this.db) {
-			this.selectStmt = this.db.prepare(SELECT_STEPS);
-			this.selectAtStmt = this.db.prepare(SELECT_STEP_AT);
-			this.dataVersionStmt = this.db.prepare("PRAGMA data_version");
-		}
-	}
-
-	/** True if the DB was openable at construction. False means agy hasn't
-	 *  created/flushed it yet  -  call tryOpen() on later polls. */
-	get isOpen(): boolean {
-		return this.db !== null;
-	}
-
-	/** The highest idx seen (or the base passed at construction). Persist this
-	 *  across turns so a resumed conversation only streams new steps. */
-	get lastIdx(): number {
-		return this._lastIdx;
-	}
-
-	/** Retry opening the DB if it wasn't ready at construction. Returns the
-	 *  new open state. Idempotent. */
-	tryOpen(): boolean {
-		if (this.db) return true;
-		this.db = openReadOnly(this.dbPath);
-		if (this.db) {
-			this.selectStmt = this.db.prepare(SELECT_STEPS);
-			this.selectAtStmt = this.db.prepare(SELECT_STEP_AT);
-			this.dataVersionStmt = this.db.prepare("PRAGMA data_version");
-			return true;
-		}
-		return false;
-	}
-
-	/** Returns true when another connection has committed since the last poll.
-	 *  When false, readNewSteps() and poll() are guaranteed to return [] and can
-	 *  be skipped. Call ONCE per tick: it advances the data_version cursor, so a
-	 *  second call in the same tick sees no change. Exposed so the runner can
-	 *  gate its in-place step re-read (readStepAt) behind the same check and
-	 *  avoid a redundant SELECT every idle tick while agy is thinking. */
-	hasChanged(): boolean {
-		if (!this.db || !this.dataVersionStmt) return true; // force a read on first poll
-		const row = this.dataVersionStmt.get() as { data_version?: number } | undefined;
-		const v = row?.data_version ?? 0;
-		if (this.lastDataVersion === null) {
-			this.lastDataVersion = v;
-			return true;
-		}
-		if (v === this.lastDataVersion) return false;
-		this.lastDataVersion = v;
-		return true;
-	}
-
-	/** Read new steps since the last call WITHOUT re-checking data_version.
-	 *  The caller gates this behind hasChanged() so the SELECT only fires when a
-	 *  commit actually landed. Returns [] when the DB isn't open or has no new
-	 *  rows. Advances the cursor past every successfully-read row. */
-	readNewSteps(): Step[] {
-		if (!this.db || !this.selectStmt) return [];
-		const rows = this.selectStmt.all(this._lastIdx) as Array<{
-			idx: number;
-			step_type: number;
-			status: number;
-			step_payload: unknown;
-		}>;
-		const out: Step[] = [];
-		let advanced = this._lastIdx;
-		for (const r of rows) {
-			try {
-				out.push({
-					idx: r.idx,
-					stepType: r.step_type,
-					status: r.status,
-					payload: toUint8(r.step_payload),
-				});
-				advanced = r.idx;
-			} catch {
-				// Torn read: drop this row, do not advance. Retried next poll.
-				break;
-			}
-		}
-		this._lastIdx = Math.max(this._lastIdx, advanced);
-		return out;
-	}
-
-	/** Convenience: hasChanged() + readNewSteps() in one call. Kept for the
-	 *  decode-db diagnostic and any caller that doesn't need the separate
-	 *  in-place re-read. */
-	poll(): Step[] {
-		return this.hasChanged() ? this.readNewSteps() : [];
-	}
-
-	/** Read a single step by idx without advancing the cursor. Used to re-check
-	 *  the last text/thinking step: agy extends the step it is currently writing
-	 *  in place (same idx, growing text), and poll() only returns idx > lastIdx. */
-	readStepAt(idx: number): Step | null {
-		if (!this.db || !this.selectAtStmt) return null;
-		let row;
-		try {
-			row = this.selectAtStmt.get(idx) as
-				| { idx: number; step_type: number; status: number; step_payload: unknown }
-				| undefined;
-		} catch {
-			return null;
-		}
-		if (!row) return null;
-		try {
-			return {
-				idx: row.idx,
-				stepType: row.step_type,
-				status: row.status,
-				payload: toUint8(row.step_payload),
-			};
-		} catch {
-			return null;
-		}
-	}
-
-	/** Release the DB handle. Safe to call multiple times. */
-	close(): void {
-		try {
-			this.db?.close();
-		} catch {
-			// already closed
-		}
-		this.db = null;
-	}
-}