@benjamolina/pi-antigravity-guard 0.3.0 → 0.4.1

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;
 }

package/dist/response.js

@@ -1,10 +1,18 @@
+import { canonicalJson } from "./tool-contract.js";
 export class ResponseSemanticError extends Error {
 }
 export class ResponseSemantics {
+    policy;
     finished = false;
-    content = false;
     done = false;
+    content = false;
+    calls = 0;
+    ids = new Set();
+    pendingFinish;
     usage = { prompt: 0, cacheRead: 0, output: 0, reasoning: 0 };
+    constructor(policy = { kind: "reject" }) {
+        this.policy = policy;
+    }
     push(record) {
         if (this.done)
             throw new ResponseSemanticError("Response data arrived after [DONE].");
@@ -37,9 +45,8 @@ export class ResponseSemantics {
             throw new ResponseSemanticError("Response ended without a finish reason.");
         if (!this.content)
             throw new ResponseSemanticError("Response ended without content.");
+        return { type: "finish", reason: this.pendingFinish };
     }
-    addContent(text) { this.content = this.content || text.length > 0; }
-    addFinish() { this.finished = true; }
     updateUsage(value) {
         const prompt = count(value, "promptTokenCount", this.usage.prompt);
         const cacheRead = count(value, "cachedContentTokenCount", this.usage.cacheRead);
@@ -52,74 +59,135 @@ export class ResponseSemantics {
         this.usage = { prompt, cacheRead, output, reasoning };
         return { type: "usage", input: prompt - cacheRead, output, cacheRead, cacheWrite: 0, reasoning, total: prompt + output };
     }
+    addContent(text) { this.content = this.content || text.length > 0; }
+    addCall() { this.content = true; this.calls++; }
+    setFinish(reason) { this.finished = true; this.pendingFinish = reason; }
+    hasId(id) { return this.ids.has(id); }
+    addId(id) { this.ids.add(id); }
+    callIndex() { return this.calls; }
 }
 function candidate(value, events, semantics) {
     if (!Array.isArray(value) || value.length !== 1)
         throw new ResponseSemanticError("Antigravity returned invalid candidates.");
-    const candidate = value[0];
-    if (candidate === undefined)
+    const item = value[0];
+    if (item === undefined)
         return;
-    const index = field(candidate, "index");
+    const index = field(item, "index");
     if (index !== undefined && index !== 0)
         throw new ResponseSemanticError("Antigravity returned invalid candidates.");
-    const content = field(candidate, "content");
+    const content = field(item, "content");
+    const local = [];
+    const ids = [];
+    let callCount = 0;
     if (content !== undefined) {
         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) {
-            const text = field(part, "text");
-            const thought = field(part, "thought");
-            if (typeof text !== "string" || (thought !== undefined && typeof thought !== "boolean") || Object.keys(part).some((name) => name !== "text" && name !== "thought" && name !== "thoughtSignature"))
-                throw new ResponseSemanticError("Antigravity returned unsupported content.");
-            const signature = validThoughtSignature(field(part, "thoughtSignature"));
-            semantics.addContent(text);
-            if (thought === true)
-                events.push({ type: "thinking", thinking: text, ...(signature ? { signature } : {}) });
-            else
-                events.push({ type: "text", text, ...(signature ? { signature } : {}) });
+            if (field(part, "functionCall") !== undefined) {
+                const call = toolCall(part, semantics, ids, explicitIds, callCount++);
+                ids.push(call.id);
+                local.push(call);
+            }
+            else {
+                const text = field(part, "text");
+                const thought = field(part, "thought");
+                if (typeof text !== "string" || (thought !== undefined && typeof thought !== "boolean") || keys(part, ["text", "thought", "thoughtSignature"]))
+                    throw new ResponseSemanticError("Antigravity returned unsupported content.");
+                const signature = validThoughtSignature(field(part, "thoughtSignature"));
+                local.push(thought === true ? { type: "thinking", thinking: text, ...(signature ? { signature } : {}) } : { type: "text", text, ...(signature ? { signature } : {}) });
+            }
         }
     }
-    const finishReason = field(candidate, "finishReason");
+    const finishReason = field(item, "finishReason");
     if (finishReason !== undefined) {
-        if (finishReason !== "STOP" && finishReason !== "MAX_TOKENS")
+        const hasCalls = semantics.callIndex() + callCount > 0;
+        const reason = hasCalls ? "toolUse" : finishReason === "STOP" ? "stop" : finishReason === "MAX_TOKENS" ? "length" : undefined;
+        if (!reason)
             throw new ResponseSemanticError("Antigravity returned an unsupported finish reason.");
-        semantics.addFinish();
-        events.push({ type: "finish", reason: finishReason === "STOP" ? "stop" : "length" });
+        semantics.setFinish(reason);
     }
-}
-function validThoughtSignature(value) {
-    if (typeof value !== "string" || !value || value.length % 4 !== 0)
-        return undefined;
-    return /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? value : undefined;
-}
-function validateMetadata(value) {
-    for (const name of ["responseId", "modelVersion"]) {
-        const metadata = field(value, name);
-        if (metadata !== undefined && (typeof metadata !== "string" || !metadata))
-            throw new ResponseSemanticError("Antigravity returned invalid metadata.");
+    for (const id of ids)
+        semantics.addId(id);
+    for (const event of local) {
+        if (event.type === "text")
+            semantics.addContent(event.text);
+        else if (event.type === "thinking")
+            semantics.addContent(event.thinking);
+        else
+            semantics.addCall();
+        events.push(event);
     }
 }
-function count(value, name, fallback) {
-    const valueAtName = field(value, name);
-    if (valueAtName === undefined)
-        return fallback;
-    if (typeof valueAtName !== "number" || !Number.isSafeInteger(valueAtName) || valueAtName < 0)
-        throw new ResponseSemanticError("Antigravity returned invalid usage.");
-    return valueAtName;
-}
-function parse(record) {
+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 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))
+        throw new ResponseSemanticError("Antigravity returned invalid function call.");
+    let argumentsValue;
     try {
-        return JSON.parse(record);
+        const canonical = canonicalJson(args, name, "$");
+        if (Array.isArray(canonical) || canonical === null)
+            throw new Error();
+        argumentsValue = canonical;
     }
     catch {
-        throw new ResponseSemanticError("Antigravity returned invalid JSON.");
+        throw new ResponseSemanticError("Antigravity returned invalid function call.");
     }
+    const argumentsJson = JSON.stringify(argumentsValue);
+    if (new TextEncoder().encode(argumentsJson).byteLength > 1024 * 1024 || depth(argumentsValue) > 64)
+        throw new ResponseSemanticError("Antigravity returned invalid function call.");
+    const signature = validThoughtSignature(field(part, "thoughtSignature"));
+    return { type: "toolCall", callIndex: semantics.callIndex() + offset, id, name, arguments: argumentsValue, argumentsJson, ...(signature ? { signature } : {}) };
 }
