@benjamolina/pi-antigravity-guard 0.4.0 → 0.4.2

package/README.md

@@ -14,11 +14,11 @@ Choose browser login, or choose manual login and paste the complete callback URL
 
 ## Text registration is not tool enablement
 
-All seven rows below are registered for text. Every production route is currently **not enabled for tools**, so a context with a declaration, assistant tool call, or tool result fails locally before any network request. Text-only requests retain their released behavior.
+All seven rows below are registered for text. The exact `antigravity-gemini-3.8-flash` `off` route is enabled for tools from recorded direct evidence; every other production route is **not enabled for tools**, so its context with a declaration, assistant tool call, or tool result fails locally before any network request. Text-only requests retain their released behavior.
 
-| Public ID | Exposed Pi levels | Tool state | Why tools are unavailable |
+| Public ID | Exposed Pi levels | Tool state | Admission |
 |---|---|---|---|
-| `antigravity-gemini-3.8-flash` | off, low, medium, high | Disabled | missing-direct-evidence |
+| `antigravity-gemini-3.8-flash` | off, low, medium, high | Enabled (off) | pi-json-tool-loop/gemini-3.8-flash-off-v1 |
 | `antigravity-gemini-3.7-flash` | off, low, medium, high | Disabled | missing-direct-evidence |
 | `antigravity-gemini-3.6-flash` | off, low, medium, high | Disabled | missing-direct-evidence |
 | `antigravity-gemini-3.1-pro` | off, low, high | Disabled | missing-direct-evidence |
@@ -28,13 +28,17 @@ All seven rows below are registered for text. Every production route is currentl
 
 `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. `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. A future `fixture-qualified` route remains disabled for ordinary tool use; only separately authorized direct validation for the exact route may make it enabled.
 
-Claude Sonnet and Claude Opus remain disabled until declaration, call, result replay, thinking-signature, resume, interruption, and continuation evidence is recorded for each exact route. No route is enabled by this package release.
+Claude Sonnet and Claude Opus remain disabled until declaration, call, result replay, thinking-signature, resume, interruption, and continuation evidence is recorded for each exact route. Only Gemini 3.8 Flash `off` is enabled by this package release.
+
+## Opt-in direct tool-loop validation
+
+Maintainers can run `npm run build:pi` followed by `npx tsx scripts/pi-tool-loop-probe.ts --live --expect-enabled` to verify the directly admitted Gemini 3.8 Flash `off` route. The isolated runner invokes Pi in `--mode json`, passes the deterministic non-terminating `pi_evidence_echo` prompt positionally, drains its event stream, and completes after Pi emits `agent_end` and the child exits. It stores only the passing route and sanitized assertions; it never stores message contents, tool details, names, IDs, arguments, credentials, headers, or raw provider output. Other routes remain fail-closed.
 
 ## Tool preflight boundaries
 
 Tool-bearing requests are never silently downgraded to text. When an exact route is eventually enabled, declarations are retained in order and omitted or `auto` choice serializes as `AUTO`; explicit `none` serializes as `NONE`. Forced, required, named, unknown, and constrained-sampling choices are rejected before transport.
 
-Schemas must use the documented strict object-rooted subset. Unsupported keywords, references, unions, lossy constraints, empty objects, and oversized input are rejected rather than cleaned. Tool results must match the exact call ID and name, remain text-only, and are replayed in assistant source-call order; image-bearing or ambiguous results are rejected. A missing persisted result uses the documented failed response only during context reconstruction.
+Only the evidence-enabled Gemini 3.8 Flash `off` route uses the `parametersJsonSchema` profile. Its hermetically verified preflight preserves ordinary JSON Schema constraints and JSON values in canonical immutable output, including safe local RFC 6901 `$ref` expansion (`#` and `#/...`) with resolved definitions removed. External, malformed, unresolved, cyclic, or otherwise unsafe references fail closed before transport. This is local serialization and safety evidence, not direct live backend acceptance of constrained or reference-based schemas. Tool results must match the exact call ID and name, remain text-only, and are replayed in assistant source-call order; image-bearing or ambiguous results are rejected. A missing persisted result uses the documented failed response only during context reconstruction.
 
 ## Text catalog limits and safety
 
@@ -52,6 +56,6 @@ An explicit `maxTokens` must be a positive integer no greater than the row's out
 
 - Costs are reported as zero because subscription usage is unpriced, not because access is free.
 - 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, image support, or enabled tools.
+- It has no account rotation, quota fallback, model substitution, image support, or enabled tools beyond the directly admitted Gemini 3.8 Flash `off` route.
 
 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

@@ -7,6 +7,8 @@ export interface ToolEvidenceRef {
     readonly reasoning: StandardReasoningLevel;
     readonly wireModel: string;
 }
