pi-antigravity-rotator 2.1.4 → 2.1.5

package/CHANGELOG.md

@@ -2,7 +2,14 @@
 
 ## [Unreleased]
 
-## [2.1.4] - 2026-05-27
+## [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:

package/README.md

@@ -513,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.4",
+  "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

@@ -724,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;
 		}
 
@@ -1171,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";
@@ -1187,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);