pi-antigravity-rotator 2.1.1 → 2.1.3

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [2.1.3] - 2026-05-27
+
+### Fixed
+- **Anthropic Tool Use Content Blocks**: Anthropic `tool_use` and `tool_result` content blocks in message history are now correctly converted to Gemini `functionCall` / `functionResponse` parts when proxying through the Anthropic-compatible `/v1/messages` adapter, preventing `400 INVALID_ARGUMENT` errors on multi-turn tool conversations. (PR [#7](https://github.com/tuxevil/pi-antigravity-rotator/pull/7) by [@javargasm](https://github.com/javargasm))
+- **Anthropic Tool Forwarding**: `tools` and `tool_choice` from Anthropic `/v1/messages` requests are now properly forwarded to the Gemini upstream, enabling full Anthropic-native tool calling through the rotator.
+- **Anthropic Tool Response Streaming**: Streaming and non-streaming Anthropic responses now correctly emit `tool_use` content blocks and set `stop_reason: "tool_use"` when function calls are present.
+- **JSON Schema `anyOf`/`oneOf`/`allOf` Collapse**: The Claude schema sanitizer now collapses composite schema keywords (`anyOf`, `oneOf`, `allOf`) to their first variant before forwarding to Gemini, preventing schema corruption during the Gemini proto round-trip.
+
+### Added
+- **Anthropic Tool Conversion Tests**: Added dedicated test cases for Anthropic tool conversions and JSON schema type collapsing in the compat test suite. ([@javargasm](https://github.com/javargasm))
+
+## [2.1.2] - 2026-05-25
+
+### Added
+- **Developer Role Support**: Added comprehensive compatibility and validation support for the newer `"developer"` role (introduced by OpenAI to replace the system prompt on models like o1/gpt-4o).
+- **Developer Message Routing**: Automatically routes messages with the `"developer"` role as system instructions upstream in the Antigravity request mapping.
+- **Improved Adapter Coverage**: Extended type validation and integration testing in the compat adapters to fully cover the new schema additions.
+
 ## [2.1.1] - 2026-05-21
 
 ### Added

package/README.md

@@ -458,7 +458,7 @@ Current adapter scope:
 
 - Text chat/messages.
 - **Responses API compatibility**: Supports `POST /v1/responses` plus basic in-memory retrieve/delete/cancel/input-items endpoints for Codex-style agents.
-- **Model Role Support**: Fully supports the `"model"` role in chat message histories (e.g., from Pi or Hermes agents), validating and routing it identically to the `"assistant"` role.
+- **Developer and Model Role Support**: Fully supports the `"developer"` (mapped to system instructions) and `"model"` roles in chat message histories, validating and routing them correctly.
 - **Request Normalization**: Automatically normalizes loose inputs (non-array messages), legacy prompt/input fields (e.g. `prompt` strings/arrays or `input` structures), and raw native Antigravity requests (`request.contents`) into standard OpenAI/Anthropic format.
 - **Native Reasoning visibility**: Models with thinking capabilities (Gemini 3 Pro, Gemini 3.5 Flash, Claude Sonnet 4.6 Thinking) automatically expose their interleaved thinking blocks in real-time as OpenAI `reasoning_content` or Anthropic `thinking_delta` chunks.
 - Streaming mode is supported as compatibility SSE. The adapter buffers the upstream Antigravity stream, then emits one OpenAI/Anthropic-compatible final delta. Native token-by-token pass-through is not implemented yet.
@@ -467,6 +467,13 @@ Current adapter scope:
 - Responses-compatible tool support is currently limited to `type: "function"` tools. Built-in tools like `web_search`, `file_search`, `computer`, or `code_interpreter` are rejected explicitly.
 
 
+## Contributors
+
+Thanks to these amazing people who have contributed to the project:
+
+- **[@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))
+
+
 ## Connecting Codex / VS Code Agents
 
 `pi-antigravity-rotator` can act as the multi-account rotation backend for agentic frameworks, including **Codex** executing in VS Code or in the terminal.

package/package.json

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

@@ -10,7 +10,7 @@ import { withRotation, flattenHeaders, type RequestBody } from "./proxy.js";
 const compatLogger = logger.child("compat");
 
 export interface ChatMessage {
-	role: "system" | "user" | "assistant" | "model" | "tool";
+	role: "system" | "developer" | "user" | "assistant" | "model" | "tool";
 	content: string | Array<{ type: string; text?: string;[key: string]: unknown }> | null;
 	tool_calls?: OpenAIToolCall[];
 	tool_call_id?: string;
@@ -470,16 +470,17 @@ function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
 					}
 				}
 
-				// General case: recurse and sanitize each variant.
+				// 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.
 				const cleaned = value.map(sanitizeClaudeViaGeminiSchema).filter(
 					(v) => isRecord(v) && Object.keys(v).length > 0,
 				);
-				if (cleaned.length === 1) {
+				if (cleaned.length >= 1) {
 					Object.assign(out, cleaned[0]);
-				} else if (cleaned.length > 1) {
-					out[key] = cleaned;
 				}
-				// cleaned.length === 0: skip entirely
 			}
 			continue;
 		}
@@ -531,7 +532,7 @@ function convertToolChoiceToGemini(toolChoice: unknown): GeminiToolConfig | unde
 function validateMessages(value: unknown): value is ChatMessage[] {
 	return Array.isArray(value) && value.every((msg) => {
 		if (!isRecord(msg)) return false;
-		if (!["system", "user", "assistant", "model", "tool"].includes(String(msg.role))) return false;
+		if (!["system", "developer", "user", "assistant", "model", "tool"].includes(String(msg.role))) return false;
 		return typeof msg.content === "string" || msg.content === null || Array.isArray(msg.content);
 	});
 }
@@ -1009,7 +1010,7 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	// Separate system messages from conversation turns
 	const systemParts: string[] = [];
 	const conversationMessages = input.messages.filter((msg) => {
-		if (msg.role === "system") {
+		if (msg.role === "system" || msg.role === "developer") {
 			const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
 			if (text) systemParts.push(text);
 			return false;
@@ -1209,16 +1210,109 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	};
 }
 
+/** Convert Anthropic tools [{name, description, input_schema}] → OpenAI format [{type:"function", function:{name, description, parameters}}] */
+function convertAnthropicToolsToOpenAI(tools: unknown): OpenAITool[] | undefined {
+	if (!Array.isArray(tools) || tools.length === 0) return undefined;
+	const result: OpenAITool[] = [];
+	for (const t of tools) {
+		if (!isRecord(t) || !isNonEmptyString(t.name)) continue;
+		result.push({
+			type: "function",
+			function: {
+				name: t.name as string,
+				...(typeof t.description === "string" ? { description: t.description } : {}),
+				...(isRecord(t.input_schema) ? { parameters: t.input_schema as Record<string, unknown> } : {}),
+			},
+		});
+	}
+	return result.length > 0 ? result : undefined;
+}
+
+/** Convert Anthropic tool_choice → OpenAI tool_choice */
+function convertAnthropicToolChoice(toolChoice: unknown): unknown {
+	if (!isRecord(toolChoice)) return toolChoice;
+	if (toolChoice.type === "auto") return "auto";
+	if (toolChoice.type === "any") return "required";
+	if (toolChoice.type === "tool" && isNonEmptyString(toolChoice.name)) {
+		return { type: "function", function: { name: toolChoice.name } };
+	}
+	return "auto";
+}
+
+/**
+ * Convert Anthropic-format messages (tool_use / tool_result content blocks)
+ * to OpenAI-format messages (tool_calls array / role:"tool" messages).
+ */
+function convertAnthropicMessagesToOpenAI(messages: ChatMessage[]): ChatMessage[] {
+	const result: ChatMessage[] = [];
+	for (const msg of messages) {
+		// Assistant messages with tool_use content blocks → tool_calls
+		if (msg.role === "assistant" && Array.isArray(msg.content)) {
+			const blocks = msg.content as Array<Record<string, unknown>>;
+			const toolUseBlocks = blocks.filter(
+				(b) => isRecord(b) && b.type === "tool_use" && isNonEmptyString(b.name),
+			);
+			if (toolUseBlocks.length > 0) {
+				const textParts = blocks
+					.filter((b) => isRecord(b) && b.type === "text" && typeof b.text === "string")
+					.map((b) => b.text as string)
+					.join("");
+				const toolCalls: OpenAIToolCall[] = toolUseBlocks.map((b) => ({
+					id: (b.id as string) || `call_${Date.now().toString(36)}`,
+					type: "function" as const,
+					function: {
+						name: b.name as string,
+						arguments: typeof b.input === "string" ? b.input : JSON.stringify(b.input ?? {}),
+					},
+				}));
+				result.push({ role: "assistant", content: textParts || null, tool_calls: toolCalls });
+				continue;
+			}
+		}
+		// User messages with tool_result content blocks → role:"tool" messages
+		if (msg.role === "user" && Array.isArray(msg.content)) {
+			const blocks = msg.content as Array<Record<string, unknown>>;
+			const toolResults = blocks.filter((b) => isRecord(b) && b.type === "tool_result");
+			if (toolResults.length > 0) {
+				const otherBlocks = blocks.filter((b) => !isRecord(b) || b.type !== "tool_result");
+				if (otherBlocks.length > 0) {
+					result.push({ role: "user", content: otherBlocks as ChatMessage["content"] });
+				}
+				for (const tr of toolResults) {
+					const content = typeof tr.content === "string"
+						? tr.content
+						: Array.isArray(tr.content)
+						? extractTextFromUnknownContent(tr.content)
+						: JSON.stringify(tr.content ?? "");
+					result.push({
+						role: "tool",
+						content,
+						tool_call_id: tr.tool_use_id as string,
+					});
+				}
+				continue;
+			}
+		}
+		result.push(msg);
+	}
+	return result;
+}
+
 export function anthropicToAntigravityBody(input: AnthropicMessagesRequest): RequestBody {
 	const systemText = typeof input.system === "string" ? input.system : Array.isArray(input.system) ? extractText(input.system as ChatMessage["content"]) : "";
+	const tools = convertAnthropicToolsToOpenAI(input.tools);
+	const toolChoice = convertAnthropicToolChoice(input.tool_choice);
+	const convertedMessages = convertAnthropicMessagesToOpenAI(input.messages);
 	return openAIToAntigravityBody({
 		model: input.model,
 		stream: input.stream,
 		temperature: input.temperature,
 		max_tokens: input.max_tokens,
+		tools,
+		tool_choice: toolChoice,
 		messages: [
 			...(systemText ? [{ role: "system" as const, content: systemText }] : []),
-			...input.messages,
+			...convertedMessages,
 		],
 	});
 }
@@ -1410,11 +1504,28 @@ function writeAnthropicStream(res: ServerResponse, model: string, completion: Co
 		res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: contentIndex })}\n\n`);
 		contentIndex++;
 	}
-	res.write(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: contentIndex, content_block: { type: "text", text: "" } })}\n\n`);
-	if (completion.text) res.write(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: contentIndex, delta: { type: "text_delta", text: completion.text } })}\n\n`);
-	res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: contentIndex })}\n\n`);
+	if (completion.text) {
+		res.write(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: contentIndex, content_block: { type: "text", text: "" } })}\n\n`);
+		res.write(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: contentIndex, delta: { type: "text_delta", text: completion.text } })}\n\n`);
+		res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: contentIndex })}\n\n`);
+		contentIndex++;
+	}
+	// Emit tool_use content blocks if present
+	let hasToolUse = false;
+	if (completion.toolCalls && completion.toolCalls.length > 0) {
+		hasToolUse = true;
+		for (const tc of completion.toolCalls) {
+			let parsedInput: unknown;
+			try { parsedInput = JSON.parse(tc.function.arguments || "{}"); } catch { parsedInput = {}; }
+			res.write(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: contentIndex, content_block: { type: "tool_use", id: tc.id, name: tc.function.name, input: {} } })}\n\n`);
+			res.write(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: contentIndex, delta: { type: "input_json_delta", partial_json: JSON.stringify(parsedInput) } })}\n\n`);
+			res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: contentIndex })}\n\n`);
+			contentIndex++;
+		}
+	}
+	const stopReason = hasToolUse ? "tool_use" : "end_turn";
 	// message_delta: include both input_tokens and output_tokens so hermes shows full context count