+export declare const GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE: "gemini-parameters-json-schema";
+export type ToolSchemaProfile = typeof GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE;
 export type ToolCapability = {
     readonly state: "disabled";
     readonly contractRevision: 1;
@@ -18,6 +20,7 @@ export type ToolCapability = {
 } | {
     readonly state: "enabled";
     readonly contractRevision: 1;
+    readonly schemaProfile: ToolSchemaProfile;
     readonly fixtureEvidence: ToolEvidenceRef;
     readonly directEvidence: ToolEvidenceRef;
 };
@@ -402,7 +405,7 @@ type Catalog = typeof CATALOG;
 export type AntigravityPublicModelId = Catalog[number]["publicId"];
 export type AntigravityWireModelId = Catalog[number]["routes"][keyof Catalog[number]["routes"]]["wireModel"];
 /** Constructs deterministic capability data for hermetic serializer tests only. */
-export declare function createEnabledToolCapability(evidence: ToolEvidenceRef): Extract<ToolCapability, {
+export declare function createEnabledToolCapability(evidence: ToolEvidenceRef, schemaProfile?: ToolSchemaProfile): Extract<ToolCapability, {
     readonly state: "enabled";
 }>;
 export declare function defineCatalog<T extends readonly {

package/dist/catalog.js

@@ -1,4 +1,5 @@
 const ANSWER_RESERVE = 1024;
+export const GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE = "gemini-parameters-json-schema";
 const CATALOG = freeze(defineCatalog([{
         publicId: "antigravity-gemini-3.8-flash",
         descriptor: {
@@ -8,7 +9,7 @@ const CATALOG = freeze(defineCatalog([{
             maxTokens: 65_536,
         },
         routes: {
-            off: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: false }, tools: disabled("missing-direct-evidence") },
+            off: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: false }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-off-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "off", wireModel: "gemini-3.8-flash-tiered" }, GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) },
             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") },
@@ -109,9 +110,12 @@ const lookup = new Map(CATALOG.map((entry) => [entry.publicId, entry]));
 function disabled(reason) {
     return { state: "disabled", contractRevision: 1, reason };
 }
+function enabled(evidence, schemaProfile = GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) {
+    return { state: "enabled", contractRevision: 1, schemaProfile, fixtureEvidence: evidence, directEvidence: evidence };
+}
 /** Constructs deterministic capability data for hermetic serializer tests only. */
-export function createEnabledToolCapability(evidence) {
-    return freeze({ state: "enabled", contractRevision: 1, fixtureEvidence: evidence, directEvidence: evidence });
+export function createEnabledToolCapability(evidence, schemaProfile = GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) {
+    return freeze({ state: "enabled", contractRevision: 1, schemaProfile, fixtureEvidence: evidence, directEvidence: evidence });
 }
 function freeze(value) {
     if (typeof value === "object" && value !== null) {

package/dist/context.d.ts

@@ -1,5 +1,6 @@
 import type { Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
 import { type GenerationSelection } from "./catalog.ts";
+import { type ToolReplayDiagnostics } from "./tool-context.ts";
 interface Part {
     text: string;
     thought?: true;
@@ -9,6 +10,11 @@ interface Content {
     role: "user" | "model";
     parts: object[];
 }
+interface GeminiFunctionDeclaration {
+    readonly name: string;
+    readonly description: string;
+    readonly parametersJsonSchema: object;
+}
 export interface GenerationRequest {
     project: string;
     model: string;
@@ -18,7 +24,7 @@ export interface GenerationRequest {
             parts: Part[];
         };
         tools?: {
-            functionDeclarations: unknown;
+            functionDeclarations: readonly GeminiFunctionDeclaration[];
         }[];
         toolConfig?: {
             functionCallingConfig: {
@@ -50,6 +56,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 serializeContext(input: SerializeTextContextInput, injectedSelection?: GenerationSelection, onDiagnostics?: (diagnostics: ToolReplayDiagnostics) => void): GenerationRequest;
 export declare function serializeTextContext(input: SerializeTextContextInput): GenerationRequest;
 export {};

package/dist/context.js

@@ -6,7 +6,7 @@ const RESERVED_HEADERS = new Set(["authorization", "host", "content-type", "cont
 const THINKING_LEVELS = ["low", "medium", "high"];
 export class ContextSerializationError extends Error {
 }
-export function serializeContext(input, injectedSelection, onRecovery) {
+export function serializeContext(input, injectedSelection, onDiagnostics) {
     const context = input.context;
     if (!hasToolContext(context))
         return serializeTextContext(input);
@@ -20,16 +20,25 @@ export function serializeContext(input, injectedSelection, onRecovery) {
         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 prepared = prepareToolContext(field(context, "tools") ?? [], isRecord(options) ? field(options, "toolChoice") : undefined, selection.tools.schemaProfile);
     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 sameModel = (message) => field(message, "role") === "assistant" && entry.replay.kind === "same-public-model" && isSameProviderAndModel(message, entry.publicId);
+    const signedToolReplay = geminiRequiresSignedToolReplay(selection.route.wireModel) ? {
+        requireSignedToolCalls: true,
+        isSameModel: sameModel,
+        toolCallSignature: (part, message) => sameModel(message) ? validThoughtSignature(field(part, "thoughtSignature")) : undefined,
+    } : undefined;
+    const contents = replayToolHistory(isDenseArray(messages), (part, message) => messagePart(part, field(message, "role") === "assistant", sameModel(message)), onDiagnostics, signedToolReplay, prepared?.declarations.length ?? 0);
     const { systemInstruction, generationConfig } = text.request;
     return { ...text, request: {
             contents,
             ...(systemInstruction ? { systemInstruction } : {}),
-            ...(prepared ? { tools: [{ functionDeclarations: prepared.declarations }], toolConfig: { functionCallingConfig: { mode: prepared.mode } } } : {}),
+            ...(prepared ? {
+                tools: [{ functionDeclarations: prepared.declarations.map(({ name, description, parameters }) => ({ name, description, parametersJsonSchema: parameters })) }],
+                ...(prepared.mode === "NONE" ? { toolConfig: { functionCallingConfig: { mode: "NONE" } } } : {}),
+            } : {}),
             generationConfig,
         } };
 }
@@ -172,6 +181,10 @@ function resolveOutputTokens(maxTokens, maxAllowed, thinking) {
     }
     return thinking.kind === "budget" && thinking.budget > 0 ? Math.max(4096, thinking.budget + 1024) : 4096;
 }
+function geminiRequiresSignedToolReplay(wireModel) {
+    const match = /^gemini-(\d+)(?:[.-])/.exec(wireModel);
+    return match !== null && Number(match[1]) >= 3;
+}
 function validThoughtSignature(value) {
     if (typeof value !== "string" || !value || value.length % 4 !== 0)
         return undefined;

package/dist/response.js

@@ -83,9 +83,18 @@ function candidate(value, events, semantics) {
         const parts = field(content, "parts");
         if (!Array.isArray(parts))
             throw new ResponseSemanticError("Antigravity returned invalid content.");
+        const explicitIds = new Set();
+        for (const part of parts) {
+            const call = field(part, "functionCall");
+            if (call !== undefined) {
+                const id = field(call, "id");
+                if (typeof id === "string")
+                    explicitIds.add(id);
+            }
+        }
         for (const part of parts) {
             if (field(part, "functionCall") !== undefined) {
-                const call = toolCall(part, semantics, ids, callCount++);
+                const call = toolCall(part, semantics, ids, explicitIds, callCount++);
                 ids.push(call.id);
                 local.push(call);
             }
@@ -102,8 +111,8 @@ function candidate(value, events, semantics) {
     const finishReason = field(item, "finishReason");
     if (finishReason !== undefined) {
         const hasCalls = semantics.callIndex() + callCount > 0;
-        const reason = finishReason === "STOP" ? "stop" : finishReason === "MAX_TOKENS" ? "length" : finishReason === "OTHER" && hasCalls ? "toolUse" : undefined;
-        if (!reason || (hasCalls && reason !== "toolUse"))
+        const reason = hasCalls ? "toolUse" : finishReason === "STOP" ? "stop" : finishReason === "MAX_TOKENS" ? "length" : undefined;
+        if (!reason)
             throw new ResponseSemanticError("Antigravity returned an unsupported finish reason.");
         semantics.setFinish(reason);
     }
@@ -119,13 +128,14 @@ function candidate(value, events, semantics) {
         events.push(event);
     }
 }
-function toolCall(part, semantics, ids, offset) {
+function toolCall(part, semantics, ids, explicitIds, offset) {
     if (semantics.policy.kind !== "accept" || keys(part, ["functionCall", "thoughtSignature"]))
         throw new ResponseSemanticError("Antigravity returned unsupported content.");
     const call = field(part, "functionCall");
     if (keys(call, ["id", "name", "args"]))
         throw new ResponseSemanticError("Antigravity returned unsupported content.");
-    const id = field(call, "id");
+    const suppliedId = field(call, "id");
+    const id = suppliedId === undefined ? localCallId(semantics, ids, explicitIds, offset) : suppliedId;
     const name = field(call, "name");
     const args = field(call, "args");
     if (typeof id !== "string" || !id.trim() || typeof name !== "string" || !semantics.policy.declaredNames.has(name) || semantics.hasId(id) || ids.includes(id))
@@ -146,6 +156,15 @@ function toolCall(part, semantics, ids, offset) {
     const signature = validThoughtSignature(field(part, "thoughtSignature"));
     return { type: "toolCall", callIndex: semantics.callIndex() + offset, id, name, arguments: argumentsValue, argumentsJson, ...(signature ? { signature } : {}) };
 }
+function localCallId(semantics, ids, explicitIds, offset) {
+    let suffix = semantics.callIndex() + offset + 1;
+    let id = `pi-gemini-call-${suffix}`;
+    while (semantics.hasId(id) || ids.includes(id) || explicitIds.has(id)) {
+        suffix++;
+        id = `pi-gemini-call-${suffix}`;
+    }
+    return id;
+}
 function depth(value, level = 0) {
     let maximum = level;
     for (const item of Object.values(value))

package/dist/stream.d.ts

@@ -1,5 +1,6 @@
 import type { Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
 import { type GenerationSelection } from "./catalog.ts";
+import { type ToolReplayMode } from "./tool-context.ts";
 import type { ResponseSemantic } from "./response.ts";
 type StreamErrorKind = "aborted" | "access" | "capability" | "model" | "quota" | "preflight" | "response" | "transport" | "callback";
 export interface ToolStreamDiagnostics {
@@ -9,7 +10,17 @@ export interface ToolStreamDiagnostics {
     readonly preflight?: "accepted" | string;
     readonly preflightCategory?: string;
     readonly preflightPath?: string;
-    readonly recoveryCount?: number;
+    readonly replayMode: ToolReplayMode;
+    readonly recoveryCount: number;
+    readonly userMessageCount: number;
+    readonly assistantMessageCount: number;
+    readonly toolResultMessageCount: number;
+    readonly assistantToolCallBlockCount: number;
+    readonly declaredToolCount: number;
+    readonly failure?: {
+        readonly kind: StreamErrorKind;
+        readonly status?: number;
+    };
 }
 type ToolDiagnosticSemantic = {
     type: "toolDiagnostics";

package/dist/stream.js

@@ -55,7 +55,7 @@ export function createPiLifecycleStream(input) {
         currentBlock = undefined;
     };
     let removeAbort = () => { };
-    const finalize = (reason, errorMessage, details) => {
+    const finalize = (reason, errorMessage, details, error) => {
         if (complete)
             return;
         complete = true;
@@ -69,8 +69,9 @@ export function createPiLifecycleStream(input) {
         }
         output.stopReason = reason;
         const diagnostic = details ?? toolDiagnostics;
+        const failure = error && isLocalStreamError(error) ? diagnosticFailure(error) : undefined;
         if (sawToolCall || diagnostic)
-            output.diagnostics = [{ type: "antigravity-guard.tools", timestamp: input.now(), details: { ...diagnostic, terminal: reason } }];
+            output.diagnostics = [{ type: "antigravity-guard.tools", timestamp: input.now(), details: { ...diagnostic, ...(failure ? { failure } : {}), terminal: reason } }];
         if (reason === "stop" || reason === "length" || reason === "toolUse") {
             closeBlock();
             stream.push({ type: "done", reason, message: output });
@@ -153,7 +154,7 @@ export function createPiLifecycleStream(input) {
     };
     stream.push({ type: "start", partial: output });
     if (input.signal) {
-        const abort = () => finalize("aborted");
+        const abort = () => finalize("aborted", undefined, undefined, streamError("aborted", "Generation was cancelled."));
         input.signal.addEventListener("abort", abort, { once: true });
         removeAbort = () => input.signal?.removeEventListener("abort", abort);
         if (input.signal.aborted)
@@ -161,7 +162,7 @@ export function createPiLifecycleStream(input) {
     }
     if (!complete)
         void Promise.resolve().then(() => input.runTransport({ onSemantic, signal })).then(() => { if (!complete)
-            finalize(signal.aborted ? "aborted" : "error"); }, (error) => finalize(signal.aborted || input.signal?.aborted ? "aborted" : "error", isLocalStreamError(error) ? error.message : undefined, isLocalStreamError(error) ? error.details : undefined));
+            finalize(signal.aborted ? "aborted" : "error"); }, (error) => finalize(signal.aborted || input.signal?.aborted ? "aborted" : "error", isLocalStreamError(error) ? error.message : undefined, isLocalStreamError(error) ? error.details : undefined, isLocalStreamError(error) ? error : undefined));
     return stream;
 }
 function isContentSemantic(semantic) {
@@ -173,13 +174,13 @@ export async function executeStreamTransport(input) {
     const headers = requestHeaders(input);
     let responseBody = null;
     let selection;
-    let recoveryCount = 0;
+    let replayDiagnostics = emptyReplayDiagnostics();
     try {
         const entry = getCatalogEntry(input.model.id);
         selection = input.selection ?? resolveGenerationSelection(entry, input.generationOptions?.reasoning);
-        const original = serializeContext({ context: input.context, model: input.model, options: input.generationOptions, project: input.projectId, requestId: input.requestId }, selection, (count) => { recoveryCount = count; });
+        const original = serializeContext({ context: input.context, model: input.model, options: input.generationOptions, project: input.projectId, requestId: input.requestId }, selection, (diagnostics) => { replayDiagnostics = diagnostics; });
         if (hasToolContext(input.context))
-            await deliver(input.onSemantic, { type: "toolDiagnostics", details: toolDiagnostics(entry.publicId, selection, recoveryCount, "accepted") });
+            await deliver(input.onSemantic, { type: "toolDiagnostics", details: toolDiagnostics(entry.publicId, selection, replayDiagnostics, "accepted") });
         const payload = await payloadHook(input, original, signal);
         const response = await abortable(input.fetch(ENDPOINT, { method: "POST", redirect: "error", headers, body: JSON.stringify(payload), signal }), signal);
         await responseHook(input, response, signal);
@@ -199,11 +200,11 @@ export async function executeStreamTransport(input) {
         if (signal.aborted)
             throw streamError("aborted", "Generation was cancelled.");
         if (error instanceof ToolPreflightError && selection) {
-            const details = toolDiagnostics(getCatalogEntry(input.model.id).publicId, selection, recoveryCount, error.code, error.path);
+            const details = toolDiagnostics(getCatalogEntry(input.model.id).publicId, selection, replayDiagnostics, error.code, error.path);
             throw streamError("preflight", error.message, undefined, details);
         }
         if (error instanceof ContextSerializationError && error.message.startsWith("PI_TOOL_CAPABILITY_NOT_ENABLED") && selection) {
-            throw streamError("capability", error.message, undefined, toolDiagnostics(getCatalogEntry(input.model.id).publicId, selection, recoveryCount, "PI_TOOL_CAPABILITY_NOT_ENABLED"));
+            throw streamError("capability", error.message, undefined, toolDiagnostics(getCatalogEntry(input.model.id).publicId, selection, replayDiagnostics, "PI_TOOL_CAPABILITY_NOT_ENABLED"));
         }
         if (error instanceof SseFrameError || error instanceof ResponseSemanticError)
             throw streamError("response", "Antigravity returned an invalid stream.");
@@ -214,13 +215,31 @@ function validateInput(input) {
     if (!getCatalogEntry(input.model.id) || input.model.api !== API)
         throw streamError("response", "The selected Antigravity model or API is unsupported.");
 }
-function toolDiagnostics(publicModelId, selection, recoveryCount, preflight, preflightPath) {
+function toolDiagnostics(publicModelId, selection, replayDiagnostics, preflight, preflightPath) {
     return {
         publicModelId,
         reasoning: selection.level,
         capabilityState: selection.tools.state,
+        replayMode: replayDiagnostics.replayMode,
+        recoveryCount: replayDiagnostics.recoveryCount,
+        userMessageCount: replayDiagnostics.userMessageCount,
+        assistantMessageCount: replayDiagnostics.assistantMessageCount,
+        toolResultMessageCount: replayDiagnostics.toolResultMessageCount,
+        assistantToolCallBlockCount: replayDiagnostics.assistantToolCallBlockCount,
+        declaredToolCount: replayDiagnostics.declaredToolCount,
         preflight,
-        ...(preflight === "accepted" ? { recoveryCount } : { preflightCategory: preflightCategory(preflight), ...(preflightPath ? { preflightPath } : {}) }),
+        ...(preflight === "accepted" ? {} : { preflightCategory: preflightCategory(preflight), ...(preflightPath ? { preflightPath } : {}) }),
+    };
+}
+function emptyReplayDiagnostics() {
+    return {
+        replayMode: "none",
+        recoveryCount: 0,
+        userMessageCount: 0,
+        assistantMessageCount: 0,
+        toolResultMessageCount: 0,
+        assistantToolCallBlockCount: 0,
+        declaredToolCount: 0,
     };
 }
 function preflightCategory(code) {
@@ -236,9 +255,9 @@ function preflightCategory(code) {
 }
 function responsePolicy(payload, selection) {
     const declarations = payload.request.tools?.[0]?.functionDeclarations;
-    if (selection.tools.state !== "enabled" || payload.request.toolConfig?.functionCallingConfig.mode !== "AUTO" || !Array.isArray(declarations))
+    if (selection.tools.state !== "enabled" || payload.request.toolConfig?.functionCallingConfig.mode === "NONE" || !Array.isArray(declarations))
         return { kind: "reject" };
-    const names = declarations.map((item) => typeof item === "object" && item !== null ? Object.getOwnPropertyDescriptor(item, "name")?.value : undefined);
+    const names = declarations.map((declaration) => Object.getOwnPropertyDescriptor(declaration, "name")?.value);
     return names.every((name) => typeof name === "string") ? { kind: "accept", declaredNames: new Set(names) } : { kind: "reject" };
 }
 async function payloadHook(input, payload, signal) {
@@ -364,6 +383,18 @@ function isSse(value) { return value?.split(";", 1)[0]?.trim().toLowerCase() ===
 function inactivityTimeout(input) {
     return input.inactivityTimeoutMs === undefined ? INACTIVITY_TIMEOUT_MS : input.inactivityTimeoutMs > 0 && Number.isFinite(input.inactivityTimeoutMs) ? Math.min(input.inactivityTimeoutMs, INACTIVITY_TIMEOUT_MS) : 0;
 }
+function diagnosticFailure(error) {
+    if (!isStreamErrorKind(error.kind))
+        return undefined;
+    const status = error.status;
+    return {
+        kind: error.kind,
+        ...(typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 ? { status } : {}),
+    };
+}
+function isStreamErrorKind(value) {
+    return value === "aborted" || value === "access" || value === "capability" || value === "model" || value === "quota" || value === "preflight" || value === "response" || value === "transport" || value === "callback";
+}
 function streamError(kind, message, status, details) {
     const error = new StreamTransportError(kind, message, status, details);
     LOCAL_ERRORS.add(error);

package/dist/tool-context.d.ts

@@ -4,11 +4,26 @@ export interface PreparedToolContext {
     readonly mode: "AUTO" | "NONE";
 }
 export declare function hasToolContext(context: unknown): boolean;
-export declare function prepareToolContext(tools: unknown, choice: unknown): PreparedToolContext | undefined;
+export declare function prepareToolContext(tools: unknown, choice: unknown, schemaProfile: unknown): PreparedToolContext | undefined;
 type WirePart = object;
 type WireContent = {
     role: "user" | "model";
     parts: WirePart[];
 };
-export declare function replayToolHistory(messages: unknown[], serializePart: (part: Record<string, unknown>, message: Record<string, unknown>) => WirePart, onRecovery?: (recoveryCount: number) => void): WireContent[];
+export type ToolReplayMode = "none" | "signed-function-response" | "unsigned-observation";
+export interface ToolReplayDiagnostics {
+    readonly replayMode: ToolReplayMode;
+    readonly recoveryCount: number;
+    readonly userMessageCount: number;
+    readonly assistantMessageCount: number;
+    readonly toolResultMessageCount: number;
+    readonly assistantToolCallBlockCount: number;
+    readonly declaredToolCount: number;
+}
+export interface ToolReplayPolicy {
+    readonly requireSignedToolCalls: boolean;
+    readonly isSameModel: (message: Record<string, unknown>) => boolean;
+    readonly toolCallSignature: (part: Record<string, unknown>, message: Record<string, unknown>) => string | undefined;
+}
+export declare function replayToolHistory(messages: unknown[], serializePart: (part: Record<string, unknown>, message: Record<string, unknown>) => WirePart, onDiagnostics?: (diagnostics: ToolReplayDiagnostics) => void, policy?: ToolReplayPolicy, declaredToolCount?: number): WireContent[];
 export {};

package/dist/tool-context.js

@@ -1,4 +1,5 @@
 import { canonicalJson, ToolPreflightError } from "./tool-contract.js";
+import { GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE } from "./catalog.js";
 import { normalizeToolDeclarations } from "./tool-schema.js";
 export function hasToolContext(context) {
     if (!isRecord(context))
@@ -16,7 +17,9 @@ export function hasToolContext(context) {
         return Array.isArray(content) && content.some((part) => isRecord(part) && value(part, "type") === "toolCall");
     });
 }
-export function prepareToolContext(tools, choice) {
+export function prepareToolContext(tools, choice, schemaProfile) {
+    if (schemaProfile !== GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE)
+        throw new ToolPreflightError("PI_TOOL_SCHEMA_PROFILE_UNSUPPORTED", "tools", "$");
     const declarations = normalizeToolDeclarations(tools ?? []);
     if (!declarations.length) {
         if (choice === "auto")
@@ -29,27 +32,45 @@ export function prepareToolContext(tools, choice) {
         unsupportedChoice();
     return { declarations, mode: choice === "none" ? "NONE" : "AUTO" };
 }
-export function replayToolHistory(messages, serializePart, onRecovery) {
+export function replayToolHistory(messages, serializePart, onDiagnostics, policy, declaredToolCount = 0) {
     const output = [];
     const calls = new Set();
     const results = new Set();
     const recoveryCount = { value: 0 };
+    const shape = {
+        userMessageCount: 0,
+        assistantMessageCount: 0,
+        toolResultMessageCount: 0,
+        assistantToolCallBlockCount: 0,
+        declaredToolCount: safeCount(declaredToolCount),
+    };
+    let replayMode = "none";
     let pending;
+    const appendTurn = (role, parts) => {
+        if (!parts.length)
+            return;
+        const last = output.at(-1);
+        if (last?.role === role)
+            last.parts.push(...parts);
+        else
+            output.push({ role, parts });
+    };
     const finalize = () => {
         if (!pending)
             return;
-        output.push({ role: "user", parts: pending.calls.map((call) => {
-                const actual = pending.results.get(call.id);
-                if (actual)
-                    return actual;
-                recoveryCount.value += 1;
-                return missingResult(call);
-            }) });
+        appendTurn("user", pending.calls.map((call) => {
+            const actual = pending.results.get(call.id);
+            if (actual)
+                return actual;
+            recoveryCount.value += 1;
+            return pending.observations ? observation(call, missingResultText()) : missingResult(call);
+        }));
         pending = undefined;
     };
     for (const message of messages) {
         const current = record(message);
         if (value(current, "role") === "toolResult") {
+            shape.toolResultMessageCount += 1;
             const id = nonempty(value(current, "toolCallId"), "PI_TOOL_RESULT_FOREIGN");
             if (results.has(id))
                 history("PI_TOOL_RESULT_DUPLICATE");
@@ -68,8 +89,8 @@ export function replayToolHistory(messages, serializePart, onRecovery) {
                     history("PI_TOOL_RESULT_MEDIA_UNSUPPORTED");
                 return value(part, "text");
             }).join("\n\n");
-            const response = value(current, "isError") === true ? { error: text } : { result: text };
-            pending.results.set(id, { functionResponse: { name: call.name, id, response } });
+            const response = value(current, "isError") === true ? { error: text } : { output: text };
+            pending.results.set(id, pending.observations ? observation(call, text) : { functionResponse: { name: call.name, response } });
             results.add(id);
             continue;
         }
@@ -77,53 +98,82 @@ export function replayToolHistory(messages, serializePart, onRecovery) {
         const role = value(current, "role");
         if (role !== "user" && role !== "assistant")
             history("PI_TOOL_CALL_INVALID");
+        if (role === "user")
+            shape.userMessageCount += 1;
+        else
+            shape.assistantMessageCount += 1;
         const rawContent = value(current, "content");
         if (typeof rawContent === "string") {
             if (!rawContent)
                 history("PI_TOOL_CALL_INVALID");
-            output.push({ role: role === "assistant" ? "model" : "user", parts: [{ text: rawContent }] });
+            appendTurn(role === "assistant" ? "model" : "user", [{ text: rawContent }]);
             continue;
         }
         const content = dense(rawContent);
         const hasCalls = role === "assistant" && content.some((part) => value(record(part), "type") === "toolCall");
         if (!hasCalls) {
-            output.push({ role: role === "assistant" ? "model" : "user", parts: content.map((part) => serializePart(record(part), current)) });
+            appendTurn(role === "assistant" ? "model" : "user", content.map((part) => serializePart(record(part), current)));
             continue;
         }
         if (value(current, "stopReason") !== "toolUse")
             history("PI_TOOL_CALL_INVALID");
         const group = [];
-        const parts = content.map((item) => {
+        const parts = content.flatMap((item) => {
             const part = record(item);
-            if (value(part, "type") !== "toolCall")
-                return serializePart(part, current);
+            if (value(part, "type") !== "toolCall") {
+                if (isEmptyUnsignedText(part))
+                    return [];
+                return [serializePart(part, current)];
+            }
+            shape.assistantToolCallBlockCount += 1;
             const id = nonempty(value(part, "id"), "PI_TOOL_CALL_INVALID");
             const name = nonempty(value(part, "name"), "PI_TOOL_CALL_INVALID");
             if (!/^[A-Za-z_][A-Za-z0-9_.:-]*$/.test(name) || calls.has(id))
                 history(calls.has(id) ? "PI_TOOL_CALL_DUPLICATE" : "PI_TOOL_CALL_INVALID");
             const args = canonicalJson(value(part, "arguments"), name, "$.arguments");
-            if (Array.isArray(args) || args === null)
+            if (typeof args !== "object" || Array.isArray(args) || args === null)
                 history("PI_TOOL_CALL_INVALID");
             calls.add(id);
-            group.push({ id, name });
-            return { functionCall: { name, args, id } };
+            const call = { id, name, args };
+            group.push(call);
+            return [{ call, signature: policy?.toolCallSignature(part, current), signaturePresent: value(part, "thoughtSignature") !== undefined }];
         });
-        output.push({ role: "model", parts });
-        pending = { calls: group, results: new Map() };
+        const toolParts = parts.filter((part) => "call" in part);
+        const callsAreSigned = policy?.requireSignedToolCalls === true && policy.isSameModel(current) && Boolean(toolParts[0]?.signature) && toolParts.every((part) => !part.signaturePresent || Boolean(part.signature));
+        const observations = policy?.requireSignedToolCalls === true && !callsAreSigned;
+        if (observations)
+            replayMode = "unsigned-observation";
+        else if (replayMode === "none" && callsAreSigned)
+            replayMode = "signed-function-response";
+        appendTurn("model", parts.flatMap((part) => {
+            if (!("call" in part))
+                return [part];
+            if (observations)
+                return [];
+            return [{ functionCall: { name: part.call.name, args: part.call.args }, ...(part.signature ? { thoughtSignature: part.signature } : {}) }];
+        }));
+        pending = { calls: group, results: new Map(), observations };
     }
     finalize();
-    onRecovery?.(recoveryCount.value);
+    onDiagnostics?.({ replayMode, recoveryCount: recoveryCount.value, ...shape });
     return output;
 }
+function observation(call, text) {
+    const args = JSON.stringify(call.args);
+    const label = args === "{}" ? `\`${call.name}\`` : `\`${call.name}\` (${args})`;
+    return { text: `[Observation from ${label}:\n${text}]` };
+}
+function missingResultText() {
+    return "Tool execution did not complete or its result was not recorded. Treat the call as failed; do not assume it had no side effects and do not retry it automatically.";
+}
 function missingResult(call) {
     return {
         functionResponse: {
             name: call.name,
-            id: call.id,
             response: {
                 error: {
                     code: "PI_TOOL_RESULT_MISSING",
-                    message: "Tool execution did not complete or its result was not recorded. Treat the call as failed; do not assume it had no side effects and do not retry it automatically.",
+                    message: missingResultText(),
                 },
             },
         },
@@ -142,11 +192,18 @@ function dense(value) {
         history("PI_TOOL_CALL_INVALID");
     return value;
 }
+function isEmptyUnsignedText(part) {
+    const text = value(part, "text");
+    return value(part, "type") === "text" && typeof text === "string" && !text.trim() && value(part, "textSignature") === undefined;
+}
 function nonempty(value, code) {
     if (typeof value !== "string" || !value.trim())
         history(code);
     return value;
 }
+function safeCount(value) {
+    return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
 function unsupportedChoice() {
     throw new ToolPreflightError("PI_TOOL_CHOICE_UNSUPPORTED", "tools", "$");
 }

package/dist/tool-schema.js

@@ -1,10 +1,12 @@
-import { canonicalJson, denseArray, fail, freeze, ownData, plainObject } from "./tool-contract.js";
-const TYPES = new Set(["object", "array", "string", "number", "integer", "boolean"]);
-const KEYWORDS = new Set(["type", "description", "nullable", "enum", "const", "properties", "required", "items"]);
+import { denseArray, fail, freeze, ownData, plainObject } from "./tool-contract.js";
 const MAX_SCHEMA_DEPTH = 32;
 const MAX_SCHEMA_NODES = 2048;
 const MAX_SCHEMA_BYTES = 256 * 1024;
 const MAX_TOTAL_SCHEMA_BYTES = 1024 * 1024;
+const METADATA = new Set(["$schema", "$id", "$anchor", "$dynamicAnchor", "$vocabulary", "$comment"]);
+const SCHEMA_MAPS = new Set(["properties", "patternProperties", "dependentSchemas"]);
+const SCHEMAS = new Set(["additionalItems", "additionalProperties", "contains", "contentSchema", "else", "if", "items", "not", "propertyNames", "then", "unevaluatedItems", "unevaluatedProperties"]);
+const SCHEMA_ARRAYS = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
 export function normalizeToolDeclarations(value) {
     const tools = denseArray(value, "tools", "$");
     const names = new Set();
@@ -32,94 +34,179 @@ function normalizeDeclaration(value, index, names) {
     const constrainedSampling = ownData(tool, "constrainedSampling", name, path);
     if (constrainedSampling !== undefined && constrainedSampling !== false)
         fail("PI_TOOL_CONSTRAINED_SAMPLING_UNSUPPORTED", name, `${path}.constrainedSampling`);
-    const parameterRoot = plainObject(ownData(tool, "parameters", name, path), name, "$");
-    if (ownData(parameterRoot, "type", name, "$") !== "object")
+    const root = plainObject(ownData(tool, "parameters", name, path), name, "$");
+    if (ownData(root, "type", name, "$") !== "object")
+        fail("PI_TOOL_SCHEMA_INVALID", name, "$.type");
+    const snapshot = snapshotJson(root, name, "$", { ancestors: new Set(), nodes: 0 });
+    if (!isJsonObject(snapshot))
+        fail("PI_TOOL_SCHEMA_INVALID", name, "$");
+    const parameters = emitSchema(snapshot, snapshot, name, "$", { nodes: 0 }, new Set());
+    if (!isJsonObject(parameters) || parameters.type !== "object")
         fail("PI_TOOL_SCHEMA_INVALID", name, "$.type");
-    const parameters = normalizeSchema(parameterRoot, name, "$");
     if (Buffer.byteLength(JSON.stringify(parameters), "utf8") > MAX_SCHEMA_BYTES)
         fail("PI_TOOL_SCHEMA_LIMIT", name, "$");
     return freeze({ name, description, parameters });
 }
-function normalizeSchema(value, declaration, path, state = { ancestors: new Set(), nodes: 0 }, depth = 0) {
+function snapshotJson(value, declaration, path, state, depth = 0) {
     if (depth > MAX_SCHEMA_DEPTH || ++state.nodes > MAX_SCHEMA_NODES)
         fail("PI_TOOL_SCHEMA_LIMIT", declaration, path);
-    if (typeof value === "object" && value !== null) {
-        if (state.ancestors.has(value))
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-        state.ancestors.add(value);
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    if (typeof value !== "object" || state.ancestors.has(value))
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    state.ancestors.add(value);
+    try {
+        if (Array.isArray(value))
+            return freeze(snapshotArray(value, declaration, path, state, depth));
+        const object = plainObject(value, declaration, path);
+        const output = {};
+        for (const key of Object.keys(object).sort())
+            define(output, key, snapshotJson(ownData(object, key, declaration, path), declaration, pathSegment(path, key), state, depth + 1));
+        return freeze(output);
     }
-    const schema = plainObject(value, declaration, path);
-    for (const key of Object.keys(schema))
-        if (!KEYWORDS.has(key))
-            fail("PI_TOOL_SCHEMA_UNSUPPORTED", declaration, `${path}.${key}`);
-    const type = ownData(schema, "type", declaration, path);
-    if (typeof type !== "string" || !TYPES.has(type))
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.type`);
-    const output = { type };
-    const description = ownData(schema, "description", declaration, path);
-    if (description !== undefined) {
-        if (typeof description !== "string")
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.description`);
-        output.description = description;
+    finally {
+        state.ancestors.delete(value);
     }
-    const nullable = ownData(schema, "nullable", declaration, path);
-    if (nullable !== undefined) {
-        if (typeof nullable !== "boolean")
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.nullable`);
-        output.nullable = nullable;
+}
+function snapshotArray(value, declaration, path, state, depth) {
+    if (Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length || Object.getOwnPropertyNames(value).length !== value.length + 1)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    const values = denseArray(value, declaration, path);
+    const output = [];
+    for (let index = 0; index < values.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !("value" in descriptor))
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}[${index}]`);
+        output.push(snapshotJson(descriptor.value, declaration, `${path}[${index}]`, state, depth + 1));
     }
-    const enumValue = ownData(schema, "enum", declaration, path);
-    const constant = ownData(schema, "const", declaration, path);
-    if (enumValue !== undefined && constant !== undefined)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.const`);
-    if (enumValue !== undefined)
-        output.enum = normalizeEnum(enumValue, type, nullable === true, declaration, `${path}.enum`);
-    if (constant !== undefined)
-        output.enum = freeze([validateEnumValue(constant, type, nullable === true, declaration, `${path}.const`)]);
-    if (type === "object")
-        normalizeObject(schema, output, declaration, path, state, depth);
-    else if (type === "array")
-        normalizeArray(schema, output, declaration, path, state, depth);
-    else if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined || ownData(schema, "items", declaration, path) !== undefined)
+    return output;
+}
+function emitSchema(value, root, declaration, path, state, targets, depth = 0) {
+    if (depth > MAX_SCHEMA_DEPTH || ++state.nodes > MAX_SCHEMA_NODES)
+        fail("PI_TOOL_SCHEMA_LIMIT", declaration, path);
+    if (typeof value === "boolean")
+        return value;
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return freeze(output);
+    const reference = value.$ref;
+    if (reference !== undefined) {
+        const referencePath = pathSegment(path, "$ref");
+        const target = resolveReference(reference, root, declaration, referencePath);
+        if (isJsonObject(target) && targets.has(target))
+            fail("PI_TOOL_SCHEMA_REFERENCE_CYCLE", declaration, referencePath);
+        const next = new Set(targets);
+        if (isJsonObject(target))
+            next.add(target);
+        const resolved = emitSchema(target, root, declaration, path, state, next, depth + 1);
+        const sibling = emitObject(value, root, declaration, path, state, targets, depth + 1, new Set(["$ref"]));
+        if (!Object.keys(sibling).length)
+            return resolved;
+        if (resolved === true || resolved === false)
+            return resolved === true ? sibling : false;
+        return freeze({ allOf: freeze([resolved, sibling]) });
+    }
+    return emitObject(value, root, declaration, path, state, targets, depth, new Set());
 }
-function normalizeObject(schema, output, declaration, path, state, depth) {
-    if (ownData(schema, "items", declaration, path) !== undefined)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.items`);
-    const properties = plainObject(ownData(schema, "properties", declaration, path), declaration, `${path}.properties`);
-    const names = Object.keys(properties).sort();
-    if (!names.length)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.properties`);
-    const normalized = {};
-    for (const name of names)
-        normalized[name] = normalizeSchema(properties[name], declaration, `${path}.properties.${name}`, state, depth + 1);
-    output.properties = freeze(normalized);
-    const required = ownData(schema, "required", declaration, path);
-    if (required !== undefined) {
-        const values = denseArray(required, declaration, `${path}.required`);
-        if (values.some((name) => typeof name !== "string" || !Object.hasOwn(properties, name)) || new Set(values).size !== values.length)
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.required`);
-        output.required = freeze([...values].sort());
+function emitObject(value, root, declaration, path, state, targets, depth, omitted) {
+    const output = {};
+    for (const key of Object.keys(value)) {
+        const child = value[key];
+        if (omitted.has(key) || METADATA.has(key))
+            continue;
+        if (key === "$defs" || key === "definitions") {
+            emitSchemaMap(child, root, declaration, pathSegment(path, key), state, targets, depth + 1);
+            continue;
+        }
+        if (SCHEMA_MAPS.has(key))
+            define(output, key, emitSchemaMap(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (SCHEMA_ARRAYS.has(key))
+            define(output, key, emitSchemaArray(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (key === "dependencies")
+            define(output, key, emitDependencies(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (key === "items" && Array.isArray(child))
+            define(output, key, emitSchemaArray(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (SCHEMAS.has(key))
+            define(output, key, emitSchema(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else
+            define(output, key, child);
     }
+    return freeze(output);
 }
-function normalizeArray(schema, output, declaration, path, state, depth) {
-    if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined)
+function emitSchemaMap(value, root, declaration, path, state, targets, depth) {
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    output.items = normalizeSchema(ownData(schema, "items", declaration, path), declaration, `${path}.items`, state, depth + 1);
+    const output = {};
+    for (const key of Object.keys(value))
+        define(output, key, emitSchema(value[key], root, declaration, pathSegment(path, key), state, targets, depth));
+    return freeze(output);
 }
-function normalizeEnum(value, type, nullable, declaration, path) {
-    const values = denseArray(value, declaration, path);
-    if (!values.length)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    const normalized = values.map((item, index) => validateEnumValue(item, type, nullable, declaration, `${path}[${index}]`));
-    if (new Set(normalized.map((item) => JSON.stringify(item))).size !== normalized.length)
+function emitSchemaArray(value, root, declaration, path, state, targets, depth) {
+    if (!Array.isArray(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return freeze(normalized);
+    return freeze(value.map((item, index) => emitSchema(item, root, declaration, `${path}[${index}]`, state, targets, depth)));
 }
-function validateEnumValue(value, type, nullable, declaration, path) {
-    const json = canonicalJson(value, declaration, path);
-    if (typeof json === "object" || (json === null && !nullable) || (json !== null && (type === "integer" ? typeof json !== "number" || !Number.isInteger(json) : typeof json !== type)))
+function emitDependencies(value, root, declaration, path, state, targets, depth) {
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return json;
+    const output = {};
+    for (const key of Object.keys(value)) {
+        const dependency = value[key];
+        if (Array.isArray(dependency) && dependency.every((entry) => typeof entry === "string"))
+            define(output, key, dependency);
+        else
+            define(output, key, emitSchema(dependency, root, declaration, pathSegment(path, key), state, targets, depth));
+    }
+    return freeze(output);
+}
+function resolveReference(reference, root, declaration, path) {
+    if (typeof reference !== "string" || (reference !== "#" && !reference.startsWith("#/")))
+        fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    if (reference === "#")
+        return root;
+    let pointer;
+    try {
+        pointer = decodeURIComponent(reference.slice(1));
+    }
+    catch {
+        return fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    }
+    let current = root;
+    for (const rawToken of pointer.slice(1).split("/")) {
+        const token = decodeToken(rawToken, declaration, path);
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9][0-9]*)$/.test(token) || !Number.isSafeInteger(Number(token)) || Number(token) >= current.length)
+                fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+            current = current[Number(token)];
+        }
+        else if (isJsonObject(current)) {
+            if (!Object.hasOwn(current, token))
+                fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+            current = current[token];
+        }
+        else
+            fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    }
+    if (typeof current !== "boolean" && !isJsonObject(current))
+        fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    return current;
+}
+function decodeToken(value, declaration, path) {
+    return value.replace(/~(.)?/g, (escape, next) => {
+        if (escape === "~0")
+            return "~";
+        if (escape === "~1")
+            return "/";
+        return fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    });
+}
+function pathSegment(path, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function define(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: true, configurable: false, writable: false });
 }

package/package.json

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