pi-antigravity-rotator 2.1.4 → 2.1.6

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [2.1.6] - 2026-06-12
+
+### Fixed
+- **Streaming tool calls finish reason**: Fixed an issue where `streamCompatSse` emitted `finish_reason: "stop"` instead of `"tool_calls"` when function calls were streamed to the client via OpenAI compatibility layer. This resolves compatibility issues with clients like ZED editor that discard pending tool executions as canceled when receiving "stop".
+
+## [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.
+
+
 ## [2.1.4] - 2026-05-27
 
 ### Improved

package/README.md

@@ -471,6 +471,7 @@ Current adapter scope:
 
 Thanks to these amazing people who have contributed to the project:
 
+- **[@josenicomaia](https://github.com/josenicomaia)** (José Nicodemos Maia Neto) — Fixed streaming pass-through to emit correct `finish_reason` for tool calls, fixing tool execution on ZED editor. ([PR #8](https://github.com/tuxevil/pi-antigravity-rotator/pull/8))
 - **[@javargasm](https://github.com/javargasm)** (Jeisson Alexander Vargas Marroquin) — Anthropic tool-use compatibility layer (`tool_use`/`tool_result` content block conversion), JSON schema round-trip fixes, and compat test suite expansion. ([PR #3](https://github.com/tuxevil/pi-antigravity-rotator/pull/3), [PR #7](https://github.com/tuxevil/pi-antigravity-rotator/pull/7))
 
 
@@ -513,7 +514,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.6",
   "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);
@@ -1638,6 +1682,7 @@ async function streamCompatSse(
 	const created = Math.floor(Date.now() / 1000);
 	const id = format === "openai" ? `chatcmpl-${Date.now().toString(36)}` : `msg_${Date.now().toString(36)}`;
 
+	const openaiToolCalls: OpenAIToolCall[] = [];
 	let anthropicActiveBlockIndex = -1;
 	let anthropicActiveBlockType: "thinking" | "text" | null = null;
 	let anthropicHasToolUse = false;
@@ -1732,6 +1777,7 @@ async function streamCompatSse(
 									cacheThoughtSignature(callId, part.thoughtSignature);
 								}
 								if (format === "openai") {
+									openaiToolCalls.push({ id: callId, type: "function", function: { name, arguments: args } });
 									res.write(`data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta: { tool_calls: [{ index: toolCallIndex - 1, id: callId, type: "function", function: { name, arguments: args } }] }, finish_reason: null }] })}\n\n`);
 								} else {
 									// Close any active text/thinking block before emitting tool_use
@@ -1769,7 +1815,8 @@ async function streamCompatSse(
 
 	if (!reqClosed && !res.writableEnded) {
 		if (format === "openai") {
-			res.write(`data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\n`);
+			const openaiFinishReason = toolCallIndex > 0 ? "tool_calls" : "stop";
+			res.write(`data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta: {}, finish_reason: openaiFinishReason }] })}\n\n`);
 			// Emit a usage chunk so agents (hermes, openwebui, etc.) can display token statistics
 			if (inputTokens > 0 || outputTokens > 0) {
 				res.write(`data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [], usage: { prompt_tokens: inputTokens, completion_tokens: outputTokens, total_tokens: inputTokens + outputTokens } })}\n\n`);
@@ -1787,7 +1834,8 @@ async function streamCompatSse(
 		res.end();
 	}
 
-	return { text, inputTokens, outputTokens, responseId, toolCalls: anthropicToolCalls.length > 0 ? anthropicToolCalls : undefined };
+	const collectedToolCalls = openaiToolCalls.length > 0 ? openaiToolCalls : anthropicToolCalls.length > 0 ? anthropicToolCalls : undefined;
+	return { text, inputTokens, outputTokens, responseId, toolCalls: collectedToolCalls };
 }
 
 async function streamResponsesSse(