pi-antigravity-rotator 2.2.1 → 2.3.0

package/src/cli.ts

@@ -8,56 +8,72 @@
 
 import { getConfigDir } from "./paths.js";
 
-const args = process.argv.slice(2).filter((a) => !a.startsWith("--config-dir") && a !== process.argv[process.argv.indexOf("--config-dir") + 1]);
+const args = process.argv
+  .slice(2)
+  .filter(
+    (a) =>
+      !a.startsWith("--config-dir") &&
+      a !== process.argv[process.argv.indexOf("--config-dir") + 1],
+  );
 const command = args[0] || "start";
 
 console.log(`Config dir: ${getConfigDir()}`);
 console.log();
 
 switch (command) {
-	case "start": {
-		// Dynamic import to avoid loading everything for help
-		const { main } = await import("./index.js");
-		main();
-		break;
-	}
-	case "login": {
-		const { runLogin } = await import("./login.js");
-		runLogin();
-		break;
-	}
-	case "status": {
-		try {
-			const port = 51200;
-			const res = await fetch(`http://localhost:${port}/api/status`);
-			const data = await res.json();
-			console.log(JSON.stringify(data, null, 2));
-		} catch {
-			console.error("Rotator is not running or unreachable on port 51200");
-			process.exit(1);
-		}
-		break;
-	}
-	case "doctor": {
-		const { printDoctorReport, runDoctor } = await import("./doctor.js");
-		const result = runDoctor();
-		printDoctorReport(result);
-		process.exit(result.ok ? 0 : 1);
-		break;
-	}
-	default:
-		console.log("Pi Antigravity Rotator");
-		console.log();
-		console.log("Usage:");
-		console.log("  pi-antigravity-rotator start     Start the proxy (default)");
-		console.log("  pi-antigravity-rotator login     Add a new Google account");
-		console.log("  pi-antigravity-rotator status    Show account status (JSON)");
-		console.log("  pi-antigravity-rotator doctor    Validate config and local state");
-		console.log();
-		console.log("Options:");
-		console.log("  --config-dir <path>    Config directory (default: ~/.pi-antigravity-rotator/)");
-		console.log();
-		console.log("Environment:");
-		console.log("  PI_ROTATOR_DIR         Config directory override");
-		process.exit(command === "help" || command === "--help" ? 0 : 1);
+  case "start": {
+    // Dynamic import to avoid loading everything for help
+    const { main } = await import("./index.js");
+    await main();
+    break;
+  }
+  case "login": {
+    const { initDb } = await import("./db-store.js");
+    await initDb();
+    const { runLogin } = await import("./login.js");
+    await runLogin();
+    break;
+  }
+  case "status": {
+    try {
+      const port = 51200;
+      const res = await fetch(`http://localhost:${port}/api/status`);
+      const data = await res.json();
+      console.log(JSON.stringify(data, null, 2));
+    } catch {
+      console.error("Rotator is not running or unreachable on port 51200");
+      process.exit(1);
+    }
+    break;
+  }
+  case "doctor": {
+    const { initDb } = await import("./db-store.js");
+    await initDb();
+    const { printDoctorReport, runDoctor } = await import("./doctor.js");
+    const result = await runDoctor();
+    printDoctorReport(result);
+    process.exit(result.ok ? 0 : 1);
+    break;
+  }
+  default:
+    console.log("Pi Antigravity Rotator");
+    console.log();
+    console.log("Usage:");
+    console.log("  pi-antigravity-rotator start     Start the proxy (default)");
+    console.log("  pi-antigravity-rotator login     Add a new Google account");
+    console.log(
+      "  pi-antigravity-rotator status    Show account status (JSON)",
+    );
+    console.log(
+      "  pi-antigravity-rotator doctor    Validate config and local state",
+    );
+    console.log();
+    console.log("Options:");
+    console.log(
+      "  --config-dir <path>    Config directory (default: ~/.pi-antigravity-rotator/)",
+    );
+    console.log();
+    console.log("Environment:");
+    console.log("  PI_ROTATOR_DIR         Config directory override");
+    process.exit(command === "help" || command === "--help" ? 0 : 1);
 }

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;
+}