@benjamolina/pi-antigravity-guard 0.2.0 → 0.4.0

package/dist/catalog.js

@@ -0,0 +1,188 @@
+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 }, tools: disabled("missing-direct-evidence") },
+            low: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            medium: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "medium", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            high: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "high", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+        },
+        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 }, tools: disabled("missing-direct-evidence") },
+            low: { wireModel: "gemini-3.7-flash-low", thinking: { kind: "budget", budget: 1000, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            medium: { wireModel: "gemini-3.7-flash-medium", thinking: { kind: "budget", budget: 4000, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            high: { wireModel: "gemini-3.7-flash-high", thinking: { kind: "budget", budget: -1, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+        },
+        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" }, tools: disabled("missing-direct-evidence") },
+            low: { wireModel: "gemini-3.6-flash-low", thinking: { kind: "budget", budget: 1000, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            medium: { wireModel: "gemini-3.6-flash-medium", thinking: { kind: "budget", budget: 4000, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            high: { wireModel: "gemini-3.6-flash-high", thinking: { kind: "budget", budget: -1, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+        },
+        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" }, tools: disabled("missing-direct-evidence") },
+            low: { wireModel: "gemini-3.1-pro-low", thinking: { kind: "budget", budget: 1001, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            high: { wireModel: "gemini-pro-agent", thinking: { kind: "budget", budget: 10001, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+        },
+        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 }, tools: disabled("claude-continuity-unproven") },
+            high: { wireModel: "claude-sonnet-4-6", thinking: { kind: "budget", budget: 1024, includeThoughts: true }, tools: disabled("claude-continuity-unproven") },
+        },
+        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 }, tools: disabled("claude-continuity-unproven") },
+            high: { wireModel: "claude-opus-4-6-thinking", thinking: { kind: "budget", budget: 1024, includeThoughts: true }, tools: disabled("claude-continuity-unproven") },
+        },
+        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" }, tools: disabled("missing-direct-evidence") },
+            medium: { wireModel: "gpt-oss-120b-medium", thinking: { kind: "budget", budget: 8192, includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+        },
+        replay: { kind: "strip" },
+        response: { kind: "gemini-envelope", family: "gpt-oss" },
+    }]));
+const lookup = new Map(CATALOG.map((entry) => [entry.publicId, entry]));
+function disabled(reason) {
+    return { state: "disabled", contractRevision: 1, reason };
+}
+/** Constructs deterministic capability data for hermetic serializer tests only. */
+export function createEnabledToolCapability(evidence) {
+    return freeze({ state: "enabled", contractRevision: 1, fixtureEvidence: evidence, directEvidence: evidence });
+}
+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) {
+    return resolveGenerationSelection(entry, reasoning).route;
+}
+export function resolveGenerationSelection(entry, reasoning) {
+    const level = reasoning === undefined || reasoning === "off" ? "off" : reasoning;
+    if (typeof level !== "string" || !entry.routes[level])
+        throw new Error("Unsupported reasoning level");
+    const typedLevel = level;
+    const configured = entry.routes[typedLevel];
+    const { tools, ...route } = configured;
+    return { level: typedLevel, route, tools: resolveToolCapability(tools, entry.publicId, typedLevel, route.wireModel) };
+}
+export function resolveToolCapability(capability, publicModelId, reasoning, wireModel) {
+    if (capability.state === "disabled")
+        return capability;
+    const evidence = capability.state === "enabled" ? [capability.fixtureEvidence, capability.directEvidence] : [capability.fixtureEvidence];
+    if (capability.contractRevision !== 1 || evidence.some((item) => item.publicModelId !== publicModelId || item.reasoning !== reasoning || item.wireModel !== wireModel)) {
+        return freeze(disabled("stale-or-conflicting-evidence"));
+    }
+    return capability;
+}
+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,5 @@
 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];
+import { type GenerationSelection } from "./catalog.ts";
 interface Part {
     text: string;
     thought?: true;
@@ -9,24 +7,34 @@ interface Part {
 }
 interface Content {
     role: "user" | "model";
-    parts: Part[];
-}
-interface ThinkingConfig {
-    thinkingLevel: ThinkingLevel;
-    includeThoughts: boolean;
+    parts: object[];
 }
 export interface GenerationRequest {
     project: string;
-    model: typeof WIRE_MODEL;
+    model: string;
     request: {
         contents: Content[];
         systemInstruction?: {
             parts: Part[];
         };
+        tools?: {
+            functionDeclarations: unknown;
+        }[];
+        toolConfig?: {
+            functionCallingConfig: {
+                mode: "AUTO" | "NONE";
+            };
+        };
         generationConfig: {
             temperature: number;
             maxOutputTokens: number;
-            thinkingConfig: ThinkingConfig;
+            thinkingConfig?: {
+                thinkingLevel: "low" | "medium" | "high";
+                includeThoughts: boolean;
+            } | {
+                thinkingBudget: number;
+                includeThoughts: boolean;
+            };
         };
     };
     requestType: "agent";
@@ -42,5 +50,6 @@ export interface SerializeTextContextInput {
 }
 export declare class ContextSerializationError extends Error {
 }
+export declare function serializeContext(input: SerializeTextContextInput, injectedSelection?: GenerationSelection, onRecovery?: (recoveryCount: number) => void): GenerationRequest;
 export declare function serializeTextContext(input: SerializeTextContextInput): GenerationRequest;
 export {};

package/dist/context.js

@@ -1,12 +1,38 @@
+import { getCatalogEntry, resolveGenerationSelection } from "./catalog.js";
+import { hasToolContext, prepareToolContext, replayToolHistory } from "./tool-context.js";
 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 serializeContext(input, injectedSelection, onRecovery) {
+    const context = input.context;
+    if (!hasToolContext(context))
+        return serializeTextContext(input);
+    const options = input.options;
+    const entry = isRecord(input.model) ? getCatalogEntry(field(input.model, "id", true)) : undefined;
+    if (!entry || !isRecord(context))
+        return serializeTextContext(input);
+    const selected = resolveGenerationSelection(entry, isRecord(options) ? option(options, "reasoning") : undefined);
+    const selection = injectedSelection ?? selected;
+    if (selection.level !== selected.level || selection.route.wireModel !== selected.route.wireModel)
+        fail("Invalid tool capability selection.");
+    if (selection.tools.state !== "enabled")
+        fail(capabilityError(entry.publicId, selection.level, selection.tools));
+    const prepared = prepareToolContext(field(context, "tools") ?? [], isRecord(options) ? field(options, "toolChoice") : undefined);
+    const { tools: _tools, messages, ...textContext } = context;
+    const { toolChoice: _choice, ...textOptions } = isRecord(options) ? options : {};
+    const text = serializeTextContext({ ...input, context: { ...textContext, messages: [{ role: "user", content: "placeholder", timestamp: 0 }] }, options: textOptions });
+    const contents = replayToolHistory(isDenseArray(messages), (part, message) => messagePart(part, field(message, "role") === "assistant", field(message, "role") === "assistant" && entry.replay.kind === "same-public-model" && isSameProviderAndModel(message, entry.publicId)), onRecovery);
+    const { systemInstruction, generationConfig } = text.request;
+    return { ...text, request: {
+            contents,
+            ...(systemInstruction ? { systemInstruction } : {}),
+            ...(prepared ? { tools: [{ functionDeclarations: prepared.declarations }], toolConfig: { functionCallingConfig: { mode: prepared.mode } } } : {}),
+            generationConfig,
+        } };
+}
 export function serializeTextContext(input) {
     try {
         if (!isRecord(input))
@@ -16,8 +42,13 @@ 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 selection = resolveGenerationSelection(entry, option(options, "reasoning"));
+        const route = selection.route;
+        if (isToolBearingContext(context) && selection.tools.state !== "enabled")
+            fail(capabilityError(entry.publicId, selection.level, selection.tools));
         const systemPrompt = field(context, "systemPrompt");
         const tools = field(context, "tools");
         if (systemPrompt !== undefined && typeof systemPrompt !== "string")
@@ -36,7 +67,7 @@ export function serializeTextContext(input) {
             if (role !== "user" && role !== "assistant")
                 fail("Unsupported context role for this text-only provider.");
             const assistant = role === "assistant";
-            const parts = messageParts(field(message, "content", true), assistant, assistant && isSameProviderAndModel(message));
+            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.");
@@ -47,10 +78,13 @@ export function serializeTextContext(input) {
         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: resolveThinkingConfig(options),
+                    maxOutputTokens: resolveOutputTokens(maxTokens, entry.descriptor.maxTokens, route.thinking),
+                    ...(() => {
+                        const thinkingConfig = serializeThinkingConfig(route.thinking);
+                        return thinkingConfig ? { thinkingConfig } : {};
+                    })(),
                 } }, requestType: "agent", userAgent: "antigravity", requestId };
     }
     catch (error) {
@@ -59,64 +93,97 @@ export function serializeTextContext(input) {
         fail("Invalid text context.");
     }
 }
+function capabilityError(publicId, reasoning, capability) {
+    const reason = capability.state === "disabled" ? capability.reason : capability.state;
+    return `PI_TOOL_CAPABILITY_NOT_ENABLED: ${publicId}/${reasoning} is ${capability.state} (${reason}).`;
+}
+function isToolBearingContext(context) {
+    const tools = field(context, "tools");
+    if (tools !== undefined && isDenseArray(tools).length > 0)
+        return true;
+    const messages = isDenseArray(field(context, "messages", true));
+    for (const message of messages) {
+        if (!isRecord(message))
+            continue;
+        if (field(message, "role") === "toolResult")
+            return true;
+        const content = field(message, "content");
+        if (!Array.isArray(content))
+            continue;
+        for (const part of content)
+            if (isRecord(part) && field(part, "type") === "toolCall")
+                return true;
+    }
+    return false;
+}
 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))
+    return parts.map((part) => messagePart(isRecord(part) ? part : fail("Only text context is supported by this provider."), assistant, sameProviderAndModel));
+}
+function messagePart(part, assistant, sameProviderAndModel) {
+    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 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.");
-    });
+        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 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 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 && reasoning !== "off" && !isThinkingLevel(reasoning))
+    if (reasoning !== undefined && reasoning !== "off" && !isThinkingLevel(reasoning) && reasoning !== "minimal")
         fail("Unsupported reasoning level.");
     if (budgets !== undefined)
         fail("Thinking budgets are not supported.");
