pi-antigravity-rotator 2.1.2 → 2.1.4

package/CHANGELOG.md

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

package/README.md

@@ -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.
@@ -493,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

package/package.json

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

@@ -470,16 +470,98 @@ function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
 					}
 				}
 
-				// General case: recurse and sanitize each variant.
+				// 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]);
-				} else if (cleaned.length > 1) {
-					out[key] = cleaned;
+				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;
 				}
-				// cleaned.length === 0: skip entirely
+
+				// 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;
 		}
@@ -1209,16 +1291,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 +1585,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 +1640,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 +1733,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 +1779,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 +2331,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,