pi-antigravity-rotator 1.12.2 → 1.12.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.12.4] - 2026-05-18
+
+### Added
+- **Claude `cache_control` stripping**: Anthropic requests often include `cache_control` objects which Google Cloud Code Assist API rejects with "Extra inputs are not permitted". The proxy now safely strips `cache_control` from all system and message content blocks before forwarding them to Gemini.
+- **Claude `VALIDATED` Function Calling**: Automatically enforces `toolConfig: { functionCallingConfig: { mode: "VALIDATED" } }` for Claude models when tools are present, ensuring stricter schema adherence.
+- **Adaptive Thinking Budgets**: Replaced static thinking budget values with a dynamic `MODEL_SPECS` mapping. `gemini-3-flash` now correctly uses adaptive thinking budgets (`-1`) which allows the model to decide its own optimal reasoning length, while Pro models use strict budgets (e.g. `10001` for high).
+- **Max Output Tokens Enforcement**: The proxy now enforces hard `maxOutputTokens` caps based on the specific model's upper limits (e.g. `65535` vs `64000`), dynamically adjusting them to ensure there is enough room for both the thinking budget and the final output response without triggering upstream validation errors.
+
+## [1.12.3] - 2026-05-18
+
+### Fixed
+- **Gemini 3.1 Pro High Deprecation (`400 Invalid Argument`)**: Google Cloud Code Assist deprecated the internal string `"gemini-3.1-pro-high"` and replaced it with `"gemini-pro-agent"`. The proxy now automatically maps `"gemini-3.1-pro-high"` to `"gemini-pro-agent"` under the hood when constructing the upstream payload, preventing `400` validation errors while allowing clients to continue using the `-high` alias.
+- **Missing `thought_signature` on Tool Calls (`400 Invalid Argument`)**: Gemini thinking models strictly require a cryptographic Base64 `thought_signature` for all `functionCall` history parts, which the proxy normally caches in RAM. To prevent API rejection on cache misses (e.g. after a proxy restart or when using synthetic tool IDs), the proxy now gracefully collapses the orphaned tool exchange into a neutral user summary (`[Context: The assistant used tools...]`). This preserves the conversation context without triggering the `400` error or teaching the model bad tool-calling formats.
+
 ## [1.12.2] - 2026-05-18
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "1.12.2",
+  "version": "1.12.4",
   "description": "Multi-account rotation proxy for Google Antigravity with per-model routing, real-time quota tracking, and infringement detection",
   "license": "MIT",
   "type": "module",

package/src/compat.ts

@@ -86,6 +86,64 @@ export interface CompatCompletion {
 	toolCalls?: OpenAIToolCall[];
 }
 