-function hasError(value) { return field(value, "error") !== undefined; }
-function field(value, name) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new ResponseSemanticError("Antigravity returned an invalid response.");
-    const descriptor = Object.getOwnPropertyDescriptor(value, name);
-    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+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))
+        maximum = Math.max(maximum, depthValue(item, level + 1));
+    return maximum;
+}
+function depthValue(value, level) { return value && typeof value === "object" ? depth(value, level) : level; }
+function keys(value, allowed) { return typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).some((name) => !allowed.includes(name)); }
+function validThoughtSignature(value) { return typeof value === "string" && value && value.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? value : undefined; }
+function validateMetadata(value) { for (const name of ["responseId", "modelVersion"]) {
+    const metadata = field(value, name);
+    if (metadata !== undefined && (typeof metadata !== "string" || !metadata))
+        throw new ResponseSemanticError("Antigravity returned invalid metadata.");
+} }
+function count(value, name, fallback) { const item = field(value, name); if (item === undefined)
+    return fallback; if (typeof item !== "number" || !Number.isSafeInteger(item) || item < 0)
+    throw new ResponseSemanticError("Antigravity returned invalid usage."); return item; }
+function parse(record) { try {
+    return JSON.parse(record);
+}
+catch {
+    throw new ResponseSemanticError("Antigravity returned invalid JSON.");
+} }
+function hasError(value) { return field(value, "error") !== undefined; }
+function field(value, name) { if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new ResponseSemanticError("Antigravity returned an invalid response."); const descriptor = Object.getOwnPropertyDescriptor(value, name); return descriptor && "value" in descriptor ? descriptor.value : undefined; }

package/dist/stream.d.ts

@@ -1,10 +1,37 @@
 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" | "model" | "quota" | "response" | "transport" | "callback";
