@benjamolina/pi-antigravity-guard 0.1.0 → 0.2.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 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-tiered`.
 
 ## Use
 
@@ -12,13 +12,15 @@ 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.
+
+`@benjamolina/pi-antigravity-guard@0.2.0` supports Pi reasoning levels `low`, `medium`, and `high`. An authorized live matrix against `gemini-3.8-flash-tiered` confirmed all three levels; `minimal` was rejected twice with zero usage and is not exposed. Each supported level is sent as the matching native `thinkingLevel` with visible thoughts enabled. When reasoning is off or omitted, the request uses native `low` thinking without returning visible thoughts. Custom `thinkingBudgets` are unsupported and rejected.
 
 ## Limits and safety
 
 - This provider stores credentials through Pi's OAuth lifecycle and never reads or changes OpenCode account files; each is independent.
 - 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.
+- The public-to-wire model mapping remains separate from availability and entitlement. The documented reasoning levels are limited to the authorized live matrix results above.
 - It has no account rotation, quota fallback, model substitution, or tool 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/context.d.ts

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

package/dist/context.js

@@ -1,8 +1,10 @@
 const MAX_TEXT_BYTES = 8 * 1024 * 1024;
 const MAX_OUTPUT_TOKENS = 65_536;
+const PROVIDER = "antigravity-guard";
 const PUBLIC_MODEL = "antigravity-gemini-3.8-flash";
 const WIRE_MODEL = "gemini-3.8-flash-tiered";
 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) {
@@ -20,10 +22,8 @@ export function serializeTextContext(input) {
         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,11 +35,12 @@ 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 && isSameProviderAndModel(message));
+            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.");
@@ -49,7 +50,7 @@ export function serializeTextContext(input) {
         return { project, model: WIRE_MODEL, request: { contents, ...(systemInstruction ? { systemInstruction } : {}), generationConfig: {
                     temperature: typeof temperature === "number" ? temperature : 1,
                     maxOutputTokens: typeof maxTokens === "number" ? maxTokens : 4096,
-                    thinkingConfig: { thinkingLevel: "low", includeThoughts: false },
+                    thinkingConfig: resolveThinkingConfig(options),
                 } }, requestType: "agent", userAgent: "antigravity", requestId };
     }
     catch (error) {
@@ -58,29 +59,69 @@ 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) {
+    return field(message, "provider") === PROVIDER && field(message, "model") === PUBLIC_MODEL;
+}
+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 resolveThinkingConfig(options) {
+    const reasoning = option(options, "reasoning");
+    if (isThinkingLevel(reasoning))
+        return { thinkingLevel: reasoning, includeThoughts: true };
+    return { thinkingLevel: "low", includeThoughts: false };
+}
 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))
+        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)
@@ -95,6 +136,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

@@ -14,7 +14,8 @@ export function registerAntigravityProvider(pi) {
         models: [{
                 id: MODEL,
                 name: "Gemini 3.8 Flash (Antigravity, text only)",
-                reasoning: false,
+                reasoning: true,
+                thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high" },
                 input: ["text"],
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
                 contextWindow: 1_048_576,

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

@@ -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);

package/package.json

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