@benjamolina/pi-antigravity-guard 0.4.7 → 0.4.9

package/dist/context.d.ts

@@ -26,6 +26,7 @@ export interface GenerationRequest {
     request: {
         contents: Content[];
         systemInstruction?: {
+            role?: "user";
             parts: Part[];
         };
         tools?: {
@@ -47,6 +48,8 @@ export interface GenerationRequest {
                 includeThoughts: boolean;
             };
         };
+        sessionId?: string;
+        labels?: Record<string, string>;
     };
     requestType: "agent";
     userAgent: "antigravity";

package/dist/context.js

@@ -1,5 +1,6 @@
 import { CLAUDE_CUSTOM_PARAMETERS_PROFILE, getCatalogEntry, resolveGenerationSelection } from "./catalog.js";
 import { normalizeCustomToolSchema } from "./tool-schema.js";
+import { buildAntigravityEnvelope } from "./envelope.js";
 import { hasToolContext, prepareToolContext, replayToolHistory } from "./tool-context.js";
 const MAX_TEXT_BYTES = 8 * 1024 * 1024;
 const PROVIDER = "antigravity-guard";
@@ -26,13 +27,23 @@ export function serializeContext(input, injectedSelection, onDiagnostics) {
     const { toolChoice: _choice, ...textOptions } = isRecord(options) ? options : {};
     const text = serializeTextContext({ ...input, context: { ...textContext, messages: [{ role: "user", content: "placeholder", timestamp: 0 }] }, options: textOptions });
     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,
+    const requireSigned = geminiRequiresSignedToolReplay(selection.route.wireModel);
+    const includeToolCallId = entry.response.family === "claude" || entry.response.family === "gpt-oss";
+    const toolReplayPolicy = (requireSigned || includeToolCallId) ? {
+        requireSignedToolCalls: requireSigned,
         isSameModel: sameModel,
         toolCallSignature: (part, message) => sameModel(message) ? validThoughtSignature(field(part, "thoughtSignature")) : undefined,
+        includeToolCallId,
     } : undefined;
-    const contents = replayToolHistory(isDenseArray(messages), (part, message) => messagePart(part, field(message, "role") === "assistant", sameModel(message)), onDiagnostics, signedToolReplay, prepared?.declarations.length ?? 0);
+    const contents = replayToolHistory(isDenseArray(messages), (part, message) => messagePart(part, field(message, "role") === "assistant", sameModel(message)), onDiagnostics, toolReplayPolicy, prepared?.declarations.length ?? 0);
     const { systemInstruction, generationConfig } = text.request;
+    const envelope = buildAntigravityEnvelope({
+        wireModelId: selection.route.wireModel,
+        family: entry.response.family,
+        contentsCount: contents.length,
+        messages: isDenseArray(messages),
+        injectedRequestId: input.requestId,
+    });
     return { ...text, request: {
             contents,
             ...(systemInstruction ? { systemInstruction } : {}),
@@ -47,7 +58,9 @@ export function serializeContext(input, injectedSelection, onDiagnostics) {
                 ...(prepared.mode === "NONE" ? { toolConfig: { functionCallingConfig: { mode: "NONE" } } } : {}),
             } : {}),
             generationConfig,
-        } };
+            sessionId: envelope.sessionId,
+            labels: envelope.labels,
+        }, requestId: envelope.requestId };
 }
 export function serializeTextContext(input) {
     try {
@@ -91,9 +104,16 @@ export function serializeTextContext(input) {
         }
         if (!contents.length)
             fail("A text conversation is required.");
-        const systemInstruction = systemPrompt === undefined ? undefined : { parts: [{ text: systemPrompt }] };
+        const systemInstruction = systemPrompt === undefined ? undefined : { role: "user", parts: [{ text: systemPrompt }] };
         const temperature = option(options, "temperature");
         const maxTokens = option(options, "maxTokens");
+        const envelope = buildAntigravityEnvelope({
+            wireModelId: route.wireModel,
+            family: entry.response.family,
+            contentsCount: contents.length,
+            messages: isDenseArray(field(context, "messages", true)),
+            injectedRequestId: requestId,
+        });
         return { project, model: route.wireModel, request: { contents, ...(systemInstruction ? { systemInstruction } : {}), generationConfig: {
                     temperature: typeof temperature === "number" ? temperature : 1,
                     maxOutputTokens: resolveOutputTokens(maxTokens, entry.descriptor.maxTokens, route.thinking),
@@ -101,7 +121,7 @@ export function serializeTextContext(input) {
                         const thinkingConfig = serializeThinkingConfig(route.thinking);
                         return thinkingConfig ? { thinkingConfig } : {};
                     })(),
-                } }, requestType: "agent", userAgent: "antigravity", requestId };
+                }, sessionId: envelope.sessionId, labels: envelope.labels }, requestType: "agent", userAgent: "antigravity", requestId: envelope.requestId };
     }
     catch (error) {
         if (error instanceof ContextSerializationError)

package/dist/envelope.d.ts

@@ -0,0 +1,20 @@
+export declare const ANTIGRAVITY_MODEL_ENUM: Readonly<Record<string, string>>;
+export declare function stableUuid(seed: string): string;
+export declare function resolveSessionTrajectory(messages?: readonly unknown[]): {
+    conversationId: string;
+    trajectoryId: string;
+};
+export declare function clearSessionTrajectoryMap(): void;
+export interface AntigravityEnvelope {
+    readonly requestId: string;
+    readonly sessionId: string;
+    readonly labels: Record<string, string>;
+}
+export declare function buildAntigravityEnvelope(options: {
+    wireModelId: string;
+    family: "gemini" | "claude" | "gpt-oss";
+    contentsCount: number;
+    messages?: readonly unknown[];
+    explicitSessionId?: string;
+    injectedRequestId?: string;
+}): AntigravityEnvelope;

package/dist/envelope.js

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+export const ANTIGRAVITY_MODEL_ENUM = Object.freeze({
+    // Gemini 3.8 Flash
+    "gemini-3.8-flash": "MODEL_PLACEHOLDER_M318",
+    "gemini-3.8-flash-high": "MODEL_PLACEHOLDER_M318",
+    "gemini-3.8-flash-medium": "MODEL_PLACEHOLDER_M319",
+    "gemini-3.8-flash-low": "MODEL_PLACEHOLDER_M320",
+    "gemini-3.8-flash-tiered": "MODEL_PLACEHOLDER_M322",
+    // Gemini 3.7 Flash
+    "gemini-3.7-flash": "MODEL_PLACEHOLDER_M298",
+    "gemini-3.7-flash-high": "MODEL_PLACEHOLDER_M298",
+    "gemini-3.7-flash-medium": "MODEL_PLACEHOLDER_M299",
+    "gemini-3.7-flash-low": "MODEL_PLACEHOLDER_M300",
+    "gemini-3.7-flash-tiered": "MODEL_PLACEHOLDER_M301",
+    // Gemini 3.6 Flash
+    "gemini-3.6-flash": "MODEL_PLACEHOLDER_M71",
+    "gemini-3.6-flash-high": "MODEL_PLACEHOLDER_M71",
+    "gemini-3.6-flash-medium": "MODEL_PLACEHOLDER_M72",
+    "gemini-3.6-flash-low": "MODEL_PLACEHOLDER_M73",
+    "gemini-3.6-flash-tiered": "MODEL_PLACEHOLDER_M196",
+    // Gemini 3.5 Flash
+    "gemini-3.5-flash": "MODEL_PLACEHOLDER_M20",
+    "gemini-3.5-flash-extra-low": "MODEL_PLACEHOLDER_M187",
+    "gemini-3.5-flash-low": "MODEL_PLACEHOLDER_M20",
+    "gemini-3-flash-agent": "MODEL_PLACEHOLDER_M84",
+    // Gemini 3.1 Pro
+    "gemini-3.1-pro": "MODEL_PLACEHOLDER_M36",
+    "gemini-3.1-pro-low": "MODEL_PLACEHOLDER_M36",
+    "gemini-3.1-pro-high": "MODEL_PLACEHOLDER_M37",
+    "gemini-pro-agent": "MODEL_PLACEHOLDER_M16",
+    // Claude
+    "claude-sonnet-4-6": "MODEL_PLACEHOLDER_M35",
+    "claude-opus-4-6": "MODEL_PLACEHOLDER_M26",
+    "claude-opus-4-6-thinking": "MODEL_PLACEHOLDER_M26",
+    // GPT-OSS
+    "gpt-oss-120b": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
+    "gpt-oss-120b-medium": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
+});
+export function stableUuid(seed) {
+    const bytes = createHash("sha1").update(seed).digest().subarray(0, 16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+const sessionTrajectoryMap = new Map();
+export function resolveSessionTrajectory(messages) {
+    const firstMsg = Array.isArray(messages) ? messages[0] : undefined;
+    if (!isRecord(firstMsg)) {
+        return { conversationId: crypto.randomUUID(), trajectoryId: crypto.randomUUID() };
+    }
+    const role = typeof firstMsg.role === "string" ? firstMsg.role : "user";
+    const timestamp = typeof firstMsg.timestamp === "number" ? String(firstMsg.timestamp) : "";
+    const rawContent = firstMsg.content;
+    const contentSeed = typeof rawContent === "string"
+        ? rawContent.slice(0, 64)
+        : Array.isArray(rawContent)
+            ? JSON.stringify(rawContent[0] ?? "").slice(0, 64)
+            : "";
+    const seed = `${role}:${timestamp}:${contentSeed}`;
+    let entry = sessionTrajectoryMap.get(seed);
+    if (!entry) {
+        entry = {
+            conversationId: stableUuid(`antigravity:conv:${seed}`),
+            trajectoryId: stableUuid(`antigravity:traj:${seed}`),
+        };
+        sessionTrajectoryMap.set(seed, entry);
+        if (sessionTrajectoryMap.size > 64) {
+            const oldestKey = sessionTrajectoryMap.keys().next().value;
+            if (oldestKey !== undefined)
+                sessionTrajectoryMap.delete(oldestKey);
+        }
+    }
+    return entry;
+}
+export function clearSessionTrajectoryMap() {
+    sessionTrajectoryMap.clear();
+}
+const UUID_AGENT_REGEX = /^agent-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function buildAntigravityEnvelope(options) {
+    const isClaude = options.family === "claude";
+    const isNonGemini = options.family === "claude" || options.family === "gpt-oss";
+    const step = Math.max(1, options.contentsCount);
+    const lastStepIndex = String(Math.max(0, step - 1));
+    const assistantMsgCount = Array.isArray(options.messages)
+        ? options.messages.filter((m) => isRecord(m) && m.role === "assistant" && m.stopReason !== "error" && m.stopReason !== "aborted").length
+        : 0;
+    const requestIndex = Math.max(0, assistantMsgCount);
+    const { conversationId, trajectoryId } = resolveSessionTrajectory(options.messages);
+    const sessionHash = createHash("sha1").update(`session:${trajectoryId}`).digest().subarray(0, 8);
+    const generatedSessionId = String(new DataView(sessionHash.buffer, sessionHash.byteOffset, 8).getBigInt64(0, true));
+    const sessionId = options.explicitSessionId || generatedSessionId;
+    const labels = {
+        last_step_index: lastStepIndex,
+        request_id: `${trajectoryId}-${requestIndex}`,
+        trajectory_id: trajectoryId,
+        used_claude: isClaude ? "true" : "false",
+        used_claude_conservative: isClaude ? "true" : "false",
+        used_non_gemini_model: isNonGemini ? "true" : "false",
+    };
+    const modelEnum = ANTIGRAVITY_MODEL_ENUM[options.wireModelId];
+    if (modelEnum) {
+        labels.model_enum = modelEnum;
+    }
+    const requestId = options.injectedRequestId && !UUID_AGENT_REGEX.test(options.injectedRequestId)
+        ? options.injectedRequestId
+        : `agent/${conversationId}/${trajectoryId}/${step}`;
+    return { requestId, sessionId, labels };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/tool-context.d.ts

@@ -20,10 +20,12 @@ export interface ToolReplayDiagnostics {
     readonly assistantToolCallBlockCount: number;
     readonly declaredToolCount: number;
 }
+export declare function sanitizeToolCallId(id: string, fallbackName?: string): string;
 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;
+    readonly includeToolCallId?: boolean;
 }
 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

@@ -32,6 +32,12 @@ export function prepareToolContext(tools, choice, schemaProfile) {
         unsupportedChoice();
     return { declarations, mode: choice === "none" ? "NONE" : "AUTO" };
 }
+let toolCallCounter = 0;
+export function sanitizeToolCallId(id, fallbackName) {
+    const cleaned = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const capped = cleaned.slice(0, 64);
+    return capped || `${fallbackName || "tool"}_${++toolCallCounter}`;
+}
 export function replayToolHistory(messages, serializePart, onDiagnostics, policy, declaredToolCount = 0) {
     const output = [];
     const calls = new Set();
@@ -63,7 +69,7 @@ export function replayToolHistory(messages, serializePart, onDiagnostics, policy
             if (actual)
                 return actual;
             recoveryCount.value += 1;
-            return pending.observations ? observation(call, missingResultText()) : missingResult(call);
+            return pending.observations ? observation(call, missingResultText()) : missingResult(call, policy?.includeToolCallId);
         });
         if (pending.extraParts?.length) {
             turnParts.push(...pending.extraParts);
@@ -109,7 +115,7 @@ export function replayToolHistory(messages, serializePart, onDiagnostics, policy
             const text = textParts.join("\n\n");
             const outputText = text || (imageParts.length > 0 ? "[Image content]" : "");
             const response = value(current, "isError") === true ? { error: outputText } : { output: outputText };
-            pending.results.set(id, pending.observations ? observation(call, outputText) : { functionResponse: { name: call.name, response } });
+            pending.results.set(id, pending.observations ? observation(call, outputText) : { functionResponse: { ...(policy?.includeToolCallId ? { id: sanitizeToolCallId(call.id, call.name) } : {}), name: call.name, response } });
             if (imageParts.length > 0) {
                 if (!pending.extraParts)
                     pending.extraParts = [];
@@ -174,7 +180,7 @@ export function replayToolHistory(messages, serializePart, onDiagnostics, policy
                 return [part];
             if (observations)
                 return [];
-            return [{ functionCall: { name: part.call.name, args: part.call.args }, ...(part.signature ? { thoughtSignature: part.signature } : {}) }];
+            return [{ functionCall: { ...(policy?.includeToolCallId ? { id: sanitizeToolCallId(part.call.id, part.call.name) } : {}), name: part.call.name, args: part.call.args }, ...(part.signature ? { thoughtSignature: part.signature } : {}) }];
         }));
         pending = { calls: group, results: new Map(), observations };
     }
@@ -190,9 +196,10 @@ function observation(call, 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) {
+function missingResult(call, includeToolCallId) {
     return {
         functionResponse: {
+            ...(includeToolCallId ? { id: sanitizeToolCallId(call.id, call.name) } : {}),
             name: call.name,
             response: {
                 error: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benjamolina/pi-antigravity-guard",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Pi adapter for Antigravity Guard",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,9 @@
     "README.md"
   ],
   "pi": {
-    "extensions": ["./dist/extension.js"]
+    "extensions": [
+      "./dist/extension.js"
+    ]
   },
   "dependencies": {
     "@benjamolina/antigravity-guard-core": "0.1.0"