+// ---------------------------------------------------------------------------
+// Model-specific specs — mirrors Antigravity-Manager model_specs.json
+// ---------------------------------------------------------------------------
+interface ModelSpec {
+	maxOutputTokens: number;
+	thinkingBudget: number; // -1 = adaptive (model decides), >=0 = fixed
+	isThinking: boolean;
+}
+const MODEL_SPECS: Record<string, ModelSpec> = {
+	"gemini-pro-agent":          { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3-flash-agent":      { maxOutputTokens: 65536, thinkingBudget: -1,    isThinking: true },
+	"gemini-3-pro-high":         { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3-pro-low":          { maxOutputTokens: 65535, thinkingBudget: 1001,  isThinking: true },
+	"gemini-3.1-pro-high":       { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3.1-pro-low":        { maxOutputTokens: 65535, thinkingBudget: 1001,  isThinking: true },
+	"gemini-3.1-pro-preview":    { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3-flash":            { maxOutputTokens: 65536, thinkingBudget: 32768, isThinking: true },
+	"gemini-2.5-flash":          { maxOutputTokens: 65535, thinkingBudget: 24576, isThinking: true },
+	"gemini-2.5-pro":            { maxOutputTokens: 65535, thinkingBudget: 1024,  isThinking: true },
+	"claude-sonnet-4-6":         { maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+	"claude-sonnet-4-6-thinking":{ maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+	"claude-opus-4-6-thinking":  { maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+};
+const GEMINI_MAX_OUTPUT_TOKENS = 65536;
+const CLAUDE_MAX_OUTPUT_TOKENS = 64000;
+const FALLBACK_THINKING_BUDGET = 24576;
+const CLAUDE_DEFAULT_THINKING_BUDGET = 32768;
+
+function getModelFamily(model: string): "claude" | "gemini" | "unknown" {
+	const l = model.toLowerCase();
+	if (l.includes("claude")) return "claude";
+	if (l.includes("gemini")) return "gemini";
+	return "unknown";
+}
+
+function getModelSpec(model: string): ModelSpec {
+	const lower = model.toLowerCase();
+	if (MODEL_SPECS[lower]) return MODEL_SPECS[lower];
+	for (const [key, spec] of Object.entries(MODEL_SPECS)) {
+		if (lower.includes(key)) return spec;
+	}
+	const family = getModelFamily(model);
+	if (family === "claude") return { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS, thinkingBudget: CLAUDE_DEFAULT_THINKING_BUDGET, isThinking: true };
+	if (family === "gemini") return { maxOutputTokens: GEMINI_MAX_OUTPUT_TOKENS, thinkingBudget: FALLBACK_THINKING_BUDGET, isThinking: true };
+	return { maxOutputTokens: 65536, thinkingBudget: FALLBACK_THINKING_BUDGET, isThinking: false };
+}
+
+function isThinkingModel(model: string): boolean {
+	const spec = getModelSpec(model);
+	if (spec.isThinking) return true;
+	const l = model.toLowerCase();
+	if (l.includes("gemini")) {
+		const m = l.match(/gemini-(\d+)/);
+		if (m && parseInt(m[1], 10) >= 3) return true;
+	}
+	return false;
+}
+
 type AntigravityPart = { text: string } | { inlineData: { mimeType: string; data: string } };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -120,12 +178,29 @@ function cacheThoughtSignature(callId: string, signature: string): void {
 	thoughtSignatureCache.set(callId, signature);
 }
 
+/**
+ * Strip cache_control fields from content blocks.
+ * Cloud Code API rejects cache_control with "Extra inputs are not permitted".
+ */
+function cleanCacheControl<T>(content: T): T {
+	if (!Array.isArray(content)) return content;
+	return content.map((block: Record<string, unknown>) => {
+		if (!block || typeof block !== "object") return block;
+		if ("cache_control" in block) {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			const { cache_control: _cc, ...rest } = block;
+			return rest;
+		}
+		return block;
+	}) as T;
+}
+
 function extractText(content: ChatMessage["content"]): string {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
-	return content
-		.filter((p) => (p.type === "text" && typeof p.text === "string") || (p.type === "thinking" && typeof p.thinking === "string"))
-		.map((p) => p.type === "thinking" ? `[Thinking]\n${p.thinking}\n[/Thinking]` : p.text)
+	return cleanCacheControl(content)
+		.filter((p: { type?: string; text?: string; thinking?: string }) => (p.type === "text" && typeof p.text === "string") || (p.type === "thinking" && typeof p.thinking === "string"))
+		.map((p: { type?: string; text?: string; thinking?: string }) => p.type === "thinking" ? `[Thinking]\n${p.thinking}\n[/Thinking]` : (p.text as string))
 		.join("\n");
 }
 
@@ -246,12 +321,15 @@ function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
 	if (!isRecord(schema)) return schema;
 
 	// Only remove fields that Gemini's API layer truly rejects at the network level.
-	// We keep Draft 2020-12 keywords like minimum/maximum/pattern/title/etc.
+	// We keep standard Draft 2020-12 keywords but must strip exclusiveMinimum/exclusiveMaximum
+	// as boolean values (Draft 4) — the API layer rejects them even for Claude-bound requests.
 	const UNSUPPORTED = new Set([
 		"$schema", "$id", "$ref", "$defs", "definitions",
 		"if", "then", "else", "not",
 		"patternProperties", "unevaluatedProperties", "unevaluatedItems",
 		"contentEncoding", "contentMediaType",
+		// Gemini's protobuf layer rejects these regardless of target model
+		"exclusiveMinimum", "exclusiveMaximum",
 	]);
 
 	const out: Record<string, unknown> = {};
@@ -411,10 +489,41 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	// Determine if model is Claude — affects schema sanitization and tool call ID handling
 	const isClaude = /^claude-/i.test(input.model);
 
+	// Use model specs to determine thinking support
+	const isThinking = isThinkingModel(input.model);
+	const isGeminiThinking = !isClaude && isThinking;
+
 	const contents: GeminiContent[] = [];
 	for (let i = 0; i < conversationMessages.length; i++) {
 		const msg = conversationMessages[i];
 		if (msg.role === "assistant") {
+			// Check if this is a thinking model turn with tool calls that have no cached signatures.
+			// If so, we collapse the tool exchange into a neutral user summary instead of
+			// injecting [Tool call: ...] text that the model will learn to mimic.
+			const hasMissingSig =
+				isGeminiThinking &&
+				Array.isArray(msg.tool_calls) &&
+				msg.tool_calls.length > 0 &&
+				!thoughtSignatureCache.has(msg.tool_calls[0].id);
+
+			if (hasMissingSig) {
+				// Build a summary of what the model did and what results came back.
+				// We collect the paired tool result(s) from the immediately following messages.
+				const toolNames = msg.tool_calls!.map((tc) => tc.function.name).join(", ");
+				const resultParts: string[] = [];
+				while (i + 1 < conversationMessages.length && conversationMessages[i + 1].role === "tool") {
+					i++;
+					const toolMsg = conversationMessages[i];
+					const toolText = typeof toolMsg.content === "string" ? toolMsg.content : extractText(toolMsg.content);
+					resultParts.push(`${toolMsg.name || "tool"}: ${toolText.slice(0, 500)}`);
+				}
+				const summaryText = `[Context: The assistant used tools (${toolNames}) and received results:\n${resultParts.join("\n")}]`;
+				contents.push({ role: "user", parts: [{ text: summaryText }] });
+				// Add a minimal model acknowledgement to avoid consecutive user turns
+				contents.push({ role: "model", parts: [{ text: "Understood, I have the tool results." }] });
+				continue;
+			}
+
 			const parts: unknown[] = [];
 			if (msg.content) {
 				const textContent = typeof msg.content === "string" ? msg.content : extractText(msg.content);
@@ -427,28 +536,24 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 				// signatures on older historical turns are silently ignored.
 				let isFirstInMessage = true;
 				for (const tc of msg.tool_calls) {
+					let args: unknown;
 					try {
-						const args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
-						// Only the first functionCall part in a model turn needs the signature
-						const cachedSig = isFirstInMessage ? thoughtSignatureCache.get(tc.id) : undefined;
-						parts.push({
-							...(cachedSig ? { thoughtSignature: cachedSig } : {}),
-							// Include id only for Claude — Gemini native models reject the id field
-							functionCall: { ...(isClaude ? { id: tc.id } : {}), name: tc.function.name, args },
-						});
+						args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
 					} catch {
-						const cachedSig = isFirstInMessage ? thoughtSignatureCache.get(tc.id) : undefined;
-						parts.push({
-							...(cachedSig ? { thoughtSignature: cachedSig } : {}),
-							functionCall: { ...(isClaude ? { id: tc.id } : {}), name: tc.function.name, args: {} },
-						});
+						args = {};
 					}
+					// Only the first functionCall part in a model turn needs the signature
+					const cachedSig = isFirstInMessage ? thoughtSignatureCache.get(tc.id) : undefined;
+					parts.push({
+						...(cachedSig ? { thoughtSignature: cachedSig } : {}),
+						// Include id only for Claude — Gemini native models reject the id field
+						functionCall: { ...(isClaude ? { id: tc.id } : {}), name: tc.function.name, args },
+					});
 					isFirstInMessage = false;
 				}
 			}
 			if (parts.length > 0) contents.push({ role: "model", parts });
 		} else if (msg.role === "tool") {
-			const prevMsg = conversationMessages[i - 1];
 			const responseText = typeof msg.content === "string" ? msg.content : extractText(msg.content);
 			const fnName = msg.name || "unknown";
 			// Include tool_call_id so Gemini can pass it as tool_use_id to Claude
@@ -460,6 +565,7 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 		} else {
 			// user message
 			const msgParts = extractParts(msg.content);
+
 			if (msgParts.length > 0) contents.push({ role: "user", parts: msgParts });
 		}
 	}
@@ -472,35 +578,84 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	const geminiTools = convertOpenAIToolsToGemini(inputTools, isClaude);
 	const geminiToolConfig = input.tool_choice !== undefined ? convertToolChoiceToGemini(input.tool_choice) : undefined;
 
-	// Map OpenAI reasoning_effort → Gemini thinkingLevel
-	const thinkingLevel = mapReasoningEffortToThinkingLevel(input.reasoning_effort, input.model);
+	// Cap maxOutputTokens to model limits and build thinkingConfig
+	const modelSpec = getModelSpec(input.model);
+	const modelFamily = getModelFamily(input.model);
+	let maxOutputTokens = typeof input.max_tokens === "number" ? input.max_tokens : undefined;
+	if (maxOutputTokens && maxOutputTokens > modelSpec.maxOutputTokens) {
+		compatLogger.debug(`Capping ${input.model} maxOutputTokens ${maxOutputTokens} → ${modelSpec.maxOutputTokens}`);
+		maxOutputTokens = modelSpec.maxOutputTokens;
+	}
+
+	let thinkingConfigObj: Record<string, unknown> | undefined;
+	if (modelFamily === "claude" && isThinking) {
+		// Claude: snake_case keys required by v1internal
+		const tb = modelSpec.thinkingBudget;
+		thinkingConfigObj = { include_thoughts: true, thinking_budget: tb };
+		if (!maxOutputTokens || maxOutputTokens <= tb) {
+			maxOutputTokens = Math.min(tb + 8192, modelSpec.maxOutputTokens);
+			compatLogger.debug(`Adjusted Claude maxOutputTokens → ${maxOutputTokens}`);
+		}
+	} else if (isThinking) {
+		// Gemini: camelCase keys; thinkingBudget=-1 means adaptive (omit the field)
+		const tb = modelSpec.thinkingBudget;
+		thinkingConfigObj = tb === -1
+			? { includeThoughts: true }
+			: { includeThoughts: true, thinkingBudget: tb };
+		if (tb !== -1 && (!maxOutputTokens || maxOutputTokens <= tb)) {
+			maxOutputTokens = Math.min(tb + 8192, modelSpec.maxOutputTokens);
+			compatLogger.debug(`Adjusted Gemini maxOutputTokens → ${maxOutputTokens}`);
+		}
+	} else if (input.reasoning_effort) {
+		// Non-thinking models with explicit reasoning_effort hint
+		const budgets: Record<string, number> = { low: Math.round(modelSpec.thinkingBudget / 4), medium: Math.round(modelSpec.thinkingBudget / 2), high: modelSpec.thinkingBudget };
+		const b = budgets[input.reasoning_effort.toLowerCase()];
+		if (b) thinkingConfigObj = { includeThoughts: true, thinkingBudget: b };
+	}
+
+	const generationConfig: Record<string, unknown> = {
+		...(typeof input.temperature === "number" ? { temperature: input.temperature } : {}),
+		...(maxOutputTokens ? { maxOutputTokens } : {}),
+		...(thinkingConfigObj ? { thinkingConfig: thinkingConfigObj } : {}),
+	};
 
 	const request: Record<string, unknown> = {
 		contents,
-		generationConfig: {
-			...(typeof input.temperature === "number" ? { temperature: input.temperature } : {}),
-			...(typeof input.max_tokens === "number" ? { maxOutputTokens: input.max_tokens } : {}),
-			// Always request thought blocks. Models that don't support thinking ignore this.
-			thinkingConfig: {
-				includeThoughts: true,
-				...(thinkingLevel ? { thinkingLevel } : {}),
-			},
-		},
+		generationConfig,
 	};
 
 	if (systemParts.length > 0) {
-		request.systemInstruction = {
-			role: "user",
-			parts: [{ text: systemParts.join("\n\n") }],
-		};
+		if (!isClaude && isThinking) {
+			// Gemini thinking models (gemini-3.1-pro-high/low) reject the systemInstruction
+			// field entirely — prepend system prompt to the first user content turn instead.
+			const firstTurn = contents[0];
+			if (firstTurn && firstTurn.role === "user" && (firstTurn.parts[0] as any)?.text !== undefined) {
+				(firstTurn.parts[0] as any).text = systemParts.join("\n\n") + "\n\n" + (firstTurn.parts[0] as any).text;
+			} else if (firstTurn && firstTurn.role === "user") {
+				firstTurn.parts.unshift({ text: systemParts.join("\n\n") + "\n\n" });
+			} else {
+				contents.unshift({
+					role: "user",
+					parts: [{ text: systemParts.join("\n\n") }],
+				});
+			}
+		} else {
+			request.systemInstruction = {
+				role: "system",
+				parts: [{ text: systemParts.join("\n\n") }],
+			};
+		}
 	}
 
 	if (geminiTools.length > 0) request.tools = geminiTools;
 	if (geminiToolConfig) request.toolConfig = geminiToolConfig;
 
+	let mappedModel = input.model;
+	if (mappedModel === "gemini-3.1-pro-high") mappedModel = "gemini-pro-agent";
+
 	return {
 		project: "compat-placeholder",
-		model: input.model,
+		model: mappedModel,
 		userAgent: "antigravity",
 		requestType: "agent",
 		request,
@@ -522,28 +677,47 @@ export function anthropicToAntigravityBody(input: AnthropicMessagesRequest): Req
 }
 
 /**
- * Maps an OpenAI reasoning_effort string to a Gemini thinkingLevel.
- * Gemini 3 Pro only supports LOW and HIGH; Flash supports MINIMAL/LOW/MEDIUM/HIGH.
+ * Maps an OpenAI reasoning_effort / model name suffix to a Gemini thinkingBudget integer.
+ * Cloud Code Assist uses thinkingBudget (integer token count), not thinkingLevel (string).
+ * Values match models.json: -high=10001, -low=1001, flash=dynamic(-1 means dynamic).
+ * Returns undefined for models that don't need an explicit budget (e.g. Claude, plain flash).
  */
-function mapReasoningEffortToThinkingLevel(effort: string | undefined, modelId: string): string | undefined {
-	const isGemini3Pro = /gemini-3(?:\.1)?-pro/i.test(modelId);
-	
+function mapReasoningEffortToThinkingLevel(effort: string | undefined, modelId: string): number | undefined {
+	const lowerModel = modelId.toLowerCase();
+	const isGemini31Pro = /gemini-3\.1-pro/i.test(modelId);
+	const isGemini3Flash = lowerModel.includes("gemini-3-flash");
+
 	let effectiveEffort = effort;
 	if (!effectiveEffort) {
-		const lowerModel = modelId.toLowerCase();
-		if (lowerModel.endsWith("-high") || lowerModel.includes("claude-")) effectiveEffort = "high";
+		if (lowerModel.endsWith("-high") || lowerModel.includes("gemini-pro-agent")) effectiveEffort = "high";
 		else if (lowerModel.endsWith("-low")) effectiveEffort = "low";
-		else if (lowerModel.includes("gemini-3-flash")) effectiveEffort = "high";
+		else if (isGemini3Flash) effectiveEffort = "high";
+		// Claude models: skip — thinking is handled by the anthropic-beta header
 	}
 
 	if (!effectiveEffort) return undefined;
 
-	switch (effectiveEffort.toLowerCase()) {
-		case "low": return isGemini3Pro ? "LOW" : "LOW";
-		case "medium": return isGemini3Pro ? "HIGH" : "MEDIUM";
-		case "high": return "HIGH";
-		default: return undefined;
+	// Gemini 3.1 Pro uses fixed budgets matching models.json
+	if (isGemini31Pro) {
+		switch (effectiveEffort.toLowerCase()) {
+			case "high": return 10001;
+			case "medium": return 5000;
+			case "low": return 1001;
+			default: return undefined;
+		}
 	}
+
+	// Flash uses dynamic budget (-1 means let the model decide)
+	if (isGemini3Flash) {
+		switch (effectiveEffort.toLowerCase()) {
+			case "high": return -1;
+			case "medium": return 4096;
+			case "low": return 1024;
+			default: return undefined;
+		}
+	}
+
+	return undefined;
 }
 
 export function parseAntigravitySse(raw: string): CompatCompletion {