@estebanforge/pi-antigravity-bridge 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.0] - 2026-07-31
+
+### Added
+
+- **Full agy catalog in the picker, grouped like agy's own.** Gemini models
+  collapse to base entries (gemini-3.6-flash, gemini-3.1-pro) with a
+  thinking-effort toggle; Claude (Sonnet/Opus) and GPT-OSS appear as fixed
+  entries with no toggle, since their thinking cannot be changed. The earlier
+  Gemini-only filter is gone. Google's Antigravity subscription bills all of
+  these through agy, so routing Claude here uses the agy quota you already pay
+  for (if you also run pi-claude-bridge you will simply see two Claude
+  entries).
+- **Reasoning-effort bridging (`agy --effort`).** For an effort-driven Gemini
+  base, pi's thinking-effort toggle drives agy's `--effort` (agy 1.1.5+), and
+  the toggle only offers the tiers that base actually accepts (Flash:
+  low/medium/high; Pro: low/high), so it can never request a tier agy rejects.
+  The level is clamped to the base's supported tiers and always passed (a base
+  slug is invalid on its own). Fixed models never receive `--effort` (agy
+  rejects it for them). Behavior verified by local experiments against agy
+  1.1.9.
+
+### Changed
+
+- **Breaking: Gemini model ids changed shape.** Effort is no longer part of the
+  model id (`antigravity/gemini-3-6-flash-medium` →
+  `antigravity/gemini-3-6-flash`); it is now chosen via pi's thinking-effort
+  toggle. A persisted default model, a `--model antigravity/...` flag, or a
+  scoped-model pattern set before upgrading will need re-selection.
+  Claude/GPT-OSS ids keep their qualified shape (e.g.
+  `antigravity/claude-sonnet-4-6`).
+- **Requires agy >= 1.1.5.** Base slugs and the `--effort` flag landed there;
+  older agy rejects every Gemini entry with a flag error.
+
+### Fixed
+
+- **AskAntigravity model resolution** now parses agy's stable-slug catalog
+  (`gemini-3.6-flash-high`, `claude-sonnet-4-6`) instead of the legacy human
+  names. The `sonnet`/`opus`/`gpt-oss` aliases and the `/agy thinking` tier had
+  silently resolved to invalid `--model` values since agy switched to slugs;
+  they now resolve to exact valid slugs.
+
 ## [1.0.0] - 2026-07-29
 
 First release. A streaming Gemini model provider for pi, built on Google's

package/extensions/index.ts

@@ -83,6 +83,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			name: m.name,
 			api: m.api,
 			reasoning: m.reasoning,
+			thinkingLevelMap: m.thinkingLevelMap,
 			input: m.input,
 			cost: m.cost,
 			contextWindow: m.contextWindow,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.0.0",