@@ -128,7 +195,7 @@ function validateOptions(options) {
         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.");

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,16 +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: 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,
-                maxTokens: 65_536,
-            }],
+        models: listCatalogEntries().map(toPiModelDescriptor),
         oauth: {
             name: "Antigravity Guard",
             isSubscription: true,

package/dist/response.d.ts

@@ -1,4 +1,5 @@
-export type ResponseSemantic = TextSemantic | ThinkingSemantic | FinishSemantic | UsageSemantic;
+import type { JsonObject } from "./tool-contract.ts";
+export type ResponseSemantic = TextSemantic | ThinkingSemantic | ToolCallSemantic | FinishSemantic | UsageSemantic;
 export interface TextSemantic {
     type: "text";
     text: string;
@@ -9,9 +10,18 @@ export interface ThinkingSemantic {
     thinking: string;
     signature?: string;
 }
+export interface ToolCallSemantic {
+    type: "toolCall";
+    callIndex: number;
+    id: string;
+    name: string;
+    arguments: JsonObject;
+    argumentsJson: string;
+    signature?: string;
+}
 export interface FinishSemantic {
     type: "finish";
-    reason: "stop" | "length";
+    reason: "stop" | "length" | "toolUse";
 }
 export interface UsageSemantic {
     type: "usage";
@@ -22,16 +32,31 @@ export interface UsageSemantic {
     reasoning: number;
     total: number;
 }
+export type ToolResponsePolicy = {
+    kind: "reject";
+} | {
+    kind: "accept";
+    declaredNames: ReadonlySet<string>;
+};
 export declare class ResponseSemanticError extends Error {
 }
 export declare class ResponseSemantics {
+    readonly policy: ToolResponsePolicy;
     private finished;
-    private content;
     private done;
+    private content;
+    private calls;
+    private readonly ids;
+    private pendingFinish;
     private usage;
+    constructor(policy?: ToolResponsePolicy);
     push(record: string): ResponseSemantic[];
-    finish(): void;
-    addContent(text: string): void;
-    addFinish(): void;
+    finish(): FinishSemantic;
     private updateUsage;
+    addContent(text: string): void;
+    addCall(): void;
+    setFinish(reason: FinishSemantic["reason"]): void;
+    hasId(id: string): boolean;
+    addId(id: string): void;
+    callIndex(): number;
 }