-	res.write(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { input_tokens: completion.inputTokens, output_tokens: completion.outputTokens } })}\n\n`);
+	res.write(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: stopReason, stop_sequence: null }, usage: { input_tokens: completion.inputTokens, output_tokens: completion.outputTokens } })}\n\n`);
 	res.write(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`);
 	res.end();
 }
@@ -1448,6 +1559,8 @@ async function streamCompatSse(
 
 	let anthropicActiveBlockIndex = -1;
 	let anthropicActiveBlockType: "thinking" | "text" | null = null;
+	let anthropicHasToolUse = false;
+	const anthropicToolCalls: OpenAIToolCall[] = [];
 
 	res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" });
 
@@ -1539,6 +1652,20 @@ async function streamCompatSse(
 								}
 								if (format === "openai") {
 									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
+									if (anthropicActiveBlockType !== null) {
+										res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: anthropicActiveBlockIndex })}\n\n`);
+										anthropicActiveBlockType = null;
+									}
+									anthropicActiveBlockIndex++;
+									anthropicHasToolUse = true;
+									anthropicToolCalls.push({ id: callId, type: "function", function: { name, arguments: args } });
+									let parsedInput: unknown;
+									try { parsedInput = JSON.parse(args); } catch { parsedInput = {}; }
+									res.write(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: anthropicActiveBlockIndex, content_block: { type: "tool_use", id: callId, name, input: {} } })}\n\n`);
+									res.write(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: anthropicActiveBlockIndex, delta: { type: "input_json_delta", partial_json: JSON.stringify(parsedInput) } })}\n\n`);
+									res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: anthropicActiveBlockIndex })}\n\n`);
 								}
 							}
 						}
@@ -1571,14 +1698,15 @@ async function streamCompatSse(
 			if (anthropicActiveBlockType !== null) {
 				res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: anthropicActiveBlockIndex })}\n\n`);
 			}