+  "version": "1.1.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.",
   "keywords": [
     "pi-package",
@@ -28,7 +28,7 @@
   "type": "module",
   "scripts": {
     "build": "tsc --noEmit",
-    "test": "tsx --test tests/*.test.ts",
+    "test": "vitest run",
     "prepublishOnly": "npm run build && npm test",
     "run-agy": "tsx scripts/run-agy.ts",
     "decode-db": "tsx scripts/decode-db.ts",
@@ -61,7 +61,8 @@
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
     "typebox": "^1.1.38",
-    "typescript": "^5.8.0"
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.7"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0"

package/src/ask-tool.ts

@@ -43,16 +43,17 @@ const TIER_RANK: Record<ThinkingTier, number> = { low: 0, medium: 1, high: 2 };
 
 // Static alias overlay for non-Gemini models agy may or may not surface.
 // Live catalog entries win on case-insensitive full-string equality; the
-// overlay resolves the alias when agy doesn't list it.
+// overlay resolves the alias when agy doesn't list it. Names are agy's stable
+// slugs (the same ids `agy models` prints and `--model` accepts).
 const STATIC_ALIAS_OVERLAY: ReadonlyArray<ModelEntry> = [
-	{ full: "Claude Sonnet 4.6 (Thinking)", family: "other", version: null, tier: null },
-	{ full: "Claude Opus 4.6 (Thinking)", family: "other", version: null, tier: null },
-	{ full: "GPT-OSS 120B (Medium)", family: "other", version: null, tier: null },
+	{ full: "claude-sonnet-4-6", family: "other", version: null, tier: null },
+	{ full: "claude-opus-4-6-thinking", family: "other", version: null, tier: null },
+	{ full: "gpt-oss-120b-medium", family: "other", version: null, tier: null },
 ];
 const STATIC_SHORT_ALIAS: ReadonlyMap<string, string> = new Map([
-	["sonnet", "Claude Sonnet 4.6 (Thinking)"],
-	["opus", "Claude Opus 4.6 (Thinking)"],
-	["gpt-oss", "GPT-OSS 120B (Medium)"],
+	["sonnet", "claude-sonnet-4-6"],
+	["opus", "claude-opus-4-6-thinking"],
+	["gpt-oss", "gpt-oss-120b-medium"],
 ]);
 
 // agy conversation ids are UUID DB-stems. First char must be alphanumeric so a
@@ -77,7 +78,7 @@ COMPACT OUTPUT (param: digest): when true, the prompt is prefixed to request com
 type Family = "flash" | "pro" | "other";
 
 interface ModelEntry {
-	full: string; // exact agy string, e.g. "Gemini 3.6 Flash (Medium)"
+	full: string; // exact agy slug, e.g. "gemini-3.6-flash-medium"
 	family: Family;
 	version: string | null; // "3.6"
 	tier: ThinkingTier | null;
@@ -119,7 +120,7 @@ function parseModelLine(line: string): ModelEntry | null {
 			: "other";
 	const versionMatch = lower.match(/(\d+\.\d+)/);
 	const version = versionMatch ? versionMatch[1] : null;
-	const tierMatch = lower.match(/\((low|medium|high)\)/);
+	const tierMatch = lower.match(/-(low|medium|high)$/);
 	const tier = tierMatch ? (tierMatch[1] as ThinkingTier) : null;
 	return { full, family, version, tier };
 }
@@ -248,7 +249,7 @@ export async function registerAskAntigravityTool(
 			model: Type.Optional(
 				Type.String({
 					description:
-						"Model alias or exact id. Friendly: 'flash', 'pro', 'gemini'. Add a tier: 'flash high'. Pin a version: '3.5 flash'. Exact: 'Gemini 3.6 Flash (Medium)'. Omit for the configured default.",
+						"Model alias or exact id. Friendly: 'flash', 'pro', 'gemini'. Add a tier: 'flash high'. Pin a version: '3.5 flash'. Exact: 'gemini-3.6-flash-medium'. Omit for the configured default.",
 				}),
 			),
 			mode: Type.Optional(

package/src/mcp-server.ts

@@ -292,7 +292,7 @@ export async function startMcpServer(
 
 	const makeServer = (signal: AbortSignal) => {
 		const s = new Server(
-			{ name: "pi-antigravity-bridge", version: "1.0.0" },
+			{ name: "pi-antigravity-bridge", version: "1.1.0" },
 			{ capabilities: { tools: {} } },
 		);
 		s.setRequestHandler(ListToolsRequestSchema, listHandler);

package/src/models.ts

@@ -1,29 +1,62 @@
-// Discover Gemini models from `agy models` and project them into pi's Model
-// shape so they appear in the /model picker as antigravity/<slug>.
+// Discover models from `agy models` and project them into pi's Model shape so
+// they appear in the /model picker as antigravity/<slug>.
 //
-// agy prints one model per line, e.g.:
-//   Gemini 3.6 Flash (Medium)
-//   Gemini 3.1 Pro (High)
-//   Claude Sonnet 4.6 (Thinking)
-//   GPT-OSS 120B (Medium)
+// agy lists effort-qualified slugs one per line, e.g.:
+//   gemini-3.6-flash-high / -medium / -low
+//   gemini-3.1-pro-high / -low            (Pro has NO medium variant)
+//   claude-sonnet-4-6                      (fixed thinking, no effort tiers)
+//   gpt-oss-120b-medium                    (fixed, no effort tiers)
 //
-// We keep ONLY Gemini models here  -  Claude and GPT-OSS belong to other
-// providers (pi-claude-bridge, etc.). Driving them through agy would double-
-// bill and conflict with the user's other subscriptions.
+// Gemini models are collapsed to a BASE slug (gemini-3.6-flash) and exposed
+// with a thinking-effort toggle whose levels match exactly the tiers agy
+// offers that base (verified: Pro rejects medium). The picked level is sent as
+// agy --effort; a base slug is INVALID on its own, so effort is always passed.
+// Claude and GPT-OSS keep agy's exact slug with no toggle: their thinking is
+// fixed and agy rejects --effort for them. Google's Antigravity subscription
+// bills all of these through agy.
 
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, Model, ThinkingLevelMap } from "@earendil-works/pi-ai";
 
 const DISCOVERY_TIMEOUT_MS = 8_000;
 
+/** Reasoning-effort tiers agy accepts via --effort. */
+export type AgyEffort = "low" | "medium" | "high";
+
+/** low < medium < high, for sorting/clamping. */
+const EFFORT_RANK: Record<AgyEffort, number> = { low: 0, medium: 1, high: 2 };
+
+/** Split an agy slug into (base, tier). tier is null when the slug has no
+ *  -high/-medium/-low suffix (claude-sonnet-4-6, gpt-oss-120b-medium's "medium"
+ *  IS its suffix here, claude-opus-4-6-thinking is not a tier). */
+const TIER_RE = /^(.+)-(high|medium|low)$/;
+
+/** agy emits clean slug ids (gemini-3.6-flash-high). Reject anything else so a
+ *  banner / auth / "Fetching models…" line can't register as a model, and a
+ *  leading-dash token (e.g. "-high") can't reach agy's flag parser as
+ *  --model. First char must be alphanumeric (no leading dash, no dot). */
+const MODEL_LINE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+/** Model families VERIFIED to accept base-slug + --effort. Only these collapse
+ *  to a base slug with a thinking toggle. Any other family stays as agy's exact
+ *  qualified slug (always valid on its own), so an unknown or fixed-thinking
+ *  family degrades safely instead of forcing an unsupported --effort. Add a
+ *  family here only after confirming base+--effort is accepted for it. */
+const EFFORT_CAPABLE_FAMILIES: readonly RegExp[] = [/^gemini-/];
+
 export interface AgyModelEntry {
-	/** Exact agy string, e.g. "Gemini 3.6 Flash (Medium)". */
+	/** Exact agy --model string to pass: a base slug ("gemini-3.6-flash") when
+	 *  effort-driven, else agy's full qualified slug ("claude-opus-4-6-thinking"). */
 	full: string;
-	/** pi model id, e.g. "gemini-3-6-flash-medium". */
+	/** pi model id, e.g. "gemini-3-6-flash". */
 	id: string;
+	/** Present iff this is an effort-driven base slug. Lists the tiers agy
+	 *  accepts for it; pi's thinking toggle picks among them and we always pass
+	 *  --effort. Absent => fixed model, never pass --effort. */
+	efforts?: AgyEffort[];
 }
 
 /** Spawn `agy models` and return its raw stdout text. Returns "" on any
@@ -169,33 +202,50 @@ export async function loadModelCatalogRaw(
 	return raw;
 }
 
-/** Parse raw `agy models` text into the provider's slugified Gemini entries. */
+/** Parse raw `agy models` text into the provider's model entries.
+ *
+ *  Effort-driven Gemini bases (>= 2 tier variants in the catalog) collapse to
+ *  one BASE-slug entry carrying the tiers they accept. Models with 0 or 1 tier
+ *  variants keep agy's exact qualified slug: a single suffix (gpt-oss-120b-
+ *  medium) or none (claude-sonnet-4-6) means fixed thinking, where --effort is
+ *  unsupported. Insertion order of first-seen bases is preserved. */
 export function entriesFromRaw(raw: string): AgyModelEntry[] {
-	return raw
+	const lines = raw
 		.split("\n")
 		.map((line) => line.trim())
 		.filter((line) => line.length > 0)
-		.filter(isGeminiModel)
-		.map((full) => ({ full, id: slugify(full) }))
-		.filter((e): e is AgyModelEntry => e.id.length > 0);
+		.filter((line) => MODEL_LINE_RE.test(line));
+	const groups = new Map<string, { lines: string[]; tiers: Set<AgyEffort> }>();
+	for (const line of lines) {
+		const m = TIER_RE.exec(line);
+		const base = m ? (m[1] as string) : line;
+		const tier = m ? (m[2] as AgyEffort) : null;
+		let g = groups.get(base);
+		if (!g) {
+			g = { lines: [], tiers: new Set<AgyEffort>() };
+			groups.set(base, g);
+		}
+		g.lines.push(line);
+		if (tier) g.tiers.add(tier);
+	}
+	const entries: AgyModelEntry[] = [];
+	for (const [base, g] of groups) {
+		const efforts = [...g.tiers].sort((a, b) => EFFORT_RANK[a] - EFFORT_RANK[b]);
+		if (efforts.length >= 2 && EFFORT_CAPABLE_FAMILIES.some((re) => re.test(base))) {
+			entries.push({ full: base, id: slugify(base), efforts });
+		} else {
+			for (const line of g.lines) entries.push({ full: line, id: slugify(line) });
+		}
+	}
+	return entries.filter((e) => e.id.length > 0);
 }
 
-/** Run `agy models`, return parsed Gemini entries. Returns [] on any failure
+/** Run `agy models`, return parsed model entries. Returns [] on any failure
  *  (non-fatal  -  the provider falls back to a hardcoded set). */
 export async function discoverAgyModels(binary: string): Promise<AgyModelEntry[]> {
 	return entriesFromRaw(await spawnAgyModelsRaw(binary));
 }
 
-/** Gemini models only. Case-insensitive: the name must contain "gemini" and
- *  NOT be a Claude/GPT-OSS entry (defensive  -  agy could rename lines). */
-function isGeminiModel(line: string): boolean {
-	const l = line.toLowerCase();
-	if (!l.includes("gemini")) return false;
-	if (l.includes("claude")) return false;
-	if (l.includes("gpt")) return false;
-	return true;
-}
-
 /** "Gemini 3.6 Flash (Medium)" -> "gemini-3-6-flash-medium".
  *  Lowercase, non-alphanumerics -> "-", collapsed, trimmed. */
 export function slugify(full: string): string {
@@ -205,17 +255,22 @@ export function slugify(full: string): string {
 		.replace(/^-+|-+$/g, "");
 }
 
+/** Build the thinkingLevelMap for an effort-driven base: hide "off" and
+ *  "minimal" always (agy has no no-thinking mode; a base REQUIRES an effort),
+ *  and hide any of low/medium/high the base doesn't offer (e.g. Pro has no
+ *  medium). pi's getSupportedThinkingLevels treats a null value as hidden, so
+ *  the toggle then shows exactly agy's slider stops. */
+function thinkingLevelMapFor(efforts: readonly AgyEffort[]): ThinkingLevelMap {
+	const map: Record<string, string | null> = { off: null, minimal: null };
+	for (const level of ["low", "medium", "high"] as const) {
+		if (!efforts.includes(level)) map[level] = null;
+	}
+	return map as ThinkingLevelMap;
+}
+
 /** Project an agy entry to pi's Model shape. */
 export function toPiModel(entry: AgyModelEntry): Model<Api> {
-	const tier = /\(high\)/i.test(entry.full)
-		? "high"
-		: /\(low\)/i.test(entry.full)
-			? "low"
-			: "medium";
-	// "reasoning" gates pi's thinking-effort UI. Gemini reasons at every tier,
-	// but we only expose the toggle for High to avoid implying control we
-	// don't actually bridge to agy.
-	const reasoning = tier === "high";
+	const effortDriven = !!entry.efforts && entry.efforts.length > 0;
 	return {
 		id: entry.id,
 		name: entry.full,
@@ -225,7 +280,11 @@ export function toPiModel(entry: AgyModelEntry): Model<Api> {
 		// pi requires non-empty values. The "agy-bridge" api string is a custom
 		// sentinel that no built-in provider claims, so it can never collide.
 		baseUrl: "agy-bridge://antigravity",
-		reasoning,
+		// reasoning=true only for effort-driven bases => pi shows the toggle.
+		// Fixed models (Claude/GPT-OSS) get no toggle: their thinking can't be
+		// changed and agy rejects --effort for them.
+		reasoning: effortDriven,
+		...(effortDriven ? { thinkingLevelMap: thinkingLevelMapFor(entry.efforts!) } : {}),
 		// agy's -p prompt is text-only. Advertising image input would let pi
 		// offer image attach, but extractUserPrompt silently drops image blocks,
 		// so the user would be misled. Keep input text-only until agy supports
@@ -244,18 +303,9 @@ export function toPiModel(entry: AgyModelEntry): Model<Api> {
  *  can still select a model and get a clear runtime error instead of an empty
  *  list. Update these when agy ships new Gemini versions. */
 export const FALLBACK_MODELS: AgyModelEntry[] = [
-	{ full: "Gemini 3.6 Flash (Medium)", id: "gemini-3-6-flash-medium" },
-	{ full: "Gemini 3.6 Flash (High)", id: "gemini-3-6-flash-high" },
-	{ full: "Gemini 3.1 Pro (High)", id: "gemini-3-1-pro-high" },
+	{ full: "gemini-3.6-flash", id: "gemini-3-6-flash", efforts: ["low", "medium", "high"] },
+	{ full: "gemini-3.1-pro", id: "gemini-3-1-pro", efforts: ["low", "high"] },
+	{ full: "claude-sonnet-4-6", id: "claude-sonnet-4-6" },
 ];
 
-/** Resolve a pi model id back to the exact agy string. O(n) over a small list
- *   -  the provider calls this once per turn. Returns null on miss (caller
- *  falls back to passthrough, agy will likely reject). */
-export function resolveAgyString(
-	piModelId: string,
-	entries: AgyModelEntry[],
-): string | null {
-	const found = entries.find((e) => e.id === piModelId);
-	return found ? found.full : null;
-}
+

package/src/provider.ts

@@ -25,11 +25,12 @@ import {
 	type Message,
 	type Model,
 	type SimpleStreamOptions,
+	type ThinkingLevel,
 	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 { resolveAgyString, type AgyModelEntry } from "./models.js";
+import { type AgyEffort, type AgyModelEntry } from "./models.js";
 import { SessionStore } from "./sessions.js";
 import { loadConfig } from "./config.js";
 import path from "node:path";
@@ -246,6 +247,46 @@ export interface StreamSimpleDeps {
 	runAgyTurn?: typeof runAgyTurn;
 }
 
+/** pi thinking-effort order mirrors agy's, for clamping. */
+const AGY_EFFORT_ORDER: readonly AgyEffort[] = ["low", "medium", "high"];
+
+/** Map pi's thinking level onto one of the tiers `efforts` the base actually
+ *  supports, clamping to the nearest available. agy rejects an effort tier a
+ *  base doesn't list (e.g. medium on Pro), so we never emit one. A base slug is
+ *  invalid without --effort, so when pi sends no level we default to the
+ *  middle tier (or the highest available). */
+export function toAgyEffort(
+	reasoning: ThinkingLevel | undefined,
+	efforts: readonly AgyEffort[],
+): AgyEffort {
+	let candidate: AgyEffort;
+	switch (reasoning) {
+		case "minimal":
+		case "low":
+			candidate = "low";
+			break;
+		case "medium":
+			candidate = "medium";
+			break;
+		case "high":
+		case "xhigh":
+		case "max":
+			candidate = "high";
+			break;
+		default:
+			candidate = efforts[0] ?? "low";
+	}
+	if (efforts.includes(candidate)) return candidate;
+	const i = AGY_EFFORT_ORDER.indexOf(candidate);
+	for (let j = i; j < AGY_EFFORT_ORDER.length; j++) {
+		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
+	}
+	for (let j = i - 1; j >= 0; j--) {
+		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
+	}
+	return efforts[0] ?? "low";
+}
+
 /** Build the streamSimple closure. Captures the model catalog + session store
  *  resolved at extension load. */
 export function createStreamSimple(
@@ -311,20 +352,27 @@ async function runTurn(
 	const 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 the exact agy string. Fall through to the id
-	// itself on miss  -  agy will likely reject, but the error reaches the user
+	// 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 agyModel = resolveAgyString(model.id, entries) ?? model.id;
+	const entry = entries.find((e) => e.id === model.id) ?? null;
+	const agyModel = entry?.full ?? model.id;
 
 	// Runtime config (mode, permissions). Loaded fresh each turn so /agy
 	// toggles take effect immediately without a reload.
 	const config = loadConfig();
 
+	// 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,

package/src/runner.ts

@@ -88,6 +88,9 @@ export interface AgyRunOptions {
 	/** Exact agy model string, e.g. "Gemini 3.6 Flash (Medium)". Caller
 	 *  resolves aliases; the runner passes this through verbatim. */
 	model?: string;
+	/** Reasoning effort passed to agy --effort (low|medium|high). Omit to let
+	 *  the model slug's own effort stand (requires agy >= 1.1.5). */
+	effort?: "low" | "medium" | "high";
 	/** agy execution mode. accept-edits = agy applies edits; plan = review-only. */
 	mode?: "accept-edits" | "plan";
 	/** Pass --dangerously-skip-permissions so commands don't hang on an
@@ -168,6 +171,7 @@ export async function runAgyTurn(
 	// this dir, so its agy stays plain (no recursion).
 	if (bridgeMcpConfigExists()) args.push("--add-dir", bridgeMcpConfigDir());
 	if (opts.model) args.push("--model", opts.model);
+	if (opts.effort) args.push("--effort", opts.effort);
 	args.push("--mode", mode);
 	// Without this, any run_command triggers an interactive permission prompt
 	// that hangs forever in non-interactive print mode (no TTY to answer y/n).