pi-antigravity-rotator 2.1.3 → 2.1.5

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [2.1.5] - 2026-05-27
+
+### Fixed
+- **Claude tool_use/tool_result ordering via Responses API**: Resolved a persistent `400 INVALID_ARGUMENT` (`messages.1: tool_use ids were found without tool_result blocks immediately after`) error when using Claude models (e.g. `claude-sonnet-4-6`) through the OpenAI Responses API (used by Codex and similar agents). Three structural issues were corrected in the Gemini content turn builder:
+  - **Parallel function_call merging**: Codex sends parallel tool calls as separate `function_call` input items. Each was creating its own assistant turn, but Claude requires all `tool_use` blocks in a single assistant message. Consecutive `function_call` items are now merged into one assistant message with multiple `tool_calls`.
+  - **Text/tool_call separation**: Codex sends the assistant's narration text (`"Let me explore..."`) and its `function_call` items as separate input items. The narration was creating a `model` Gemini turn between the `functionCall` turn and the `functionResponse` turn, breaking Claude's strict ordering. Text-only model turns that follow a `functionCall` model turn are now suppressed.
+  - **Consecutive tool result merging**: Multiple `functionResponse` parts are now merged into a single `user` Gemini turn, ensuring all `tool_result` blocks appear in one message directly after the `tool_use` assistant message.
+
+
+### Improved
+- **Less Lossy Schema Collapsing for Claude**: The `sanitizeClaudeViaGeminiSchema` function now handles complex `anyOf`/`oneOf`/`allOf` schemas with significantly less information loss:
+  - **Nullable detection (lossless)**: `anyOf: [{type: X}, {type: "null"}]` patterns are now converted to `{type: X, nullable: true}` instead of losing the null variant.
+  - **`allOf` deep merge (lossless)**: `allOf` variants are now deep-merged (properties union + required union) instead of picking only the first variant.
+  - **`anyOf`/`oneOf` object merge**: When all variants are objects, properties are merged into a union and only fields required in ALL variants remain required, preserving wider input acceptance.
+  - The first-variant fallback is still used for truly incompatible mixed-type unions.
+
+### Fixed
+- **README: Incorrect model names in Codex section**: Removed references to nonexistent `claude-3-5-sonnet` and `gemini-3-pro` models, replaced with actual supported models (`claude-opus-4-6-thinking`, `gemini-3.1-pro`, `gpt-oss-120b`, etc.).
+
+### Added
+- **Schema sanitizer tests**: Added test cases for nullable detection, `allOf` deep merge, and `anyOf` object variant merging.
+
 ## [2.1.3] - 2026-05-27
 
 ### Fixed

package/README.md

@@ -500,9 +500,10 @@ To connect Codex to your local rotator:
 
 3. **Select a Supported Model**:
    Configure Codex to target one of the following models supported by the rotator (which will be mapped to the best available Google Antigravity account/model under the hood):
