@benjamolina/pi-antigravity-guard 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Pi Antigravity Guard
 
-`@benjamolina/pi-antigravity-guard` is a Pi extension that registers the text-only `antigravity-guard` provider. It exposes exactly one selectable model, `antigravity-gemini-3.8-flash`, which is sent to Antigravity as `gemini-3.8-flash`.
+`@benjamolina/pi-antigravity-guard` is a static Pi extension that registers the text-only `antigravity-guard` provider. It uses Pi-managed OAuth credentials and the existing Antigravity OAuth endpoint and quota path; it does not provide alternate credential routes, quota pools, fallback, or model substitution.
 
 ## Use
 
@@ -12,13 +12,32 @@ Install the package in Pi, then run:
 
 Choose browser login, or choose manual login and paste the complete callback URL. The loopback callback uses fixed port `51121`; browser callback failures, remote shells, and port conflicts can use the manual callback-URL flow.
 
-Start a fresh text-only session with `--no-builtin-tools` and disable any active extension-provided tools. That flag does not disable extension tools by itself. Tools, tool history, images, and thinking content are unsupported and rejected rather than silently changed.
+Start a fresh text-only session with `--no-builtin-tools` and disable any active extension-provided tools. That flag does not disable extension tools by itself. Tools, tool history, and images are unsupported and rejected rather than silently changed.
+
+## Supported static catalog
+
+The provider registers only these evidence-admitted public IDs, in this order. `off` is available for every row even though it is omitted from Pi's level map; omitted reasoning also selects that row's `off` route. Unsupported levels are not advertised and are rejected before transport.
+
+| Public ID | Exposed Pi levels | Context / output |
+|---|---|---:|
+| `antigravity-gemini-3.8-flash` | off, low, medium, high | 1,048,576 / 65,536 |
+| `antigravity-gemini-3.7-flash` | off, low, medium, high | 1,048,576 / 65,536 |
+| `antigravity-gemini-3.6-flash` | off, low, medium, high | 1,048,576 / 65,536 |
+| `antigravity-gemini-3.1-pro` | off, low, high | 1,048,576 / 65,535 |
+| `antigravity-claude-sonnet-4.6` | off, high | 250,000 / 64,000 |
+| `antigravity-claude-opus-4.6-thinking` | off, high | 250,000 / 64,000 |
+| `antigravity-gpt-oss-120b` | off, medium | 131,072 / 32,768 |
+
+Gemini 3.8 remains compatible with the released mapping: `antigravity-gemini-3.8-flash` sends `gemini-3.8-flash-tiered`; `off` sends native `thinkingLevel: "low"` with hidden thoughts, and `low`, `medium`, and `high` send their matching native level with visible thoughts.
+
+`antigravity-gemini-3.5-flash` is not registered or advertised as supported because its recorded HTTP-200 response lacks the strict terminal metadata required for admission.
 
 ## Limits and safety
 
-- This provider stores credentials through Pi's OAuth lifecycle and never reads or changes OpenCode account files; each is independent.
+An explicit `maxTokens` must be a positive integer no greater than the row's output limit. For a route with a positive finite thinking budget, it must also be greater than that budget. When `maxTokens` is omitted, the provider uses 4,096 unless a larger finite thinking budget needs a 1,024-token answer reserve, always bounded by the row's output limit. Custom `thinkingBudgets` are unsupported and rejected.
+
 - Costs are reported as zero because subscription usage is unpriced, not because access is free.
-- The documented public-to-wire model mapping is not proof that the model is live, available, or entitled. No authorized live OAuth or generation check has been run.
-- It has no account rotation, quota fallback, model substitution, or tool support.
+- The catalog is static: it performs no startup or runtime model discovery, catalog synchronization, or dynamic registration.
+- It has no account rotation, quota fallback, model substitution, tool support, or image support.
 
 To remove it, disable or uninstall `@benjamolina/pi-antigravity-guard` and reload Pi. Removal does not delete Pi-managed credentials or revoke tokens.

package/dist/catalog.d.ts

