@benjamolina/pi-antigravity-guard 0.4.0 → 0.4.1

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,7 +28,11 @@ 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
 
@@ -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.js

@@ -8,7 +8,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" }) },
             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,6 +109,9 @@ const lookup = new Map(CATALOG.map((entry) => [entry.publicId, entry]));
 function disabled(reason) {
     return { state: "disabled", contractRevision: 1, reason };
 }
+function enabled(evidence) {
+    return { state: "enabled", contractRevision: 1, 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 });

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);
@@ -24,12 +24,21 @@ export function serializeContext(input, injectedSelection, onRecovery) {
     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

@@ -10,5 +10,20 @@ 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

@@ -29,27 +29,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 +86,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 +95,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 +189,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/package.json

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