-   - `gemini-3.5-flash` or `gemini-3.5-flash-high` / `gemini-3.5-flash-low` (Recommended for fast general reasoning)
-   - `gemini-3-pro` or `gemini-pro-agent` (For deep reasoning)
-   - `claude-sonnet-4-6` or `claude-3-5-sonnet` (Alternative routing fallback)
+   - `gemini-3.5-flash` or `gemini-3.5-flash-high` / `gemini-3.5-flash-low` / `gemini-3.5-flash-medium` (Recommended for fast general reasoning)
+   - `gemini-3.1-pro` or `gemini-pro-agent` / `gemini-3.1-pro-high` / `gemini-3.1-pro-low` (For deep reasoning)
+   - `claude-sonnet-4-6` or `claude-opus-4-6-thinking` (Claude models via Vertex AI)
+   - `gpt-oss-120b` or `gpt-oss-120b-medium` (Open-source GPT model)
 
    Example Codex configuration entry:
    ```json
@@ -512,7 +513,7 @@ To connect Codex to your local rotator:
 ### Features Enabled for Codex Agents
 
 - **Native Reasoning Visibility**: If using models with thinking enabled (e.g., `gemini-3.5-flash-high`), interleaved reasoning/thinking blocks are streamed back in real-time as OpenAI `reasoning_content` chunks. This lets Codex inspect the model's inner thoughts before it acts.
-- **Function / Tool Routing**: Function calls emitted by Codex are fully translated to Gemini `functionCalls` and returned back to Codex safely, enabling full agentic capabilities.
+- **Function / Tool Routing**: Function calls emitted by Codex are fully translated to Gemini `functionCalls` and returned back to Codex safely, enabling full agentic capabilities. Multi-turn tool conversations work correctly for all models including Claude (`claude-sonnet-4-6`, `claude-opus-4-6-thinking`) — parallel tool calls are batched into a single turn and tool results are properly grouped to satisfy Claude's strict `tool_use`/`tool_result` ordering requirements.
 - **Strict Validation**: The rotator strictly validates the Responses input contract and rejects unsupported tools (e.g., `web_search`) proactively to ensure Codex doesn't hit unexpected runtime exceptions.
 
 ## Development Checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "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

@@ -470,17 +470,98 @@ function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
 					}
 				}
 
-				// General case: collapse to the first valid variant.
-				// Gemini's Schema proto serialization corrupts complex anyOf/oneOf
-				// during the round-trip to Claude, causing JSON Schema draft 2020-12
-				// validation failures. Collapsing is lossy but functional — the tool
-				// still works, just with a narrower accepted input type.
+				// Sanitize all variants first.
 				const cleaned = value.map(sanitizeClaudeViaGeminiSchema).filter(
 					(v) => isRecord(v) && Object.keys(v).length > 0,
+				) as Record<string, unknown>[];
+
+				if (cleaned.length === 0) {
+					// All variants collapsed to nothing — skip entirely.
+					continue;
+				}
+
+				// Case 3: nullable pattern — anyOf/oneOf with exactly one {type:"null"}
+				// variant and one or more real variants. Convert to the real variant
+				// with nullable:true. This is lossless — Gemini's proto supports nullable.
+				// e.g. anyOf:[{type:"string"},{type:"null"}] → {type:"string",nullable:true}
+				if (key !== "allOf") {
+					const nullIdx = cleaned.findIndex((v) => v.type === "null" && Object.keys(v).length === 1);
+					if (nullIdx !== -1) {
+						const nonNull = cleaned.filter((_, i) => i !== nullIdx);
+						if (nonNull.length === 1) {
+							Object.assign(out, nonNull[0], { nullable: true });
+							continue;
+						}
+						if (nonNull.length > 1) {
+							// Multiple non-null variants + null → collapse non-null variants,
+							// then mark nullable. Still lossy but preserves nullability.
+							Object.assign(out, nonNull[0], { nullable: true });
+							continue;
+						}
+					}
+				}
+
+				// Case 4: allOf — deep merge all variants (allOf = intersection).
+				// Merging properties from all variants is semantically correct.
+				if (key === "allOf") {
+					const merged: Record<string, unknown> = {};
+					let mergedProperties: Record<string, unknown> = {};
+					let mergedRequired: string[] = [];
+					for (const variant of cleaned) {
+						for (const [vk, vv] of Object.entries(variant)) {
+							if (vk === "properties" && isRecord(vv)) {
+								mergedProperties = { ...mergedProperties, ...vv };
+							} else if (vk === "required" && Array.isArray(vv)) {
+								mergedRequired = [...new Set([...mergedRequired, ...vv])];
+							} else {
+								merged[vk] = vv;
+							}
+						}
+					}
+					if (Object.keys(mergedProperties).length > 0) merged["properties"] = mergedProperties;
+					if (mergedRequired.length > 0) merged["required"] = mergedRequired;
+					Object.assign(out, merged);
+					continue;
+				}
+
+				// Case 5: anyOf/oneOf where all variants are objects with properties —
+				// merge all properties together, making all optional (union of shapes).
+				// This is mildly lossy (accepts wider input) but doesn't reject valid inputs.
+				const allObjects = cleaned.every(
+					(v) => v.type === "object" && isRecord(v.properties),
 				);
-				if (cleaned.length >= 1) {
-					Object.assign(out, cleaned[0]);
+				if (allObjects && cleaned.length > 1) {
+					const unionProperties: Record<string, unknown> = {};
+					for (const variant of cleaned) {
+						const props = variant.properties as Record<string, unknown>;
+						for (const [pk, pv] of Object.entries(props)) {
+							if (!(pk in unionProperties)) unionProperties[pk] = pv;
+						}
+					}
+					// Only keep required fields that exist in ALL variants
+					const allRequired = cleaned.map((v) =>
+						Array.isArray(v.required) ? new Set(v.required as string[]) : new Set<string>(),
+					);
+					const commonRequired = [...allRequired[0]].filter((r) =>
+						allRequired.every((s) => s.has(r)),
+					);
+					const base = { ...cleaned[0] };
+					base["properties"] = unionProperties;
+					if (commonRequired.length > 0) {
+						base["required"] = commonRequired;
+					} else {
+						delete base["required"];
+					}
+					Object.assign(out, base);
+					continue;
 				}
+
+				// Fallback: collapse to the first valid variant.
+				// Gemini's Schema proto serialization corrupts complex anyOf/oneOf
+				// during the round-trip to Claude, causing JSON Schema draft 2020-12
+				// validation failures. Collapsing is lossy but functional — the tool
+				// still works, just with a narrower accepted input type.
+				Object.assign(out, cleaned[0]);
 			}
 			continue;
 		}
@@ -643,11 +724,19 @@ function parseResponsesInput(input: unknown, callIdToName: Map<string, string> =
 				name: rawItem.name,
 				arguments: args,
 			});
-			messages.push({
-				role: "assistant",
-				content: null,
-				tool_calls: [{ id: callId, type: "function", function: { name: rawItem.name, arguments: args } }],
-			});
+			// Merge consecutive function_call items into a single assistant message
+			// so Claude sees one assistant turn with multiple tool_calls rather than
+			// separate assistant turns (which would each require their own tool_result).
+			const lastMsg = messages[messages.length - 1];
+			if (lastMsg && lastMsg.role === "assistant" && Array.isArray(lastMsg.tool_calls)) {
+				lastMsg.tool_calls.push({ id: callId, type: "function", function: { name: rawItem.name, arguments: args } });
+			} else {
+				messages.push({
+					role: "assistant",
+					content: null,
+					tool_calls: [{ id: callId, type: "function", function: { name: rawItem.name, arguments: args } }],
+				});
+			}
 			continue;
 		}
 
@@ -1090,7 +1179,34 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 					isFirstInMessage = false;
 				}
 			}
-			if (parts.length > 0) contents.push({ role: "model", parts });
+			if (parts.length > 0) {
+				// For Claude: handle two scenarios that break tool_use/tool_result ordering.
+				// 1. Text-only model turn after a functionCall model turn: Codex sends
+				//    assistant text and function_calls as separate items. The text-only turn
+				//    would split functionCall from functionResponse — skip it entirely.
+				// 2. Model turn with functionCalls: strip any text parts since Google's
+				//    v1internal translator may split mixed parts into separate Claude messages.
+				if (isClaude) {
+					const lastContent = contents[contents.length - 1];
+					const prevHasFunctionCall = lastContent && lastContent.role === "model" && lastContent.parts.some((p: any) => p.functionCall);
+					const hasFunctionCall = parts.some((p: any) => p.functionCall);
+					if (prevHasFunctionCall && !hasFunctionCall) {
+						// Skip text-only model turn after functionCall turn
+					} else if (hasFunctionCall) {
+						// Strip text parts, keep only functionCall parts
+						const fcOnly = parts.filter((p: any) => p.functionCall);
+						if (prevHasFunctionCall) {
+							lastContent.parts.push(...fcOnly);
+						} else {
+							contents.push({ role: "model", parts: fcOnly });
+						}
+					} else {
+						contents.push({ role: "model", parts });
+					}
+				} else {
+					contents.push({ role: "model", parts });
+				}
+			}
 		} else if (msg.role === "tool") {
 			const responseText = typeof msg.content === "string" ? msg.content : extractText(msg.content);
 			const fnName = msg.name || "unknown";
@@ -1106,7 +1222,16 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 					: { output: parsed };
 			} catch { responseData = { output: responseText }; }
 			// Include id only for Claude — Gemini native models reject the id field in functionResponse
-			contents.push({ role: "user", parts: [{ functionResponse: { ...(isClaude && toolCallId ? { id: toolCallId } : {}), name: fnName, response: responseData } }] });
+			const fnResponsePart = { functionResponse: { ...(isClaude && toolCallId ? { id: toolCallId } : {}), name: fnName, response: responseData } };
+			// Merge consecutive tool results into a single user turn.
+			// Claude (via Vertex) requires ALL tool_result blocks in one message
+			// directly after the assistant message with tool_use blocks.
+			const lastContent = contents[contents.length - 1];
+			if (lastContent && lastContent.role === "user" && Array.isArray(lastContent.parts) && lastContent.parts.length > 0 && isRecord(lastContent.parts[0] as any) && (lastContent.parts[0] as any).functionResponse !== undefined) {
+				lastContent.parts.push(fnResponsePart);
+			} else {
+				contents.push({ role: "user", parts: [fnResponsePart] });
+			}
 		} else {
 			// user message
 			const msgParts = extractParts(msg.content);