pi-antigravity-rotator 2.1.6 → 2.2.1

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [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.
+
+## [2.2.0] - 2026-06-16
+
+### Security
+
+### Security
+- **Admin token autogeneration**: On first run with no `PI_ROTATOR_ADMIN_TOKEN` env var, a cryptographically secure token is generated, persisted to `.admin-token` (mode 0600), and printed once to the operator. Dashboard and `/api/*` routes are now protected by default on fresh installs. Override the generated token by setting `PI_ROTATOR_ADMIN_TOKEN` in the env. `.admin-token` added to `.gitignore`.
+- **Querystring secret redaction**: `redactSensitive()` now also redacts `access_token`, `token`, `api_key`, `apikey`, `key`, `refresh_token` when they appear in querystring (`?key=val&...`) or URL fragment.
+- **OAuth fallback warning**: New `warnIfUsingFallbackOAuthCreds()` detects when `ANTIGRAVITY_CLIENT_ID` and/or `ANTIGRAVITY_CLIENT_SECRET` are missing and emits a one-time warning that the rotator is using the public Antigravity IDE client.
+- **Removed open CORS**: `Access-Control-Allow-Origin: *` removed from `/api/status` and `/api/config`. Replaced with `Cache-Control: no-store`. Dashboard still works same-origin.
+- **Truncated/redacted validation logs**: New `logValidationFailure()` truncates payloads to 200 chars and runs them through `redactSensitive` before logging. Applied to OpenAI messages validation and stream error logs in `compat.ts`.
+
+### Added
+- **`Config.modelSpecs`**: Operators can now override the per-model thinking/output spec table used by the compat layer without recompiling. Add a `modelSpecs` field to `accounts.json` and call `setModelSpecsOverride()` at boot (done automatically by `index.ts`).
+- **`warnIfInsecureTelemetryEndpoint()`**: Detects plain `http://` telemetry endpoints and emits a one-time warning. Default endpoint switched to `https://`. Override via `PI_ROTATOR_TELEMETRY_URL`. Silence via `PI_ROTATOR_TELEMETRY_INSECURE_OK=1`.
+- **Persistent `responsesStore`**: The OpenAI Responses API store (used by Codex via `previous_response_id`) is now persisted to `<configDir>/responses.json` with atomic writes and a 1.5s debounce. Restart-safe: in-flight Codex conversations continue across rotator restarts. New `src/responses-store.ts` with `load()`, `flush()`, `flushSync()`. Corrupt files are moved aside to `.corrupt-<ts>.bak` on startup.
+- **Debounced state writes**: Hot paths (`recordRequest`, `markExhausted`, `markError`, `markFlagged`) now call `scheduleStateSave()` instead of `saveState()`, coalescing multiple writes within a 1s window into a single disk write. New `flushPendingStateSaveSync()` in the SIGTERM/SIGINT shutdown handler drains the queue synchronously to minimise data loss.
+- **GitHub Actions CI**: New `.github/workflows/ci.yml` runs `npm ci` + `npm run check` (typecheck + 191 tests) on push and PR to `main`. Node 22 with npm cache. PRs without green checks cannot be merged.
+- **8 e2e proxy tests** (`test/proxy-e2e.test.ts`): Cover the full proxy flow with a local HTTP server as mock Antigravity — 200 happy path, 429 rate-limited (Retry-After and RESOURCE_EXHAUSTED), 401 unauthorized, 403 flagged and non-flagged, 500 server error, endpoint cascade (daily→prod).
+- **7 dashboard tests** (`test/dashboard.test.ts`): Verify utf-8/viewport meta tags, all 12 admin API endpoints are referenced, the `escapeHtml`/`jsString`/`maskText`/`maskEmail` helpers are present and `escapeHtml` correctly escapes the 5 HTML-sensitive characters, no hardcoded OAuth secrets or refresh tokens leak into the HTML.
+
+### Changed
+- **Refactored `proxy.ts`**: Extracted `classifyUpstreamResponse()` that returns a discriminated `UpstreamAction`. Both `withRotation()` and `handleProxyRequest()` dispatch against the helper instead of duplicating the 401/403/404/400/429/5xx branches. ~150 lines of parallel code removed. New `UpstreamAction` type with 9 action kinds.
+
+### Cleanup
+- **Removed `src/antigravity-prompt.ts`**: 80-line `ANTIGRAVITY_IDENTITY_PROMPT` export with 0 references in the repo.
+- **Consolidated agent docs**: `CLAUDE.md` now points to `AGENTS.md` as the single source of truth. The duplicated BEADS INTEGRATION block is gone.
+- **Moved scripts to `scripts/`**: 10 one-off utility scripts (`mitm.js`, `mock_google.js`, `query_models.{js,ts}`, `test-compat.ts`, `test-direct.js`, `test_generate.js`, `test_loop.js`, `test-http.cjs`, `test-openai.cjs`) moved from the repo root. `query_models.ts` and `test-compat.ts` updated to use `../src/...` relative imports after the move.
+
+## [2.2.1] - 2026-06-16
+
+### Fixed
+- **SSE usage extraction cross-event matching**: The old `extractTokenUsage()` ran a regex on the last 32KB of the upstream body, which could match across SSE event boundaries and return incorrect `(input, output)` pairs. Replaced with `SseEventAccumulator` + `extractUsageFromSseEvent()` that buffer complete SSE events (split on `\n\n`), parse each `data:` payload as JSON, and recursively search for `usageMetadata` (Gemini) or `usage` (OpenAI/Anthropic). Regex remains as a last-resort fallback for malformed JSON. Real-time streaming is preserved — the `res.write(chunk)` in `onData` is unchanged. Resolves ROADMAP §2.
+
 ## [2.1.6] - 2026-06-12
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "2.1.6",
+  "version": "2.2.1",
   "description": "Multi-account rotation proxy for Google Antigravity with per-model routing, real-time quota tracking, and infringement detection",
   "license": "MIT",
   "type": "module",
@@ -12,7 +12,9 @@
     "login": "tsx src/cli.ts login",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx/esm --test \"test/**/*.test.ts\"",
-    "check": "npm run typecheck && npm test"
+    "lint": "eslint src test",
+    "coverage": "c8 --reporter=text --reporter=html npm test",
+    "check": "npm run typecheck && npm test && npm run lint"
   },
   "files": [
     "bin/",
@@ -43,7 +45,11 @@
     "tsx": "^4.19.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
+    "c8": "^11.0.0",
+    "eslint": "^10.5.0",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.61.1"
   }
 }