+			const anthropicStopReason = anthropicHasToolUse ? "tool_use" : "end_turn";
 			// message_delta carries output_tokens; also include input_tokens so Hermes shows full context count
-			res.write(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { input_tokens: inputTokens, output_tokens: outputTokens } })}\n\n`);
+			res.write(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: anthropicStopReason, stop_sequence: null }, usage: { input_tokens: inputTokens, output_tokens: outputTokens } })}\n\n`);
 			res.write(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`);
 		}
 		res.end();
 	}
 
-	return { text, inputTokens, outputTokens, responseId, toolCalls: undefined };
+	return { text, inputTokens, outputTokens, responseId, toolCalls: anthropicToolCalls.length > 0 ? anthropicToolCalls : undefined };
 }
 
 async function streamResponsesSse(
@@ -2122,18 +2250,28 @@ export async function handleAnthropicMessages(req: IncomingMessage, res: ServerR
 	if (result.streamed) {
 		return;
 	}
+	const contentBlocks: Array<Record<string, unknown>> = [];
+	if (result.completion.thinkingText) {
+		contentBlocks.push({ type: "thinking", thinking: result.completion.thinkingText });
+	}
+	if (result.completion.text) {
+		contentBlocks.push({ type: "text", text: result.completion.text });
+	}
+	if (result.completion.toolCalls && result.completion.toolCalls.length > 0) {
+		for (const tc of result.completion.toolCalls) {
+			let parsedInput: unknown;
+			try { parsedInput = JSON.parse(tc.function.arguments || "{}"); } catch { parsedInput = {}; }
+			contentBlocks.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: parsedInput });
+		}
+	}
+	const stopReason = (result.completion.toolCalls && result.completion.toolCalls.length > 0) ? "tool_use" : "end_turn";
 	writeJson(res, 200, {
 		id: `msg_${started.toString(36)}`,
 		type: "message",
 		role: "assistant",
 		model: validation.value.model,
-		content: result.completion.thinkingText
-			? [
-				{ type: "thinking", thinking: result.completion.thinkingText },
-				{ type: "text", text: result.completion.text }
-			]
-			: [{ type: "text", text: result.completion.text }],
-		stop_reason: "end_turn",
+		content: contentBlocks,
+		stop_reason: stopReason,
 		stop_sequence: null,
 		usage: {
 			input_tokens: result.completion.inputTokens,