pi-antigravity-rotator 2.2.1 → 2.2.2

package/CHANGELOG.md

@@ -2,13 +2,21 @@
 
 ## [Unreleased]
 
+## [2.2.2] - 2026-06-21
+
+### Fixed
+- **Telemetry HTTPS Error**: Reverted the default telemetry endpoint from `https://` back to `http://` because the backend server does not support SSL, which was causing silent "packet length too long" errors and preventing telemetry and broadcast notifications from working.
+
+### Refactored
+- **Compatibility Layer**: Massively refactored the 2,400-line `src/compat.ts` into smaller, single-responsibility modules under `src/compat/` for easier maintenance. (PR [#11](https://github.com/tuxevil/pi-antigravity-rotator/pull/11) by [@josenicomaia](https://github.com/josenicomaia))
+
 ## [2.2.1] - 2026-06-20
 
 ### Fixed
-- **Support tool response images**: Extracted any image content (`image_url` or `image` formats) from OpenAI tool response content and mapped them to Antigravity `inlineData` parts.
-- **Ordered tool results**: Guaranteed all tool results remain clustered at the top of the parts array, complying with Claude's strict layout requirements.
-- **Dangling tool call filtering**: Filtered out any `tool_calls` that do not have a matching `tool_result` in the subsequent message to prevent `400 Bad Request`.
-- **Inline JSON-Schema union types**: Collapsed Draft-2020-12 inline union type arrays (e.g. `type: ["number", "null"]`) to the first non-null type and lifted nullability into the proto-supported `nullable` flag to fix 400 errors.
+- **Support tool response images**: Extracted any image content (`image_url` or `image` formats) from OpenAI tool response content and mapped them to Antigravity `inlineData` parts. (PR [#9](https://github.com/tuxevil/pi-antigravity-rotator/pull/9) by [@josenicomaia](https://github.com/josenicomaia))
+- **Ordered tool results**: Guaranteed all tool results remain clustered at the top of the parts array, complying with Claude's strict layout requirements. (PR [#9](https://github.com/tuxevil/pi-antigravity-rotator/pull/9) by [@josenicomaia](https://github.com/josenicomaia))
+- **Dangling tool call filtering**: Filtered out any `tool_calls` that do not have a matching `tool_result` in the subsequent message to prevent `400 Bad Request`. (PR [#9](https://github.com/tuxevil/pi-antigravity-rotator/pull/9) by [@josenicomaia](https://github.com/josenicomaia))
+- **Inline JSON-Schema union types**: Collapsed Draft-2020-12 inline union type arrays (e.g. `type: ["number", "null"]`) to the first non-null type and lifted nullability into the proto-supported `nullable` flag to fix 400 errors. (PR [#10](https://github.com/tuxevil/pi-antigravity-rotator/pull/10) by [@yashyadav711](https://github.com/yashyadav711))
 
 ## [2.2.0] - 2026-06-16
 

package/README.md

@@ -153,7 +153,7 @@ If login fails at project discovery:
 
 After starting the proxy, open `http://localhost:51200/dashboard` or `http://<your-server-ip>:51200/dashboard` from any machine on the same network (the proxy binds to `0.0.0.0`).
 
-If `PI_ROTATOR_ADMIN_TOKEN` is unset, dashboard and `/api/*` access remains open for backwards compatibility. v2.0 now surfaces loud warnings about that state in startup logs, `/api/status`, and the dashboard itself.
+If `PI_ROTATOR_ADMIN_TOKEN` is unset, the proxy automatically generates a cryptographically secure token on first run and saves it to a `.admin-token` file in the root directory. This token will be printed to the console on first startup. You must append `?token=<your-token>` to the dashboard URL to access it, or set `PI_ROTATOR_ADMIN_TOKEN` in your environment to override it.
 
 The dashboard shows:
 
@@ -285,7 +285,7 @@ Config files (`accounts.json`, `state.json`) are stored in `~/.pi-antigravity-ro
 # Environment variables
 export PI_ROTATOR_DIR=/path/to/config
 export PI_ROTATOR_QUOTA_USER_AGENT="antigravity/1.107.0 darwin/arm64"
-# Optional: require this token for dashboard/API access. If unset, legacy open access is preserved.
+# Optional: require this token for dashboard/API access. If unset, a secure token is auto-generated.
 export PI_ROTATOR_ADMIN_TOKEN="change-me"
 # Optional: bind the proxy to a safer local-only interface.
 export PI_ROTATOR_BIND_HOST="127.0.0.1"
@@ -410,7 +410,7 @@ Login now fails if Google does not return a project ID. No shared fallback.
 | `POST` | `/v1/chat/completions` | OpenAI-compatible non-streaming chat adapter |
 | `POST` | `/v1/messages` | Anthropic-compatible non-streaming messages adapter |
 
-If `PI_ROTATOR_ADMIN_TOKEN` is set, dashboard/API requests must include either `Authorization: Bearer <token>`, `X-Rotator-Admin-Token: <token>`, or `?token=<token>` for browser dashboard access. The native pi proxy endpoint and compatibility adapters remain unauthenticated so existing clients keep working. Put this service behind a trusted local boundary if exposing beyond localhost/LAN.
+Dashboard and internal `/api/*` requests must include either `Authorization: Bearer <token>`, `X-Rotator-Admin-Token: <token>`, or `?token=<token>` for browser dashboard access. The native pi proxy endpoint and compatibility adapters (`/v1/*`) remain unauthenticated by design, so your AI agents and existing clients will keep working without requiring a token. Put this service behind a trusted local boundary if exposing beyond localhost/LAN.
 
 ### Compatibility Adapters
 
@@ -471,7 +471,8 @@ 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))
+- **[@josenicomaia](https://github.com/josenicomaia)** (José Nicodemos Maia Neto) — Modularized the compatibility layer architecture, added multimodal tool response support, and fixed streaming pass-through for tool executions. ([PR #8](https://github.com/tuxevil/pi-antigravity-rotator/pull/8), [PR #9](https://github.com/tuxevil/pi-antigravity-rotator/pull/9), [PR #11](https://github.com/tuxevil/pi-antigravity-rotator/pull/11))
+- **[@yashyadav711](https://github.com/yashyadav711)** (Yash) — Fixed Draft-2020-12 inline JSON-Schema union type mapping for Gemini tools support. ([PR #10](https://github.com/tuxevil/pi-antigravity-rotator/pull/10))
 - **[@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))
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Multi-account rotation proxy for Google Antigravity with per-model routing, real-time quota tracking, and infringement detection",
   "license": "MIT",
   "type": "module",
@@ -42,11 +42,13 @@
   },
   "author": "Sebastián Real (tuxevil)",
   "dependencies": {
+    "pg": "^8.22.0",
     "tsx": "^4.19.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
+    "@types/pg": "^8.20.0",
     "c8": "^11.0.0",
     "eslint": "^10.5.0",
     "typescript": "^5.7.0",

package/src/compat/cache.ts

@@ -0,0 +1,42 @@
+import { ResponsesStore, type StoredResponseEntry } from "../responses-store.js";
+
+export const thoughtSignatureCache = new Map<string, string>();
+const THOUGHT_SIGNATURE_CACHE_MAX = 500;
+export const responsesStore = new ResponsesStore();
+
+export function makeCompatId(prefix: string): string {
+	return `${prefix}_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function getStoredResponse(id: string): StoredResponseEntry | null {
+	return responsesStore.get(id);
+}
+
+export function setStoredResponse(id: string, entry: StoredResponseEntry): void {
+	responsesStore.set(id, entry);
+}
+
+export function resetResponsesStoreForTests(): void {
+	responsesStore.clear();
+}
+
+export async function loadResponsesStore(): Promise<void> {
+	await responsesStore.load();
+}
+
+export async function flushResponsesStore(): Promise<void> {
+	await responsesStore.flush();
+}
+
+export function flushResponsesStoreSync(): void {
+	responsesStore.flushSync();
+}
+
+export function cacheThoughtSignature(callId: string, signature: string): void {
+	if (thoughtSignatureCache.size >= THOUGHT_SIGNATURE_CACHE_MAX) {
+		// Evict the oldest entry
+		const firstKey = thoughtSignatureCache.keys().next().value;
+		if (firstKey !== undefined) thoughtSignatureCache.delete(firstKey);
+	}
+	thoughtSignatureCache.set(callId, signature);
+}

package/src/compat/model-specs.ts

@@ -0,0 +1,78 @@
+export interface ModelSpec {
+	maxOutputTokens: number;
+	thinkingBudget: number; // -1 = adaptive (model decides), >=0 = fixed
+	isThinking: boolean;
+}
+
+export const DEFAULT_MODEL_SPECS: Record<string, ModelSpec> = {
+	"gemini-pro-agent":          { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3-flash-agent":      { maxOutputTokens: 65536, thinkingBudget: 10000, isThinking: true },
+	"gemini-3-pro-high":         { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3-pro-low":          { maxOutputTokens: 65535, thinkingBudget: 1001,  isThinking: true },
+	"gemini-3.1-pro":            { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3.1-pro-high":       { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3.1-pro-low":        { maxOutputTokens: 65535, thinkingBudget: 1001,  isThinking: true },
+	"gemini-3.1-pro-preview":    { maxOutputTokens: 65535, thinkingBudget: 10001, isThinking: true },
+	"gemini-3.5-flash":          { maxOutputTokens: 65536, thinkingBudget: 10000, isThinking: true },
+	"gemini-3.5-flash-medium":   { maxOutputTokens: 65536, thinkingBudget: 4000,  isThinking: true },
+	"gemini-3.5-flash-low":      { maxOutputTokens: 65536, thinkingBudget: 4000,  isThinking: true },
+	"gemini-3.5-flash-high":     { maxOutputTokens: 65536, thinkingBudget: 10000, isThinking: true },
+	"gemini-3-flash":            { maxOutputTokens: 65536, thinkingBudget: 4000,  isThinking: true },
+	"gemini-2.5-flash":          { maxOutputTokens: 65535, thinkingBudget: 24576, isThinking: true },
+	"gemini-2.5-pro":            { maxOutputTokens: 65535, thinkingBudget: 1024,  isThinking: true },
+	"claude-sonnet-4-6":         { maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+	"claude-sonnet-4-6-thinking":{ maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+	"claude-opus-4-6-thinking":  { maxOutputTokens: 64000, thinkingBudget: 32768, isThinking: true },
+	"gpt-oss-120b-medium":       { maxOutputTokens: 32768, thinkingBudget: 8192,  isThinking: true },
+	"gpt-oss-120b":              { maxOutputTokens: 32768, thinkingBudget: 8192,  isThinking: true },
+};
+
+let modelSpecsOverride: Record<string, ModelSpec> | null = null;
+
+/**
+ * Replace the bundled model spec table with operator-provided overrides.
+ * Pass `null` to restore defaults. Called once at startup from index.ts.
+ */
+export function setModelSpecsOverride(specs: Record<string, ModelSpec> | null): void {
+	modelSpecsOverride = specs && Object.keys(specs).length > 0 ? specs : null;
+}
+
+export function getActiveModelSpecs(): Record<string, ModelSpec> {
+	return modelSpecsOverride ?? DEFAULT_MODEL_SPECS;
+}
+
+const GEMINI_MAX_OUTPUT_TOKENS = 65536;
+const CLAUDE_MAX_OUTPUT_TOKENS = 64000;
+const FALLBACK_THINKING_BUDGET = 24576;
+const CLAUDE_DEFAULT_THINKING_BUDGET = 32768;
+
+export function getModelFamily(model: string): "claude" | "gemini" | "unknown" {
+	const l = model.toLowerCase();
+	if (l.includes("claude")) return "claude";
+	if (l.includes("gemini")) return "gemini";
+	return "unknown";
+}
+
+export function getModelSpec(model: string): ModelSpec {
+	const specs = getActiveModelSpecs();
+	const lower = model.toLowerCase();
+	if (specs[lower]) return specs[lower];
+	for (const [key, spec] of Object.entries(specs)) {
+		if (lower.includes(key)) return spec;
+	}
+	const family = getModelFamily(model);
+	if (family === "claude") return { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS, thinkingBudget: CLAUDE_DEFAULT_THINKING_BUDGET, isThinking: true };
+	if (family === "gemini") return { maxOutputTokens: GEMINI_MAX_OUTPUT_TOKENS, thinkingBudget: FALLBACK_THINKING_BUDGET, isThinking: true };
+	return { maxOutputTokens: 65536, thinkingBudget: FALLBACK_THINKING_BUDGET, isThinking: false };
+}
+
+export function isThinkingModel(model: string): boolean {
+	const spec = getModelSpec(model);
+	if (spec.isThinking) return true;
+	const l = model.toLowerCase();
+	if (l.includes("gemini")) {
+		const m = l.match(/gemini-(\d+)/);
+		if (m && parseInt(m[1], 10) >= 3) return true;
+	}
+	return false;
+}

package/src/compat/schema-sanitizer.ts

@@ -0,0 +1,277 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Gemini's function_declarations accept a restricted subset of JSON Schema.
+ * Keywords like `const`, `$schema`, `$ref`, `$defs`, `if/then/else`, `not`,
+ * `patternProperties`, etc. are not supported and will cause a 400.
+ * This function recursively strips those unsupported keywords.
+ */
+export function sanitizeGeminiSchema(schema: unknown): unknown {
+	if (!isRecord(schema)) return schema;
+
+	// Keywords Gemini does not support
+	const UNSUPPORTED = new Set([
+		"const", "$schema", "$id", "$ref", "$defs", "definitions",
+		"if", "then", "else", "not",
+		"patternProperties", "unevaluatedProperties", "unevaluatedItems",
+		"contentEncoding", "contentMediaType", "examples",
+		"exclusiveMinimum", "exclusiveMaximum", "minimum", "maximum",
+		"multipleOf", "minLength", "maxLength", "pattern",
+		"minItems", "maxItems", "uniqueItems",
+		"minProperties", "maxProperties", "title", "default",
+	]);
+
+	const out: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (UNSUPPORTED.has(key)) continue;
+
+		if (key === "anyOf" || key === "oneOf" || key === "allOf") {
+			if (Array.isArray(value)) {
+				// Special case: all items are pure {const: value} — this is the
+				// JSON Schema way of writing an enum. Convert to Gemini's `enum` array.
+				const allConst = value.every(
+					(item) => isRecord(item) && Object.keys(item).length === 1 && "const" in item,
+				);
+				if (allConst) {
+					out["enum"] = value.map((item) => (item as Record<string, unknown>)["const"]);
+					// Infer type:string when all const values are strings (covers most tool params)
+					if (value.every((item) => typeof (item as Record<string, unknown>)["const"] === "string")) {
+						if (!out["type"]) out["type"] = "string";
+					}
+				} else {
+					const cleaned = value.map(sanitizeGeminiSchema).filter(
+						// Drop entries that become empty objects after sanitisation
+						(v) => isRecord(v) && Object.keys(v).length > 0,
+					);
+					// If only one variant remains, unwrap it (Gemini prefers flat schemas)
+					if (cleaned.length === 1) {
+						Object.assign(out, cleaned[0]);
+					} else if (cleaned.length > 1) {
+						out[key] = cleaned;
+					}
+					// cleaned.length === 0: skip entirely
+				}
+			}
+			continue;
+		}
+
+		// Inline union type: `type: ["number","null"]`. Gemini's proto `type`
+		// field is a single enum, not repeating — collapse to the first non-null
+		// type and lift nullability into the proto-supported `nullable` flag.
+		if (key === "type" && Array.isArray(value)) {
+			const nonNull = (value as unknown[]).filter((t) => t !== "null");
+			if ((value as unknown[]).includes("null")) out["nullable"] = true;
+			out["type"] = (nonNull[0] ?? "string");
+			continue;
+		}
+
+		if (key === "properties" && isRecord(value)) {
+			out[key] = Object.fromEntries(
+				Object.entries(value).map(([k, v]) => [k, sanitizeGeminiSchema(v)]),
+			);
+			continue;
+		}
+
+		if (key === "items") {
+			out[key] = sanitizeGeminiSchema(value);
+			continue;
+		}
+
+		out[key] = isRecord(value) ? sanitizeGeminiSchema(value) : value;
+	}
+	return out;
+}
+
+/**
+ * Lighter sanitization for Claude models routed through Gemini's API.
+ * Gemini's outer API still validates schemas before routing to Claude, so
+ * we must remove fields Gemini's protobuf doesn't know about (like `const`,
+ * `$ref`, etc.). However, unlike the Gemini-native sanitizer, we KEEP
+ * standard JSON Schema Draft 2020-12 keywords (minimum, maximum, pattern,
+ * etc.) that Claude requires and that Gemini's API does pass through.
+ */
+export function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
+	if (!isRecord(schema)) return schema;
+
+	// Only remove fields that Gemini's API layer truly rejects at the network level.
+	// We keep standard Draft 2020-12 keywords but must strip exclusiveMinimum/exclusiveMaximum
+	// as boolean values (Draft 4) — the API layer rejects them even for Claude-bound requests.
+	const UNSUPPORTED = new Set([
+		"$schema", "$id", "$ref", "$defs", "definitions",
+		"if", "then", "else", "not",
+		"patternProperties", "unevaluatedProperties", "unevaluatedItems",
+		"contentEncoding", "contentMediaType",
+		// Gemini's protobuf layer rejects these regardless of target model
+		"exclusiveMinimum", "exclusiveMaximum",
+	]);
+
+	const out: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (UNSUPPORTED.has(key)) continue;
+
+		// `const` is not supported by Gemini's API — convert to a single-value enum
+		if (key === "const") {
+			out["enum"] = [value];
+			continue;
+		}
+
+		if (key === "anyOf" || key === "oneOf" || key === "allOf") {
+			if (Array.isArray(value)) {
+				// Case 1: all items are pure {const: value} — convert to flat enum.
+				const allPureConst = value.every(
+					(item) => isRecord(item) && Object.keys(item).length === 1 && "const" in item,
+				);
+				if (allPureConst) {
+					out["enum"] = value.map((item) => (item as Record<string, unknown>)["const"]);
+					if (value.every((item) => typeof (item as Record<string, unknown>)["const"] === "string")) {
+						if (!out["type"]) out["type"] = "string";
+					}
+					continue;
+				}
+
+				// Case 2: all items are {type: T, const: V} (same type, each with a const).
+				// e.g. [{type:"string",const:"fact"},{type:"string",const:"lesson"}]
+				// Merge into a single flat {type: T, enum: [V1, V2, ...]} — avoids
+				// the redundant anyOf-with-single-enum pattern that Claude rejects.
+				const allTypeConst = value.every(
+					(item) =>
+						isRecord(item) &&
+						Object.keys(item).length === 2 &&
+						"type" in item &&
+						"const" in item,
+				);
+				if (allTypeConst) {
+					const firstType = (value[0] as Record<string, unknown>)["type"];
+					const allSameType = value.every((item) => (item as Record<string, unknown>)["type"] === firstType);
+					if (allSameType) {
+						if (!out["type"]) out["type"] = firstType;
+						out["enum"] = value.map((item) => (item as Record<string, unknown>)["const"]);
+						continue;
+					}
+				}
+
+				// 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 (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;
+		}
+
+		// Inline union type: `type: ["number","null"]`. Gemini's proto `type`
+		// field is a single enum, not repeating — an array value triggers a 400
+		// ('Proto field is not repeating'). Collapse to the first non-null type
+		// and lift nullability into the proto-supported `nullable` flag.
+		if (key === "type" && Array.isArray(value)) {
+			const nonNull = (value as unknown[]).filter((t) => t !== "null");
+			if ((value as unknown[]).includes("null")) out["nullable"] = true;
+			out["type"] = (nonNull[0] ?? "string");
+			continue;
+		}
+
+		if (key === "properties" && isRecord(value)) {
+			out[key] = Object.fromEntries(
+				Object.entries(value).map(([k, v]) => [k, sanitizeClaudeViaGeminiSchema(v)]),
+			);
+			continue;
+		}
+
+		if (key === "items") {
+			out[key] = sanitizeClaudeViaGeminiSchema(value);
+			continue;
+		}
+
+		out[key] = isRecord(value) ? sanitizeClaudeViaGeminiSchema(value) : value;
+	}
+	return out;
+}