@@ -0,0 +1,390 @@
+export type StandardReasoningLevel = "off" | "minimal" | "low" | "medium" | "high";
+type NativeThinkingLevel = "low" | "medium" | "high";
+type NativeRoute = {
+    readonly wireModel: string;
+    readonly thinking: {
+        readonly kind: "native-level";
+        readonly thinkingLevel: NativeThinkingLevel;
+        readonly includeThoughts: boolean;
+    };
+};
+type IntegerBudgetRoute = {
+    readonly wireModel: string;
+    readonly thinking: {
+        readonly kind: "budget";
+        readonly budget: number;
+        readonly includeThoughts: boolean;
+    } | {
+        readonly kind: "omit";
+    };
+};
+export type GenerationRoute = NativeRoute | IntegerBudgetRoute;
+export interface CatalogEntry {
+    readonly publicId: string;
+    readonly descriptor: {
+        readonly name: string;
+        readonly thinkingLevelMap: Readonly<Record<"minimal" | "low" | "medium" | "high", string | null>>;
+        readonly contextWindow: number;
+        readonly maxTokens: number;
+    };
+    readonly routes: Readonly<Partial<Record<StandardReasoningLevel, GenerationRoute>>>;
+    readonly replay: {
+        readonly kind: "same-public-model" | "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gemini" | "claude" | "gpt-oss";
+    };
+}
+declare const CATALOG: readonly [{
+    readonly publicId: "antigravity-gemini-3.8-flash";
+    readonly descriptor: {
+        readonly name: "Gemini 3.8 Flash (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: "low";
+            readonly medium: "medium";
+            readonly high: "high";
+        };
+        readonly contextWindow: 1048576;
+        readonly maxTokens: 65536;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly thinking: {
+                readonly kind: "native-level";
+                readonly thinkingLevel: "low";
+                readonly includeThoughts: false;
+            };
+        };
+        readonly low: {
+            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly thinking: {
+                readonly kind: "native-level";
+                readonly thinkingLevel: "low";
+                readonly includeThoughts: true;
+            };
+        };
+        readonly medium: {
+            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly thinking: {
+                readonly kind: "native-level";
+                readonly thinkingLevel: "medium";
+                readonly includeThoughts: true;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly thinking: {
+                readonly kind: "native-level";
+                readonly thinkingLevel: "high";
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "same-public-model";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gemini";
+    };
+}, {
+    readonly publicId: "antigravity-gemini-3.7-flash";
+    readonly descriptor: {
+        readonly name: "Gemini 3.7 Flash (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: "low";
+            readonly medium: "medium";
+            readonly high: "high";
+        };
+        readonly contextWindow: 1048576;
+        readonly maxTokens: 65536;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "gemini-3.7-flash-low";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 0;
+                readonly includeThoughts: false;
+            };
+        };
+        readonly low: {
+            readonly wireModel: "gemini-3.7-flash-low";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 1000;
+                readonly includeThoughts: true;
+            };
+        };
+        readonly medium: {
+            readonly wireModel: "gemini-3.7-flash-medium";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 4000;
+                readonly includeThoughts: true;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "gemini-3.7-flash-high";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: -1;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gemini";
+    };
+}, {
+    readonly publicId: "antigravity-gemini-3.6-flash";
+    readonly descriptor: {
+        readonly name: "Gemini 3.6 Flash (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: "low";
+            readonly medium: "medium";
+            readonly high: "high";
+        };
+        readonly contextWindow: 1048576;
+        readonly maxTokens: 65536;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "gemini-3.6-flash-low";
+            readonly thinking: {
+                readonly kind: "omit";
+            };
+        };
+        readonly low: {
+            readonly wireModel: "gemini-3.6-flash-low";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 1000;
+                readonly includeThoughts: true;
+            };
+        };
+        readonly medium: {
+            readonly wireModel: "gemini-3.6-flash-medium";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 4000;
+                readonly includeThoughts: true;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "gemini-3.6-flash-high";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: -1;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gemini";
+    };
+}, {
+    readonly publicId: "antigravity-gemini-3.1-pro";
+    readonly descriptor: {
+        readonly name: "Gemini 3.1 Pro (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: "low";
+            readonly medium: null;
+            readonly high: "high";
+        };
+        readonly contextWindow: 1048576;
+        readonly maxTokens: 65535;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "gemini-3.1-pro-low";
+            readonly thinking: {
+                readonly kind: "omit";
+            };
+        };
+        readonly low: {
+            readonly wireModel: "gemini-3.1-pro-low";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 1001;
+                readonly includeThoughts: true;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "gemini-pro-agent";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 10001;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gemini";
+    };
+}, {
+    readonly publicId: "antigravity-claude-sonnet-4.6";
+    readonly descriptor: {
+        readonly name: "Claude Sonnet 4.6 (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: null;
+            readonly medium: null;
+            readonly high: "high";
+        };
+        readonly contextWindow: 250000;
+        readonly maxTokens: 64000;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "claude-sonnet-4-6";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 0;
+                readonly includeThoughts: false;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "claude-sonnet-4-6";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 1024;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "claude";
+    };
+}, {
+    readonly publicId: "antigravity-claude-opus-4.6-thinking";
+    readonly descriptor: {
+        readonly name: "Claude Opus 4.6 Thinking (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: null;
+            readonly medium: null;
+            readonly high: "high";
+        };
+        readonly contextWindow: 250000;
+        readonly maxTokens: 64000;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "claude-opus-4-6-thinking";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 0;
+                readonly includeThoughts: false;
+            };
+        };
+        readonly high: {
+            readonly wireModel: "claude-opus-4-6-thinking";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 1024;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "claude";
+    };
+}, {
+    readonly publicId: "antigravity-gpt-oss-120b";
+    readonly descriptor: {
+        readonly name: "GPT-OSS 120B (Antigravity, text only)";
+        readonly thinkingLevelMap: {
+            readonly minimal: null;
+            readonly low: null;
+            readonly medium: "medium";
+            readonly high: null;
+        };
+        readonly contextWindow: 131072;
+        readonly maxTokens: 32768;
+    };
+    readonly routes: {
+        readonly off: {
+            readonly wireModel: "gpt-oss-120b-medium";
+            readonly thinking: {
+                readonly kind: "omit";
+            };
+        };
+        readonly medium: {
+            readonly wireModel: "gpt-oss-120b-medium";
+            readonly thinking: {
+                readonly kind: "budget";
+                readonly budget: 8192;
+                readonly includeThoughts: true;
+            };
+        };
+    };
+    readonly replay: {
+        readonly kind: "strip";
+    };
+    readonly response: {
+        readonly kind: "gemini-envelope";
+        readonly family: "gpt-oss";
+    };
+}];
+type Catalog = typeof CATALOG;
+export type AntigravityPublicModelId = Catalog[number]["publicId"];
+export type AntigravityWireModelId = Catalog[number]["routes"][keyof Catalog[number]["routes"]]["wireModel"];
+export declare function defineCatalog<T extends readonly {
+    readonly publicId: string;
+    readonly descriptor?: CatalogEntry["descriptor"];
+    readonly routes: Readonly<Record<string, {
+        readonly wireModel: string;
+        readonly thinking?: GenerationRoute["thinking"];
+    }>>;
+}[]>(entries: T): T;
+export declare function listCatalogEntries(): readonly CatalogEntry[];
+export declare function getCatalogEntry(publicId: unknown): CatalogEntry | undefined;
+export declare function resolveGenerationRoute(entry: CatalogEntry, reasoning: unknown): GenerationRoute;
+export declare function toPiModelDescriptor(entry: CatalogEntry): {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    thinkingLevelMap: {
+        high: string | null;
+        low: string | null;
+        medium: string | null;
+        minimal: string | null;
+    };
+    input: "text"[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+};
+export {};

package/dist/catalog.js

@@ -0,0 +1,166 @@
+const ANSWER_RESERVE = 1024;
+const CATALOG = freeze(defineCatalog([{
+        publicId: "antigravity-gemini-3.8-flash",
+        descriptor: {
+            name: "Gemini 3.8 Flash (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high" },
+            contextWindow: 1_048_576,
+            maxTokens: 65_536,
+        },
+        routes: {
+            off: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: false } },
+            low: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: true } },
+            medium: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "medium", includeThoughts: true } },
+            high: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "high", includeThoughts: true } },
+        },
+        replay: { kind: "same-public-model" },
+        response: { kind: "gemini-envelope", family: "gemini" },
+    }, {
+        publicId: "antigravity-gemini-3.7-flash",
+        descriptor: {
+            name: "Gemini 3.7 Flash (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high" },
+            contextWindow: 1_048_576,
+            maxTokens: 65_536,
+        },
+        routes: {
+            off: { wireModel: "gemini-3.7-flash-low", thinking: { kind: "budget", budget: 0, includeThoughts: false } },
+            low: { wireModel: "gemini-3.7-flash-low", thinking: { kind: "budget", budget: 1000, includeThoughts: true } },
+            medium: { wireModel: "gemini-3.7-flash-medium", thinking: { kind: "budget", budget: 4000, includeThoughts: true } },
+            high: { wireModel: "gemini-3.7-flash-high", thinking: { kind: "budget", budget: -1, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "gemini" },
+    }, {
+        publicId: "antigravity-gemini-3.6-flash",
+        descriptor: {
+            name: "Gemini 3.6 Flash (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high" },
+            contextWindow: 1_048_576,
+            maxTokens: 65_536,
+        },
+        routes: {
+            off: { wireModel: "gemini-3.6-flash-low", thinking: { kind: "omit" } },
+            low: { wireModel: "gemini-3.6-flash-low", thinking: { kind: "budget", budget: 1000, includeThoughts: true } },
+            medium: { wireModel: "gemini-3.6-flash-medium", thinking: { kind: "budget", budget: 4000, includeThoughts: true } },
+            high: { wireModel: "gemini-3.6-flash-high", thinking: { kind: "budget", budget: -1, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "gemini" },
+    }, {
+        publicId: "antigravity-gemini-3.1-pro",
+        descriptor: {
+            name: "Gemini 3.1 Pro (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: "low", medium: null, high: "high" },
+            contextWindow: 1_048_576,
+            maxTokens: 65_535,
+        },
+        routes: {
+            off: { wireModel: "gemini-3.1-pro-low", thinking: { kind: "omit" } },
+            low: { wireModel: "gemini-3.1-pro-low", thinking: { kind: "budget", budget: 1001, includeThoughts: true } },
+            high: { wireModel: "gemini-pro-agent", thinking: { kind: "budget", budget: 10001, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "gemini" },
+    }, {
+        publicId: "antigravity-claude-sonnet-4.6",
+        descriptor: {
+            name: "Claude Sonnet 4.6 (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: null, medium: null, high: "high" },
+            contextWindow: 250_000,
+            maxTokens: 64_000,
+        },
+        routes: {
+            off: { wireModel: "claude-sonnet-4-6", thinking: { kind: "budget", budget: 0, includeThoughts: false } },
+            high: { wireModel: "claude-sonnet-4-6", thinking: { kind: "budget", budget: 1024, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "claude" },
+    }, {
+        publicId: "antigravity-claude-opus-4.6-thinking",
+        descriptor: {
+            name: "Claude Opus 4.6 Thinking (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: null, medium: null, high: "high" },
+            contextWindow: 250_000,
+            maxTokens: 64_000,
+        },
+        routes: {
+            off: { wireModel: "claude-opus-4-6-thinking", thinking: { kind: "budget", budget: 0, includeThoughts: false } },
+            high: { wireModel: "claude-opus-4-6-thinking", thinking: { kind: "budget", budget: 1024, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "claude" },
+    }, {
+        publicId: "antigravity-gpt-oss-120b",
+        descriptor: {
+            name: "GPT-OSS 120B (Antigravity, text only)",
+            thinkingLevelMap: { minimal: null, low: null, medium: "medium", high: null },
+            contextWindow: 131_072,
+            maxTokens: 32_768,
+        },
+        routes: {
+            off: { wireModel: "gpt-oss-120b-medium", thinking: { kind: "omit" } },
+            medium: { wireModel: "gpt-oss-120b-medium", thinking: { kind: "budget", budget: 8192, includeThoughts: true } },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "gpt-oss" },
+    }]));
+const lookup = new Map(CATALOG.map((entry) => [entry.publicId, entry]));
+function freeze(value) {
+    if (typeof value === "object" && value !== null) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            freeze(child);
+    }
+    return value;
+}
+export function defineCatalog(entries) {
+    const identities = new Set();
+    for (const entry of entries) {
+        if (identities.has(entry.publicId))
+            throw new Error(`Duplicate public model ID: ${entry.publicId}`);
+        identities.add(entry.publicId);
+        if (!Object.keys(entry.routes).length)
+            throw new Error(`Model has no routes: ${entry.publicId}`);
+        if (!entry.descriptor)
+            continue;
+        for (const [level, route] of Object.entries(entry.routes)) {
+            if (!route.thinking)
+                throw new Error(`Route has no thinking policy: ${entry.publicId}/${level}`);
+            if (level !== "off" && !Object.hasOwn(entry.descriptor.thinkingLevelMap, level)) {
+                throw new Error(`Route is outside descriptor map: ${entry.publicId}/${level}`);
+            }
+            if (level !== "off" && entry.descriptor.thinkingLevelMap[level] === null) {
+                throw new Error(`Route is hidden by descriptor: ${entry.publicId}/${level}`);
+            }
+            if (route.thinking.kind === "budget" && route.thinking.budget > 0 && Number.isFinite(route.thinking.budget) && route.thinking.budget + ANSWER_RESERVE > entry.descriptor.maxTokens) {
+                throw new Error(`Finite thinking budget does not leave answer reserve: ${entry.publicId}/${level}`);
+            }
+        }
+    }
+    return entries;
+}
+export function listCatalogEntries() {
+    return CATALOG;
+}
+export function getCatalogEntry(publicId) {
+    return typeof publicId === "string" ? lookup.get(publicId) : undefined;
+}
+export function resolveGenerationRoute(entry, reasoning) {
+    const level = reasoning === undefined || reasoning === "off" ? "off" : reasoning;
+    if (typeof level !== "string" || !entry.routes[level])
+        throw new Error("Unsupported reasoning level");
+    return entry.routes[level];
+}
+export function toPiModelDescriptor(entry) {
+    return {
+        id: entry.publicId,
+        name: entry.descriptor.name,
+        reasoning: true,
+        thinkingLevelMap: { ...entry.descriptor.thinkingLevelMap },
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: entry.descriptor.contextWindow,
+        maxTokens: entry.descriptor.maxTokens,
+    };
+}

package/dist/context.d.ts

@@ -1,7 +1,8 @@
 import type { Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
-declare const WIRE_MODEL = "gemini-3.8-flash-tiered";
 interface Part {
     text: string;
+    thought?: true;
+    thoughtSignature?: string;
 }
 interface Content {
     role: "user" | "model";
@@ -9,7 +10,7 @@ interface Content {
 }
 export interface GenerationRequest {
     project: string;
-    model: typeof WIRE_MODEL;
+    model: string;
     request: {
         contents: Content[];
         systemInstruction?: {
@@ -18,9 +19,12 @@ export interface GenerationRequest {
         generationConfig: {
             temperature: number;
             maxOutputTokens: number;
-            thinkingConfig: {
-                thinkingLevel: "low";
-                includeThoughts: false;
+            thinkingConfig?: {
+                thinkingLevel: "low" | "medium" | "high";
+                includeThoughts: boolean;
+            } | {
+                thinkingBudget: number;
+                includeThoughts: boolean;
             };
         };
     };

package/dist/context.js

@@ -1,8 +1,8 @@
+import { getCatalogEntry, resolveGenerationRoute } from "./catalog.js";
 const MAX_TEXT_BYTES = 8 * 1024 * 1024;
-const MAX_OUTPUT_TOKENS = 65_536;
-const PUBLIC_MODEL = "antigravity-gemini-3.8-flash";
-const WIRE_MODEL = "gemini-3.8-flash-tiered";
+const PROVIDER = "antigravity-guard";
 const RESERVED_HEADERS = new Set(["authorization", "host", "content-type", "content-length"]);
+const THINKING_LEVELS = ["low", "medium", "high"];
 export class ContextSerializationError extends Error {
 }
 export function serializeTextContext(input) {
@@ -14,16 +14,16 @@ export function serializeTextContext(input) {
         const options = field(input, "options");
         const project = field(input, "project", true);
         const requestId = field(input, "requestId", true);
-        if (!isRecord(context) || !isRecord(model) || field(model, "id", true) !== PUBLIC_MODEL || typeof project !== "string" || typeof requestId !== "string")
+        const entry = isRecord(model) ? getCatalogEntry(field(model, "id", true)) : undefined;
+        if (!isRecord(context) || !entry || typeof project !== "string" || typeof requestId !== "string")
             fail("Invalid text context.");
+        const route = resolveGenerationRoute(entry, option(options, "reasoning"));
         const systemPrompt = field(context, "systemPrompt");
         const tools = field(context, "tools");
         if (systemPrompt !== undefined && typeof systemPrompt !== "string")
             fail("Text-only context is required.");
-        if (tools !== undefined) {
-            if (isDenseArray(tools).length)
-                fail("Tools are not supported by this text-only provider.");
-        }
+        if (tools !== undefined && isDenseArray(tools).length)
+            fail("Tools are not supported by this text-only provider.");
         validateOptions(options);
         let textBytes = byteLength(systemPrompt ?? "");
         const contents = [];
@@ -35,21 +35,25 @@ export function serializeTextContext(input) {
                 fail("Tool history is not supported by this text-only provider.");
             if (role !== "user" && role !== "assistant")
                 fail("Unsupported context role for this text-only provider.");
-            const text = textParts(field(message, "content", true));
-            textBytes += text.reduce((total, part) => total + byteLength(part.text), 0);
+            const assistant = role === "assistant";
+            const parts = messageParts(field(message, "content", true), assistant, assistant && entry.replay.kind === "same-public-model" && isSameProviderAndModel(message, entry.publicId));
+            textBytes += parts.reduce((total, part) => total + byteLength(part.text), 0);
             if (textBytes > MAX_TEXT_BYTES)
                 fail("Text context is too large.");
-            contents.push({ role: role === "assistant" ? "model" : "user", parts: text });
+            contents.push({ role: role === "assistant" ? "model" : "user", parts });
         }
         if (!contents.length)
             fail("A text conversation is required.");
         const systemInstruction = systemPrompt === undefined ? undefined : { parts: [{ text: systemPrompt }] };
         const temperature = option(options, "temperature");
         const maxTokens = option(options, "maxTokens");
-        return { project, model: WIRE_MODEL, request: { contents, ...(systemInstruction ? { systemInstruction } : {}), generationConfig: {
+        return { project, model: route.wireModel, request: { contents, ...(systemInstruction ? { systemInstruction } : {}), generationConfig: {
                     temperature: typeof temperature === "number" ? temperature : 1,
-                    maxOutputTokens: typeof maxTokens === "number" ? maxTokens : 4096,
-                    thinkingConfig: { thinkingLevel: "low", includeThoughts: false },
+                    maxOutputTokens: resolveOutputTokens(maxTokens, entry.descriptor.maxTokens, route.thinking),
+                    ...(() => {
+                        const thinkingConfig = serializeThinkingConfig(route.thinking);
+                        return thinkingConfig ? { thinkingConfig } : {};
+                    })(),
                 } }, requestType: "agent", userAgent: "antigravity", requestId };
     }
     catch (error) {
@@ -58,36 +62,87 @@ export function serializeTextContext(input) {
         fail("Invalid text context.");
     }
 }
-function textParts(content) {
+function messageParts(content, assistant, sameProviderAndModel) {
     if (typeof content === "string")
         return content ? [{ text: content }] : fail("A text conversation is required.");
     const parts = isDenseArray(content);
     if (!parts.length)
         fail("A text conversation is required.");
     return parts.map((part) => {
-        if (!isRecord(part) || field(part, "type", true) !== "text")
-            fail("Only text context is supported by this provider.");
-        const text = field(part, "text", true);
-        if (typeof text !== "string" || !text)
+        if (!isRecord(part))
             fail("Only text context is supported by this provider.");
-        return { text };
+        const type = field(part, "type", true);
+        if (type === "text") {
+            const text = field(part, "text", true);
+            if (typeof text !== "string")
+                fail("Only text context is supported by this provider.");
+            const thoughtSignature = sameProviderAndModel ? validThoughtSignature(field(part, "textSignature")) : undefined;
+            if (!text && !thoughtSignature)
+                fail("Only text context is supported by this provider.");
+            return { text, ...(thoughtSignature ? { thoughtSignature } : {}) };
+        }
+        if (type === "thinking" && assistant && sameProviderAndModel) {
+            const text = field(part, "thinking", true);
+            if (typeof text !== "string")
+                fail("Only text context is supported by this provider.");
+            const thoughtSignature = validThoughtSignature(field(part, "thinkingSignature"));
+            if (!text && !thoughtSignature)
+                fail("Only text context is supported by this provider.");
+            return { thought: true, text, ...(thoughtSignature ? { thoughtSignature } : {}) };
+        }
+        if (type === "thinking" && assistant) {
+            const text = field(part, "thinking", true);
+            if (typeof text !== "string" || !text)
+                fail("Only text context is supported by this provider.");
+            return { text };
+        }
+        fail("Only text context is supported by this provider.");
     });
 }
+function isSameProviderAndModel(message, publicId) {
+    return field(message, "provider") === PROVIDER && field(message, "model") === publicId;
+}
+function serializeThinkingConfig(thinking) {
+    if (thinking.kind === "native-level")
+        return { thinkingLevel: thinking.thinkingLevel, includeThoughts: thinking.includeThoughts };
+    if (thinking.kind === "budget")
+        return { thinkingBudget: thinking.budget, includeThoughts: thinking.includeThoughts };
+    return undefined;
+}
+function resolveOutputTokens(maxTokens, maxAllowed, thinking) {
+    if (typeof maxTokens === "number") {
+        if (maxTokens > maxAllowed)
+            fail(`maxTokens must be a positive integer no greater than ${maxAllowed}.`);
+        if (thinking.kind === "budget" && thinking.budget > 0 && maxTokens <= thinking.budget)
+            fail("maxTokens must exceed the selected thinking budget.");
+        return maxTokens;
+    }
+    return thinking.kind === "budget" && thinking.budget > 0 ? Math.max(4096, thinking.budget + 1024) : 4096;
+}
+function validThoughtSignature(value) {
+    if (typeof value !== "string" || !value || value.length % 4 !== 0)
+        return undefined;
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? value : undefined;
+}
 function validateOptions(options) {
     if (options === undefined)
         return;
     if (!isRecord(options))
         fail("Invalid generation options.");
     const reasoning = option(options, "reasoning"), budgets = option(options, "thinkingBudgets"), deferred = option(options, "deferred"), toolChoice = option(options, "toolChoice"), sampling = option(options, "samplingParams"), temperature = option(options, "temperature"), maxTokens = option(options, "maxTokens"), headers = option(options, "headers");
-    if (reasoning !== undefined || budgets !== undefined || deferred)
-        fail("Reasoning and deferred requests are not supported.");
+    if (reasoning !== undefined && reasoning !== "off" && !isThinkingLevel(reasoning) && reasoning !== "minimal")
+        fail("Unsupported reasoning level.");
+    if (budgets !== undefined)
+        fail("Thinking budgets are not supported.");
+    if (deferred)
+        fail("Deferred requests are not supported.");
     if (toolChoice !== undefined && toolChoice !== "none")
         fail("Tools are not supported by this text-only provider.");
     if (sampling !== undefined)
         fail("Custom generation options are not supported.");
     if (temperature !== undefined && (typeof temperature !== "number" || !Number.isFinite(temperature) || temperature < 0 || temperature > 2))
         fail("Temperature must be finite and between 0 and 2.");
-    if (maxTokens !== undefined && (typeof maxTokens !== "number" || !Number.isInteger(maxTokens) || maxTokens <= 0 || maxTokens > MAX_OUTPUT_TOKENS))
+    if (maxTokens !== undefined && (typeof maxTokens !== "number" || !Number.isInteger(maxTokens) || maxTokens <= 0 || maxTokens > 65_536))
         fail("maxTokens must be a positive integer no greater than 65536.");
     if (headers !== undefined && !isRecord(headers))
         fail("Invalid generation options.");
@@ -95,6 +150,9 @@ function validateOptions(options) {
         if (RESERVED_HEADERS.has(name.toLowerCase()))
             fail("Custom headers cannot replace protected request headers.");
 }
+function isThinkingLevel(value) {
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
 function byteLength(value) {
     return new TextEncoder().encode(value).byteLength;
 }

package/dist/provider.js

@@ -1,9 +1,9 @@
 import { ANTIGRAVITY_ENDPOINTS } from "@benjamolina/antigravity-guard-core";
+import { listCatalogEntries, toPiModelDescriptor } from "./catalog.js";
 import { createPiOAuthLifecycle } from "./oauth.js";
 import { createPiLifecycleStream, executeStreamTransport } from "./stream.js";
 const PROVIDER = "antigravity-guard";
 const API = "antigravity-guard-sse";
-const MODEL = "antigravity-gemini-3.8-flash";
 const INVALID_CREDENTIALS = "Antigravity credentials are invalid. Run /login antigravity-guard.";
 export function registerAntigravityProvider(pi) {
     const oauth = createPiOAuthLifecycle({ fetch: globalThis.fetch, now: Date.now });
@@ -11,15 +11,7 @@ export function registerAntigravityProvider(pi) {
         name: "Antigravity Guard",
         baseUrl: ANTIGRAVITY_ENDPOINTS.daily,
         api: API,
-        models: [{
-                id: MODEL,
-                name: "Gemini 3.8 Flash (Antigravity, text only)",
-                reasoning: false,
-                input: ["text"],
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-                contextWindow: 1_048_576,
-                maxTokens: 65_536,
-            }],
+        models: listCatalogEntries().map(toPiModelDescriptor),
         oauth: {
             name: "Antigravity Guard",
             isSubscription: true,

package/dist/response.d.ts

@@ -1,7 +1,13 @@
-export type ResponseSemantic = TextSemantic | FinishSemantic | UsageSemantic;
+export type ResponseSemantic = TextSemantic | ThinkingSemantic | FinishSemantic | UsageSemantic;
 export interface TextSemantic {
     type: "text";
     text: string;
+    signature?: string;
+}
+export interface ThinkingSemantic {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
 }
 export interface FinishSemantic {
     type: "finish";
@@ -13,18 +19,19 @@ export interface UsageSemantic {
     output: number;
     cacheRead: number;
     cacheWrite: 0;
+    reasoning: number;
     total: number;
 }
 export declare class ResponseSemanticError extends Error {
 }
 export declare class ResponseSemantics {
     private finished;
-    private text;
+    private content;
     private done;
     private usage;
     push(record: string): ResponseSemantic[];
     finish(): void;
-    addText(text: string): void;
+    addContent(text: string): void;
     addFinish(): void;
     private updateUsage;
 }

package/dist/response.js

@@ -2,9 +2,9 @@ export class ResponseSemanticError extends Error {
 }
 export class ResponseSemantics {
     finished = false;
-    text = false;
+    content = false;
     done = false;
-    usage = { prompt: 0, cacheRead: 0, output: 0 };
+    usage = { prompt: 0, cacheRead: 0, output: 0, reasoning: 0 };
     push(record) {
         if (this.done)
             throw new ResponseSemanticError("Response data arrived after [DONE].");
@@ -35,20 +35,22 @@ export class ResponseSemantics {
     finish() {
         if (!this.finished)
             throw new ResponseSemanticError("Response ended without a finish reason.");
-        if (!this.text)
-            throw new ResponseSemanticError("Response ended without text.");
+        if (!this.content)
+            throw new ResponseSemanticError("Response ended without content.");
     }
-    addText(text) { this.text = this.text || text.length > 0; }
+    addContent(text) { this.content = this.content || text.length > 0; }
     addFinish() { this.finished = true; }
     updateUsage(value) {
         const prompt = count(value, "promptTokenCount", this.usage.prompt);
         const cacheRead = count(value, "cachedContentTokenCount", this.usage.cacheRead);
-        const output = count(value, "candidatesTokenCount", this.usage.output) + count(value, "thoughtsTokenCount", 0);
+        const candidates = count(value, "candidatesTokenCount", this.usage.output - this.usage.reasoning);
+        const reasoning = count(value, "thoughtsTokenCount", this.usage.reasoning);
+        const output = candidates + reasoning;
         const reported = field(value, "totalTokenCount");
         if (cacheRead > prompt || (reported !== undefined && reported !== prompt + output))
             throw new ResponseSemanticError("Antigravity returned invalid usage.");
-        this.usage = { prompt, cacheRead, output };
-        return { type: "usage", input: prompt - cacheRead, output, cacheRead, cacheWrite: 0, total: prompt + output };
+        this.usage = { prompt, cacheRead, output, reasoning };
+        return { type: "usage", input: prompt - cacheRead, output, cacheRead, cacheWrite: 0, reasoning, total: prompt + output };
     }
 }
 function candidate(value, events, semantics) {
@@ -67,10 +69,15 @@ function candidate(value, events, semantics) {
             throw new ResponseSemanticError("Antigravity returned invalid content.");
         for (const part of parts) {
             const text = field(part, "text");
-            if (typeof text !== "string" || Object.keys(part).some((name) => name !== "text" && name !== "thoughtSignature"))
+            const thought = field(part, "thought");
+            if (typeof text !== "string" || (thought !== undefined && typeof thought !== "boolean") || Object.keys(part).some((name) => name !== "text" && name !== "thought" && name !== "thoughtSignature"))
                 throw new ResponseSemanticError("Antigravity returned unsupported content.");
-            semantics.addText(text);
-            events.push({ type: "text", text });
+            const signature = validThoughtSignature(field(part, "thoughtSignature"));
+            semantics.addContent(text);
+            if (thought === true)
+                events.push({ type: "thinking", thinking: text, ...(signature ? { signature } : {}) });
+            else
+                events.push({ type: "text", text, ...(signature ? { signature } : {}) });
         }
     }
     const finishReason = field(candidate, "finishReason");
@@ -81,6 +88,11 @@ function candidate(value, events, semantics) {
         events.push({ type: "finish", reason: finishReason === "STOP" ? "stop" : "length" });
     }
 }
+function validThoughtSignature(value) {
+    if (typeof value !== "string" || !value || value.length % 4 !== 0)
+        return undefined;
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? value : undefined;
+}
 function validateMetadata(value) {
     for (const name of ["responseId", "modelVersion"]) {
         const metadata = field(value, name);

package/dist/stream.js

@@ -1,5 +1,6 @@
 import { calculateCost, createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 import { ANTIGRAVITY_ENDPOINTS } from "@benjamolina/antigravity-guard-core";
+import { getCatalogEntry } from "./catalog.js";
 import { serializeTextContext } from "./context.js";
 import { ResponseSemanticError, ResponseSemantics } from "./response.js";
 import { SseFrameError, SseFramer } from "./sse.js";
@@ -9,7 +10,6 @@ const MAX_ERROR_BYTES = 64 * 1024;
 const ANTIGRAVITY_USER_AGENT = "antigravity/cli/1.1.23 (aidev_client; os_type=linux; arch=amd64; cl=974125021; auth_method=consumer)";
 const ENDPOINT = `${ANTIGRAVITY_ENDPOINTS.daily}/v1internal:streamGenerateContent?alt=sse`;
 const API = "antigravity-guard-sse";
-const MODEL = "antigravity-gemini-3.8-flash";
 const PROTECTED_HEADERS = new Set(["authorization", "host", "content-type", "content-length"]);
 const LOCAL_ERRORS = new WeakSet();
 export class StreamTransportError extends Error {
@@ -37,6 +37,17 @@ export function createPiLifecycleStream(input) {
     };
     let complete = false;
     let textStarted = false;
+    let currentBlock;
+    const closeBlock = () => {
+        if (!currentBlock)
+            return;
+        const contentIndex = output.content.length - 1;
+        if (currentBlock.type === "text")
+            stream.push({ type: "text_end", contentIndex, content: currentBlock.text, partial: output });
+        else
+            stream.push({ type: "thinking_end", contentIndex, content: currentBlock.thinking, partial: output });
+        currentBlock = undefined;
+    };
     let removeAbort = () => { };
     const finalize = (reason, errorMessage) => {
         if (complete)
@@ -47,8 +58,7 @@ export function createPiLifecycleStream(input) {
             controller.abort();
         output.stopReason = reason;
         if (reason === "stop" || reason === "length") {
-            if (textStarted)
-                stream.push({ type: "text_end", contentIndex: 0, content: output.content[0]?.type === "text" ? output.content[0].text : "", partial: output });
+            closeBlock();
             stream.push({ type: "done", reason, message: output });
         }
         else {
@@ -60,6 +70,35 @@ export function createPiLifecycleStream(input) {
     const onSemantic = (semantic) => {
         if (complete)
             return;
+        if (isContentSemantic(semantic)) {
+            if (!currentBlock || currentBlock.type !== semantic.type) {
+                closeBlock();
+                if (semantic.type === "text") {
+                    currentBlock = { type: "text", text: "" };
+                    output.content.push(currentBlock);
+                    stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });
+                }
+                else {
+                    currentBlock = { type: "thinking", thinking: "" };
+                    output.content.push(currentBlock);
+                    stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
+                }
+            }
+            const contentIndex = output.content.length - 1;
+            if (semantic.type === "text" && currentBlock.type === "text") {
+                currentBlock.text += semantic.text;
+                if (semantic.signature)
+                    currentBlock.textSignature = semantic.signature;
+                stream.push({ type: "text_delta", contentIndex, delta: semantic.text, partial: output });
+            }
+            else if (semantic.type === "thinking" && currentBlock.type === "thinking") {
+                currentBlock.thinking += semantic.thinking;
+                if (semantic.signature)
+                    currentBlock.thinkingSignature = semantic.signature;
+                stream.push({ type: "thinking_delta", contentIndex, delta: semantic.thinking, partial: output });
+            }
+            return;
+        }
         if (semantic.type === "text" && semantic.text) {
             if (!textStarted) {
                 textStarted = true;
@@ -76,6 +115,7 @@ export function createPiLifecycleStream(input) {
             output.usage.output = semantic.output;
             output.usage.cacheRead = semantic.cacheRead;
             output.usage.cacheWrite = semantic.cacheWrite;
+            output.usage.reasoning = semantic.reasoning;
             output.usage.totalTokens = semantic.input + semantic.output + semantic.cacheRead + semantic.cacheWrite;
             output.usage.cost = calculateCost(input.model, output.usage);
         }
@@ -95,6 +135,9 @@ export function createPiLifecycleStream(input) {
             finalize(signal.aborted ? "aborted" : "error"); }, (error) => finalize(signal.aborted || input.signal?.aborted ? "aborted" : "error", isLocalStreamError(error) ? error.message : undefined));
     return stream;
 }
+function isContentSemantic(semantic) {
+    return semantic.type === "text" || semantic.type === "thinking";
+}
 export async function executeStreamTransport(input) {
     validateInput(input);
     const signal = totalSignal(input);
@@ -126,7 +169,7 @@ export async function executeStreamTransport(input) {
     }
 }
 function validateInput(input) {
-    if (input.model.id !== MODEL || input.model.api !== API)
+    if (!getCatalogEntry(input.model.id) || input.model.api !== API)
         throw streamError("response", "The selected Antigravity model or API is unsupported.");
 }
 async function payloadHook(input, payload, signal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benjamolina/pi-antigravity-guard",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Pi adapter for Antigravity Guard",
   "type": "module",
   "license": "MIT",