package/src/account-store.ts

@@ -102,7 +102,37 @@ export function saveAccountsConfig(config: Config): void {
 	writeJsonFileAtomic(ACCOUNTS_FILE, applyConfigDefaults(config));
 }
 
+// Reasonable upper bounds on per-account fields. These are defensive
+// limits to prevent a malicious or buggy caller from growing
+// accounts.json without bound, which would slow every subsequent
+// saveState. The numbers are well above any realistic real value.
+export const MAX_EMAIL_LENGTH = 254; // RFC 5321
+export const MAX_LABEL_LENGTH = 100;
+export const MAX_PROJECT_ID_LENGTH = 100;
+export const MAX_REFRESH_TOKEN_LENGTH = 4096;
+
+function validateAccountConfigLengths(entry: AccountConfig): void {
+	const checks: Array<[string, number]> = [
+		["email", MAX_EMAIL_LENGTH],
+		["label", MAX_LABEL_LENGTH],
+		["projectId", MAX_PROJECT_ID_LENGTH],
+		["refreshToken", MAX_REFRESH_TOKEN_LENGTH],
+	];
+	for (const [field, max] of checks) {
+		const value = entry[field as keyof AccountConfig];
+		if (typeof value === "string" && value.length > max) {
+			throw new Error(
+				`Account ${field} exceeds maximum length ${max} (got ${value.length}). ` +
+				`This usually indicates a malformed input — refusing to write to accounts.json.`,
+			);
+		}
+	}
+}
+
+export { validateAccountConfigLengths };
+
 export function addAccountToConfig(entry: AccountConfig): { isNew: boolean } {
+	validateAccountConfigLengths(entry);
 	const config = loadOrCreateAccountsConfig();
 	const existing = config.accounts.findIndex((a) => a.email === entry.email);
 

package/src/admin-auth.ts

@@ -1,13 +1,96 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { join } from "node:path";
 
 interface AdminAuthRequest {
 	url?: string;
 	headers: IncomingMessage["headers"];
 }
 
+const ADMIN_TOKEN_FILENAME = ".admin-token";
+
+let persistedToken: string | null = null;
+
+/**
+ * Set the persisted admin token at runtime. Called by index.ts after
+ * ensureAdminToken resolves the effective token. Subsequent calls to
+ * getConfiguredAdminToken() will return this token if no env var is set.
+ */
+export function setPersistedAdminToken(token: string | null): void {
+	persistedToken = token && token.length > 0 ? token : null;
+}
+
 export function getConfiguredAdminToken(env: NodeJS.ProcessEnv = process.env): string | null {
 	const token = env.PI_ROTATOR_ADMIN_TOKEN?.trim();
-	return token ? token : null;
+	if (token) return token;
+	return persistedToken;
+}
+
+/**
+ * Generate a cryptographically secure admin token (32 random bytes, hex).
+ * 64 hex characters = 256 bits of entropy.
+ */
+export function generateAdminToken(): string {
+	return randomBytes(32).toString("hex");
+}
+
+export function readPersistedAdminToken(configDir: string): string | null {
+	const tokenPath = join(configDir, ADMIN_TOKEN_FILENAME);
+	if (!existsSync(tokenPath)) return null;
+	try {
+		const raw = readFileSync(tokenPath, "utf-8").trim();
+		return raw ? raw : null;
+	} catch {
+		return null;
+	}
+}
+
+export function writePersistedAdminToken(configDir: string, token: string): void {
+	const tokenPath = join(configDir, ADMIN_TOKEN_FILENAME);
+	writeFileSync(tokenPath, token, { mode: 0o600, encoding: "utf-8" });
+	try {
+		chmodSync(tokenPath, 0o600);
+	} catch {
+		// Best effort: some filesystems (e.g. Windows) don't support POSIX perms.
+	}
+}
+
+export interface ResolvedAdminToken {
+	token: string;
+	source: "env" | "file" | "generated";
+	generated: boolean;
+}
+
+/**
+ * Resolve the effective admin token, generating and persisting one if needed.
+ * Priority: PI_ROTATOR_ADMIN_TOKEN env var > .admin-token file > generate new.
+ *
+ * When a token is generated, it is persisted to .admin-token with 0600 perms
+ * and returned. The caller is responsible for printing it to the operator.
+ */
+export function ensureAdminToken(
+	configDir: string,
+	env: NodeJS.ProcessEnv = process.env,
+): ResolvedAdminToken {
+	const envToken = env.PI_ROTATOR_ADMIN_TOKEN?.trim();
+	if (envToken) {
+		return { token: envToken, source: "env", generated: false };
+	}
+
+	const fileToken = readPersistedAdminToken(configDir);
+	if (fileToken) {
+		return { token: fileToken, source: "file", generated: false };
+	}
+
+	const newToken = generateAdminToken();
+	try {
+		writePersistedAdminToken(configDir, newToken);
+	} catch {
+		// If we cannot write the file (read-only fs, perms), still return the
+		// token for this session. The next restart will simply generate again.
+	}
+	return { token: newToken, source: "generated", generated: true };
 }
 
 export function getRequestAdminToken(req: AdminAuthRequest): string | null {

package/src/compat.ts

@@ -1,14 +1,25 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { PayloadTooLargeError, readLimitedBody } from "./body-limit.js";
-import { logger } from "./logger.js";
+import { logger, redactSensitive } from "./logger.js";
 import type { AccountRotator } from "./rotator.js";
-import { resolveQuotaModelKey } from "./types.js";
+import { applyModelAlias, resolveQuotaModelKey } from "./types.js";
 import { withRotation, flattenHeaders, type RequestBody } from "./proxy.js";
+import { ResponsesStore, type StoredResponseEntry } from "./responses-store.js";
 
 
 const compatLogger = logger.child("compat");
 
+const VALIDATION_LOG_MAX_CHARS = 200;
+
+export function logValidationFailure(scope: string, payload: unknown): void {
+	const truncated = redactSensitive(JSON.stringify(payload));
+	const clipped = truncated.length > VALIDATION_LOG_MAX_CHARS
+		? `${truncated.slice(0, VALIDATION_LOG_MAX_CHARS)}…[+${truncated.length - VALIDATION_LOG_MAX_CHARS} chars]`
+		: truncated;
+	compatLogger.warn(`${scope}: ${clipped}`);
+}
+
 export interface ChatMessage {
 	role: "system" | "developer" | "user" | "assistant" | "model" | "tool";
 	content: string | Array<{ type: string; text?: string;[key: string]: unknown }> | null;
@@ -131,23 +142,19 @@ interface ResponseFunctionCallOutputItem {
 
 type ResponseOutputItem = ResponseMessageOutputItem | ResponseFunctionCallOutputItem;
 
-interface StoredResponseEntry {
-	response: Record<string, unknown>;
-	inputItems: Array<Record<string, unknown>>;
-	conversationMessages: ChatMessage[];
-	callIdToName: Map<string, string>;
-	expiresAt: number;
-}
+// StoredResponseEntry now lives in responses-store.ts (persistent on disk)
 
 // ---------------------------------------------------------------------------
 // Model-specific specs — mirrors Antigravity-Manager model_specs.json
+// Operators can override these via the `modelSpecs` field in accounts.json
+// by calling setModelSpecsOverride() at startup.
 // ---------------------------------------------------------------------------
-interface ModelSpec {
+export interface ModelSpec {
 	maxOutputTokens: number;
 	thinkingBudget: number; // -1 = adaptive (model decides), >=0 = fixed
 	isThinking: boolean;
 }
-const MODEL_SPECS: Record<string, ModelSpec> = {
+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 },
@@ -169,6 +176,20 @@ const MODEL_SPECS: Record<string, ModelSpec> = {
 	"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;
+}
+
+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;
@@ -182,9 +203,10 @@ function getModelFamily(model: string): "claude" | "gemini" | "unknown" {
 }
 
 function getModelSpec(model: string): ModelSpec {
+	const specs = getActiveModelSpecs();
 	const lower = model.toLowerCase();
-	if (MODEL_SPECS[lower]) return MODEL_SPECS[lower];
-	for (const [key, spec] of Object.entries(MODEL_SPECS)) {
+	if (specs[lower]) return specs[lower];
+	for (const [key, spec] of Object.entries(specs)) {
 		if (lower.includes(key)) return spec;
 	}
 	const family = getModelFamily(model);
@@ -228,40 +250,36 @@ function isNonEmptyString(value: unknown): value is string {
  */
 const thoughtSignatureCache = new Map<string, string>();
 const THOUGHT_SIGNATURE_CACHE_MAX = 500;
-const RESPONSES_STORE_TTL_MS = 6 * 60 * 60 * 1000;
-const RESPONSES_STORE_MAX = 500;
-const responsesStore = new Map<string, StoredResponseEntry>();
+const responsesStore = new ResponsesStore();
 
 function makeCompatId(prefix: string): string {
 	return `${prefix}_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
 }
 
-function pruneResponsesStore(now = Date.now()): void {
-	for (const [id, entry] of responsesStore) {
-		if (entry.expiresAt <= now) responsesStore.delete(id);
-	}
-	while (responsesStore.size > RESPONSES_STORE_MAX) {
-		const oldest = responsesStore.keys().next();
-		if (oldest.done) break;
-		responsesStore.delete(oldest.value);
-	}
-}
-
 function getStoredResponse(id: string): StoredResponseEntry | null {
-	pruneResponsesStore();
-	return responsesStore.get(id) || null;
+	return responsesStore.get(id);
 }
 
 function setStoredResponse(id: string, entry: StoredResponseEntry): void {
-	pruneResponsesStore();
 	responsesStore.set(id, entry);
-	pruneResponsesStore();
 }
 
 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();
+}
+
 function cacheThoughtSignature(callId: string, signature: string): void {
 	if (thoughtSignatureCache.size >= THOUGHT_SIGNATURE_CACHE_MAX) {
 		// Evict the oldest entry
@@ -384,6 +402,15 @@ function sanitizeGeminiSchema(schema: unknown): unknown {
 			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(
@@ -566,6 +593,17 @@ function sanitizeClaudeViaGeminiSchema(schema: unknown): unknown {
 			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)]),
@@ -808,12 +846,13 @@ function messagesFromAntigravityRequest(value: Record<string, unknown>): ChatMes
 
 export function normalizeOpenAIChatCompletionRequest(value: unknown): unknown {
 	if (!isRecord(value) || Array.isArray(value.messages)) return value;
-	let messages: ChatMessage[] | null = null;
-	if ("messages" in value) messages = messagesFromLooseMessages(value.messages);
-	else if (typeof value.prompt === "string") messages = [{ role: "user", content: value.prompt }];
-	else if (Array.isArray(value.prompt)) messages = messagesFromResponsesInput(value.prompt) ?? value.prompt.map((prompt) => ({ role: "user", content: String(prompt) }));
-	else if ("input" in value) messages = messagesFromResponsesInput(value.input);
-	else messages = messagesFromAntigravityRequest(value);
+	const messages = (() => {
+		if ("messages" in value) return messagesFromLooseMessages(value.messages);
+		if (typeof value.prompt === "string") return [{ role: "user", content: value.prompt }];
+		if (Array.isArray(value.prompt)) return messagesFromResponsesInput(value.prompt) ?? value.prompt.map((prompt) => ({ role: "user", content: String(prompt) }));
+		if ("input" in value) return messagesFromResponsesInput(value.input);
+		return messagesFromAntigravityRequest(value);
+	})();
 	return messages ? { ...value, messages } : value;
 }
 
@@ -897,7 +936,7 @@ export function validateOpenAIChatCompletionRequest(value: unknown): { ok: true;
 	const errors: string[] = [];
 	if (!isNonEmptyString(value.model)) errors.push("body.model must be a non-empty string");
 	if (!validateMessages(value.messages)) {
-		compatLogger.warn(`OpenAI messages validation failed: ${JSON.stringify(value.messages)}`);
+		logValidationFailure("OpenAI messages validation failed", value.messages);
 		errors.push("body.messages must be an array of chat messages");
 	}
 	if (value.stream !== undefined && typeof value.stream !== "boolean") errors.push("body.stream must be boolean when provided");
@@ -961,9 +1000,15 @@ function convertResponsesToChatRequest(input: OpenAIResponsesRequest): Responses
 		throw new Error(`previous_response_id not found: ${previousResponseId}`);
 	}
 
-	const parsed = parseResponsesInput(input.input, previous?.callIdToName);
+	// Re-hydrate the persisted Maps/Arrays back into the runtime types.
+	const previousCallIdToName = previous ? new Map(Object.entries(previous.callIdToName)) : new Map<string, string>();
+	const previousConversationMessages: ChatMessage[] = previous
+		? (previous.conversationMessages as unknown as ChatMessage[])
+		: [];
+
+	const parsed = parseResponsesInput(input.input, previousCallIdToName);
 	const conversationMessages = [
-		...(previous?.conversationMessages ?? []),
+		...previousConversationMessages,
 		...parsed.messages,
 	];
 	const chatMessages = [
@@ -1086,12 +1131,13 @@ function saveResponsesEntry(
 	if (!responseId) return;
 	const { callIdToName } = buildResponsesOutput(completion);
 	const mergedConversation = [...conversationMessages, buildAssistantMessageFromCompletion(completion)];
+	const expiresAt = Date.now() + 6 * 60 * 60 * 1000;
 	setStoredResponse(responseId, {
 		response,
 		inputItems,
-		conversationMessages: mergedConversation,
-		callIdToName,
-		expiresAt: Date.now() + RESPONSES_STORE_TTL_MS,
+		conversationMessages: mergedConversation as unknown as Array<Record<string, unknown>>,
+		callIdToName: Object.fromEntries(callIdToName),
+		expiresAt,
 	});
 }
 
@@ -1124,19 +1170,37 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	for (let i = 0; i < conversationMessages.length; i++) {
 		const msg = conversationMessages[i];
 		if (msg.role === "assistant" || msg.role === "model") {
+			// Strip dangling tool calls that do not have corresponding tool results (e.g. if some or all tool calls were cancelled/failed)
+			let msgToolCalls = msg.tool_calls;
+			if (Array.isArray(msgToolCalls) && msgToolCalls.length > 0) {
+				const completedToolCallIds = new Set<string>();
+				let j = i + 1;
+				while (j < conversationMessages.length && conversationMessages[j].role === "tool") {
+					const toolCallId = conversationMessages[j].tool_call_id;
+					if (typeof toolCallId === "string") {
+						completedToolCallIds.add(toolCallId);
+					}
+					j++;
+				}
+				msgToolCalls = msgToolCalls.filter((tc) => tc.id && completedToolCallIds.has(tc.id));
+				if (msgToolCalls.length === 0) {
+					msgToolCalls = undefined;
+				}
+			}
+
 			// Check if this is a thinking model turn with tool calls that have no cached signatures.
 			// If so, we collapse the tool exchange into a neutral user summary instead of
 			// injecting [Tool call: ...] text that the model will learn to mimic.
 			const hasMissingSig =
 				isGeminiThinking &&
-				Array.isArray(msg.tool_calls) &&
-				msg.tool_calls.length > 0 &&
-				!thoughtSignatureCache.has(msg.tool_calls[0].id);
+				Array.isArray(msgToolCalls) &&
+				msgToolCalls.length > 0 &&
+				!thoughtSignatureCache.has(msgToolCalls[0].id);
 
 			if (hasMissingSig) {
 				// Build a summary of what the model did and what results came back.
 				// We collect the paired tool result(s) from the immediately following messages.
-				const toolNames = msg.tool_calls!.map((tc) => tc.function.name).join(", ");
+				const toolNames = msgToolCalls!.map((tc) => tc.function.name).join(", ");
 				const resultParts: string[] = [];
 				while (i + 1 < conversationMessages.length && conversationMessages[i + 1].role === "tool") {
 					i++;
@@ -1156,13 +1220,13 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 				const textContent = typeof msg.content === "string" ? msg.content : extractText(msg.content);
 				if (textContent) parts.push({ text: textContent });
 			}
-			if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+			if (Array.isArray(msgToolCalls) && msgToolCalls.length > 0) {
 				// Use native Gemini functionCall parts. Re-inject thought_signature from
 				// the server-side cache if available. Google only validates signatures on
 				// the *current turn* (after the last real user text message), so missing
 				// signatures on older historical turns are silently ignored.
 				let isFirstInMessage = true;
-				for (const tc of msg.tool_calls) {
+				for (const tc of msgToolCalls) {
 					let args: unknown;
 					try {
 						args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
@@ -1179,6 +1243,9 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 					isFirstInMessage = false;
 				}
 			}
+			if (parts.length === 0) {
+				parts.push({ text: "..." });
+			}
 			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
@@ -1221,16 +1288,40 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 					? parsed
 					: { output: parsed };
 			} catch { responseData = { output: responseText }; }
+			// Extract any images present in the tool result content
+			const toolImages: AntigravityPart[] = [];
+			if (msg.content && Array.isArray(msg.content)) {
+				for (const part of msg.content) {
+					if (part.type === "image_url" && isRecord(part.image_url) && typeof part.image_url.url === "string") {
+						const inlineData = dataUrlToInlineData(part.image_url.url);
+						if (inlineData) toolImages.push(inlineData);
+					} else if (part.type === "image" && isRecord(part.source) && typeof part.source.data === "string") {
+						const mediaType = typeof part.source.media_type === "string" ? part.source.media_type : "image/png";
+						toolImages.push({ inlineData: { mimeType: mediaType, data: part.source.data } });
+					}
+				}
+			}
+
 			// Include id only for Claude — Gemini native models reject the id field in functionResponse
 			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.
+			// Crucially, all tool_result (functionResponse) parts must appear before
+			// any other part types (such as inlineData images) in the parts array.
 			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);
+				const firstNonFnIdx = lastContent.parts.findIndex((p: any) => !isRecord(p) || p.functionResponse === undefined);
+				if (firstNonFnIdx === -1) {
+					lastContent.parts.push(fnResponsePart);
+				} else {
+					lastContent.parts.splice(firstNonFnIdx, 0, fnResponsePart);
+				}
+				if (toolImages.length > 0) {
+					lastContent.parts.push(...toolImages);
+				}
 			} else {
-				contents.push({ role: "user", parts: [fnResponsePart] });
+				contents.push({ role: "user", parts: [fnResponsePart, ...toolImages] });
 			}
 		} else {
 			// user message
@@ -1320,10 +1411,7 @@ export function openAIToAntigravityBody(input: OpenAIChatCompletionRequest): Req
 	if (geminiTools.length > 0) request.tools = geminiTools;
 	if (geminiToolConfig) request.toolConfig = geminiToolConfig;
 
-	let mappedModel = input.model;
-	if (mappedModel === "gemini-3.1-pro-high") mappedModel = "gemini-pro-agent";
-	if (mappedModel === "gemini-3.5-flash-high" || mappedModel === "gemini-3.5-flash" || mappedModel === "gemini-3.5-flash-medium") mappedModel = "gemini-3-flash-agent";
-	if (mappedModel === "gpt-oss-120b") mappedModel = "gpt-oss-120b-medium";
+	const mappedModel = applyModelAlias(input.model);
 
 	return {
 		project: "compat-placeholder",
@@ -1661,7 +1749,7 @@ async function readJsonBody(req: IncomingMessage): Promise<unknown> {
 		return JSON.parse(body.toString("utf-8"));
 	} catch (err) {
 		if (err instanceof PayloadTooLargeError) throw err;
-		throw new Error("Invalid JSON body");
+		throw new Error("Invalid JSON body", { cause: err });
 	}
 }
 
@@ -1810,7 +1898,7 @@ async function streamCompatSse(
 			}
 		}
 	} catch (err) {
-		compatLogger.warn(`Stream read error: ${err}`);
+				compatLogger.warn(`Stream read error: ${redactSensitive(String(err)).slice(0, 200)}`);
 	}
 
 	if (!reqClosed && !res.writableEnded) {
@@ -1988,7 +2076,7 @@ async function streamResponsesSse(
 			}
 		}
 	} catch (err) {
-		compatLogger.warn(`Responses stream read error: ${err}`);
+			compatLogger.warn(`Responses stream read error: ${redactSensitive(String(err)).slice(0, 200)}`);
 	}
 
 	const completion: CompatCompletion = {
@@ -2294,12 +2382,13 @@ export async function handleOpenAIResponsesCreate(req: IncomingMessage, res: Ser
 	requestBody.requestId = responseId;
 
 	if (validation.value.store !== false) {
+		const expiresAt = Date.now() + 6 * 60 * 60 * 1000;
 		setStoredResponse(responseId, {
 			response: buildResponsesResponse(validation.value, responseId, createdAt, { text: "", inputTokens: 0, outputTokens: 0, toolCalls: [] }, "in_progress", converted.previousResponseId),
 			inputItems: converted.inputItems,
-			conversationMessages: converted.conversationMessages,
-			callIdToName: new Map(),
-			expiresAt: Date.now() + RESPONSES_STORE_TTL_MS,
+			conversationMessages: converted.conversationMessages as unknown as Array<Record<string, unknown>>,
+			callIdToName: {},
+			expiresAt,
 		});
 	}
 

package/src/dashboard.ts

@@ -10,19 +10,19 @@ export function serveDashboard(res: ServerResponse): void {
 }
 
 export function serveStatusApi(res: ServerResponse, rotator: AccountRotator): void {
-  res.writeHead(200, {
-    "Content-Type": "application/json",
-    "Access-Control-Allow-Origin": "*",
-  });
-  res.end(JSON.stringify(rotator.getStatus()));
+	res.writeHead(200, {
+		"Content-Type": "application/json",
+		"Cache-Control": "no-store",
+	});
+	res.end(JSON.stringify(rotator.getStatus()));
 }
 
 export function serveConfigApi(res: ServerResponse, rotator: AccountRotator): void {
-  res.writeHead(200, {
-    "Content-Type": "application/json",
-    "Access-Control-Allow-Origin": "*",
-  });
-  res.end(JSON.stringify(rotator.getConfig()));
+	res.writeHead(200, {
+		"Content-Type": "application/json",
+		"Cache-Control": "no-store",
+	});
+	res.end(JSON.stringify(rotator.getConfig()));
 }
 
 export function serveConfigExportApi(res: ServerResponse, rotator: AccountRotator): void {
@@ -2843,7 +2843,7 @@ function escapeHtml(text) {
     .replace(/&/g, '&')
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
-    .replace(/\"/g, '&quot;')
+    .replace(/"/g, '&quot;')
     .replace(/'/g, '&#39;');
 }