+type StreamErrorKind = "aborted" | "access" | "capability" | "model" | "quota" | "preflight" | "response" | "transport" | "callback";
+export interface ToolStreamDiagnostics {
+    readonly publicModelId: string;
+    readonly reasoning: string;
+    readonly capabilityState: string;
+    readonly preflight?: "accepted" | string;
+    readonly preflightCategory?: string;
+    readonly preflightPath?: string;
+    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";
+    details: ToolStreamDiagnostics;
+};
+type StreamSemantic = ResponseSemantic | ToolDiagnosticSemantic;
 export declare class StreamTransportError extends Error {
     readonly kind: StreamErrorKind;
     readonly status?: number | undefined;
-    constructor(kind: StreamErrorKind, message: string, status?: number | undefined);
+    readonly details?: ToolStreamDiagnostics | undefined;
+    constructor(kind: StreamErrorKind, message: string, status?: number | undefined, details?: ToolStreamDiagnostics | undefined);
 }
 export interface StreamTransportInput {
     accessToken: string;
@@ -16,9 +43,10 @@ export interface StreamTransportInput {
     model: Model<string>;
     projectId: string;
     now: () => number;
-    onSemantic: (semantic: ResponseSemantic) => void | Promise<void>;
+    onSemantic: (semantic: StreamSemantic) => void | Promise<void>;
     platform: string;
     requestId: string;
+    selection?: GenerationSelection;
     signal?: AbortSignal;
     timeoutMs?: number;
 }
@@ -27,7 +55,7 @@ export interface PiStreamLifecycleInput {
     now: () => number;
     signal?: AbortSignal;
     runTransport: (input: {
-        onSemantic: (semantic: ResponseSemantic) => void;
+        onSemantic: (semantic: StreamSemantic) => void;
         signal: AbortSignal;
     }) => Promise<void>;
 }

package/dist/stream.js

@@ -1,7 +1,9 @@
 import { calculateCost, createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 import { ANTIGRAVITY_ENDPOINTS } from "@benjamolina/antigravity-guard-core";
-import { getCatalogEntry } from "./catalog.js";
-import { serializeTextContext } from "./context.js";
+import { getCatalogEntry, resolveGenerationSelection } from "./catalog.js";
+import { ContextSerializationError, serializeContext } from "./context.js";
+import { ToolPreflightError } from "./tool-contract.js";
+import { hasToolContext } from "./tool-context.js";
 import { ResponseSemanticError, ResponseSemantics } from "./response.js";
 import { SseFrameError, SseFramer } from "./sse.js";
 const TOTAL_TIMEOUT_MS = 120_000;
@@ -15,10 +17,12 @@ const LOCAL_ERRORS = new WeakSet();
 export class StreamTransportError extends Error {
     kind;
     status;
-    constructor(kind, message, status) {
+    details;
+    constructor(kind, message, status, details) {
         super(message);
         this.kind = kind;
         this.status = status;
+        this.details = details;
     }
 }
 export function createPiLifecycleStream(input) {
@@ -36,6 +40,8 @@ export function createPiLifecycleStream(input) {
         timestamp: input.now(),
     };
     let complete = false;
+    let sawToolCall = false;
+    let toolDiagnostics;
     let textStarted = false;
     let currentBlock;
     const closeBlock = () => {
@@ -49,15 +55,24 @@ export function createPiLifecycleStream(input) {
         currentBlock = undefined;
     };
     let removeAbort = () => { };
-    const finalize = (reason, errorMessage) => {
+    const finalize = (reason, errorMessage, details, error) => {
         if (complete)
             return;
         complete = true;
         removeAbort();
-        if (reason === "error" || reason === "aborted")
+        if (reason === "error" || reason === "aborted") {
             controller.abort();
+            for (let index = output.content.length - 1; index >= 0; index--) {
+                if (output.content[index]?.type === "toolCall")
+                    output.content.splice(index, 1);
+            }
+        }
         output.stopReason = reason;
-        if (reason === "stop" || reason === "length") {
+        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, ...(failure ? { failure } : {}), terminal: reason } }];
+        if (reason === "stop" || reason === "length" || reason === "toolUse") {
             closeBlock();
             stream.push({ type: "done", reason, message: output });
         }
@@ -70,6 +85,21 @@ export function createPiLifecycleStream(input) {
     const onSemantic = (semantic) => {
         if (complete)
             return;
+        if (semantic.type === "toolDiagnostics") {
+            toolDiagnostics = semantic.details;
+            return;
+        }
+        if (semantic.type === "toolCall") {
+            sawToolCall = true;
+            closeBlock();
+            const toolCall = { type: "toolCall", id: semantic.id, name: semantic.name, arguments: semantic.arguments, ...(semantic.signature ? { thoughtSignature: semantic.signature } : {}) };
+            output.content.push(toolCall);
+            const contentIndex = output.content.length - 1;
+            stream.push({ type: "toolcall_start", contentIndex, partial: output });
+            stream.push({ type: "toolcall_delta", contentIndex, delta: semantic.argumentsJson, partial: output });
+            stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
+            return;
+        }
         if (isContentSemantic(semantic)) {
             if (!currentBlock || currentBlock.type !== semantic.type) {
                 closeBlock();
@@ -124,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)
@@ -132,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));
+            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) {
@@ -143,8 +173,14 @@ export async function executeStreamTransport(input) {
     const signal = totalSignal(input);
     const headers = requestHeaders(input);
     let responseBody = null;
+    let selection;
+    let replayDiagnostics = emptyReplayDiagnostics();
     try {
-        const original = serializeTextContext({ context: input.context, model: input.model, options: input.generationOptions, project: input.projectId, requestId: input.requestId });
+        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, (diagnostics) => { replayDiagnostics = diagnostics; });
+        if (hasToolContext(input.context))
+            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);
@@ -155,7 +191,7 @@ export async function executeStreamTransport(input) {
             await boundedBody(response.body, signal);
             throw streamError("response", "Antigravity did not return an SSE response.");
         }
-        await consume(response.body, signal, input.onSemantic, inactivityTimeout(input));
+        await consume(response.body, signal, input.onSemantic, inactivityTimeout(input), responsePolicy(original, selection));
     }
     catch (error) {
         void responseBody?.cancel().catch(() => undefined);
@@ -163,6 +199,13 @@ export async function executeStreamTransport(input) {
             throw error;
         if (signal.aborted)
             throw streamError("aborted", "Generation was cancelled.");
+        if (error instanceof ToolPreflightError && selection) {
+            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, replayDiagnostics, "PI_TOOL_CAPABILITY_NOT_ENABLED"));
+        }
         if (error instanceof SseFrameError || error instanceof ResponseSemanticError)
             throw streamError("response", "Antigravity returned an invalid stream.");
         throw streamError("transport", "Antigravity generation request failed.");
@@ -172,6 +215,51 @@ 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, 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" ? {} : { 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) {
+    if (code.includes("SCHEMA"))
+        return "schema";
+    if (code.includes("CHOICE"))
+        return "tool-choice";
+    if (code.includes("DECLARATION") || code.includes("CONSTRAINED"))
+        return "declaration";
+    if (code.includes("RESULT") || code.includes("CALL") || code.includes("HISTORY"))
+        return "history";
+    return "capability";
+}
+function responsePolicy(payload, selection) {
+    const declarations = payload.request.tools?.[0]?.functionDeclarations;
+    if (selection.tools.state !== "enabled" || payload.request.toolConfig?.functionCallingConfig.mode === "NONE" || !Array.isArray(declarations))
+        return { kind: "reject" };
+    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) {
     try {
         const replacement = await abortable(Promise.resolve().then(() => input.generationOptions?.onPayload?.(payload, input.model)), signal);
@@ -209,10 +297,10 @@ function requestHeaders(input) {
         "User-Agent": ANTIGRAVITY_USER_AGENT,
     };
 }
-async function consume(body, signal, onSemantic, inactivityMs) {
+async function consume(body, signal, onSemantic, inactivityMs, policy) {
     const reader = body.getReader();
     const framer = new SseFramer();
-    const semantics = new ResponseSemantics();
+    const semantics = new ResponseSemantics(policy);
     try {
         while (true) {
             const next = await abortable(reader.read(), AbortSignal.any([signal, AbortSignal.timeout(inactivityMs)]));
@@ -225,7 +313,7 @@ async function consume(body, signal, onSemantic, inactivityMs) {
         for (const record of framer.finish())
             for (const semantic of semantics.push(record))
                 await deliver(onSemantic, semantic);
-        semantics.finish();
+        await deliver(onSemantic, semantics.finish());
     }
     catch (error) {
         void reader.cancel().catch(() => undefined);
@@ -295,8 +383,20 @@ 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 streamError(kind, message, status) {
-    const error = new StreamTransportError(kind, message, status);
+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);
     return error;
 }

package/dist/tool-context.d.ts

@@ -0,0 +1,29 @@
+import { type ToolDeclaration } from "./tool-schema.ts";
+export interface PreparedToolContext {
+    readonly declarations: readonly ToolDeclaration[];
+    readonly mode: "AUTO" | "NONE";
+}
+export declare function hasToolContext(context: unknown): boolean;
+export declare function prepareToolContext(tools: unknown, choice: unknown): PreparedToolContext | undefined;
+type WirePart = object;
+type WireContent = {
+    role: "user" | "model";
+    parts: WirePart[];
+};
+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 {};