@jsonstudio/llms 0.6.1435 → 0.6.1462

package/dist/conversion/compat/actions/anthropic-claude-code-system-prompt.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject } from '../../hub/types/json.js';
+import type { AnthropicClaudeCodeSystemPromptConfig } from '../../hub/pipeline/compat/compat-types.js';
+/**
+ * tabglm (Anthropic-compatible) strict-gates requests to Claude Code official client.
+ * It checks the system prompt format, and rejects mismatches with HTTP 403.
+ *
+ * This compat action normalizes the Anthropic `system` prompt into Claude Code official format.
+ * It ensures the *first* `system` block is Claude Code's official string, while keeping any
+ * existing system blocks (unless explicitly disabled).
+ */
+export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig): JsonObject;

package/dist/conversion/compat/actions/anthropic-claude-code-system-prompt.js

@@ -0,0 +1,101 @@
+const DEFAULT_SYSTEM_TEXT = "You are Claude Code, Anthropic's official CLI for Claude.";
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function normalizeSystemBlocks(system) {
+    const blocks = [];
+    const pushText = (text, extra) => {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return;
+        }
+        blocks.push({
+            ...(extra ?? {}),
+            type: 'text',
+            text: trimmed
+        });
+    };
+    if (typeof system === 'string') {
+        pushText(system);
+        return blocks;
+    }
+    if (Array.isArray(system)) {
+        for (const entry of system) {
+            if (typeof entry === 'string') {
+                pushText(entry);
+                continue;
+            }
+            if (!isRecord(entry)) {
+                continue;
+            }
+            const text = typeof entry.text === 'string' ? entry.text : '';
+            if (text) {
+                const extra = { ...entry };
+                delete extra.type;
+                delete extra.text;
+                pushText(text, extra);
+            }
+        }
+        return blocks;
+    }
+    if (isRecord(system)) {
+        const text = typeof system.text === 'string' ? system.text : '';
+        if (text) {
+            const extra = { ...system };
+            delete extra.type;
+            delete extra.text;
+            pushText(text, extra);
+        }
+    }
+    return blocks;
+}
+function dedupeSystemBlocksByText(blocks) {
+    const seen = new Set();
+    const result = [];
+    for (const block of blocks) {
+        const text = typeof block.text === 'string' ? block.text.trim() : '';
+        if (!text)
+            continue;
+        if (seen.has(text))
+            continue;
+        seen.add(text);
+        result.push({ ...block, type: 'text', text });
+    }
+    return result;
+}
+/**
+ * tabglm (Anthropic-compatible) strict-gates requests to Claude Code official client.
+ * It checks the system prompt format, and rejects mismatches with HTTP 403.
+ *
+ * This compat action normalizes the Anthropic `system` prompt into Claude Code official format.
+ * It ensures the *first* `system` block is Claude Code's official string, while keeping any
+ * existing system blocks (unless explicitly disabled).
+ */
+export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return payload;
+    }
+    const root = payload;
+    const systemText = (typeof config?.systemText === 'string' && config.systemText.trim())
+        ? config.systemText.trim()
+        : DEFAULT_SYSTEM_TEXT;
+    const preserveExisting = config?.preserveExistingSystemAsUserMessage !== false;
+    const existingBlocks = dedupeSystemBlocksByText(normalizeSystemBlocks(root.system));
+    const official = { type: 'text', text: systemText };
+    let nextBlocks = [];
+    if (!preserveExisting) {
+        nextBlocks = [official];
+    }
+    else if (existingBlocks.length === 0) {
+        nextBlocks = [official];
+    }
+    else if (existingBlocks[0].text !== systemText) {
+        nextBlocks = [official, ...existingBlocks.filter((b) => b.text !== systemText)];
+    }
+    else {
+        nextBlocks = [existingBlocks[0], ...existingBlocks.slice(1).filter((b) => b.text !== systemText)];
+        nextBlocks[0] = { ...nextBlocks[0], type: 'text', text: systemText };
+    }
+    root.system = nextBlocks;
+    return root;
+}

package/dist/conversion/compat/actions/antigravity-thought-signature-cache.js

@@ -1,4 +1,4 @@
-import { cacheAntigravitySessionSignature, getAntigravityRequestSessionId } from '../antigravity-session-signature.js';
+import { cacheAntigravitySessionSignature, getAntigravityRequestSessionMeta } from '../antigravity-session-signature.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -28,17 +28,18 @@ export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adap
         typeof payloadAny.requestId === 'string' ? String(payloadAny.requestId) : ''
     ].filter((k) => typeof k === 'string' && k.trim().length);
     let sessionId = '';
+    let messageCount = 1;
     for (const key of keyCandidates) {
-        const resolved = getAntigravityRequestSessionId(key);
-        if (resolved && resolved.trim().length) {
-            sessionId = resolved.trim();
+        const resolved = getAntigravityRequestSessionMeta(key);
+        if (resolved && resolved.sessionId.trim().length) {
+            sessionId = resolved.sessionId.trim();
+            messageCount = resolved.messageCount;
             break;
         }
     }
     if (!sessionId) {
         return payload;
     }
-    const messageCount = 1;
     const candidatesRaw = payload.candidates;
     const candidates = Array.isArray(candidatesRaw) ? candidatesRaw : [];
     for (const candidate of candidates) {

package/dist/conversion/compat/actions/antigravity-thought-signature-prepare.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+export declare function prepareAntigravityThoughtSignatureForGeminiRequest(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

package/dist/conversion/compat/actions/antigravity-thought-signature-prepare.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { cacheAntigravityRequestSessionMeta, clearAntigravitySessionSignature, extractAntigravityGeminiSessionId, getAntigravitySessionSignatureEntry, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function shouldEnableForAdapter(adapterContext) {
+    if (!adapterContext) {
+        return false;
+    }
+    const protocol = typeof adapterContext.providerProtocol === 'string' ? adapterContext.providerProtocol.trim().toLowerCase() : '';
+    if (protocol !== 'gemini-chat') {
+        return false;
+    }
+    const providerIdOrKey = typeof adapterContext.providerId === 'string' ? adapterContext.providerId.trim().toLowerCase() : '';
+    const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
+    return effectiveProviderId === 'antigravity';
+}
+function locateGeminiContentsNode(root) {
+    if (Array.isArray(root.contents)) {
+        return root;
+    }
+    const req = root.request;
+    if (isRecord(req) && Array.isArray(req.contents)) {
+        return req;
+    }
+    const data = root.data;
+    if (isRecord(data)) {
+        return locateGeminiContentsNode(data);
+    }
+    return undefined;
+}
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function resolveStableSessionId(adapterContext) {
+    if (!adapterContext) {
+        return undefined;
+    }
+    const ctxAny = adapterContext;
+    const candidates = [ctxAny.sessionId, ctxAny.conversationId].filter((v) => typeof v === 'string');
+    const raw = candidates.map((s) => s.trim()).find((s) => s.length > 0);
+    if (!raw) {
+        return undefined;
+    }
+    if (raw.toLowerCase().startsWith('sid-')) {
+        return raw;
+    }
+    return `sid-${sha256Hex(raw).slice(0, 16)}`;
+}
+function injectThoughtSignatureIntoFunctionCalls(contentsNode, signature) {
+    const contentsRaw = contentsNode.contents;
+    if (!Array.isArray(contentsRaw)) {
+        return;
+    }
+    const contents = contentsRaw;
+    for (const entry of contents) {
+        if (!isRecord(entry))
+            continue;
+        const partsRaw = entry.parts;
+        if (!Array.isArray(partsRaw))
+            continue;
+        const parts = partsRaw;
+        for (const part of parts) {
+            if (!isRecord(part))
+                continue;
+            if (!isRecord(part.functionCall))
+                continue;
+            const existing = part.thoughtSignature;
+            if (!shouldTreatAsMissingThoughtSignature(existing)) {
+                continue;
+            }
+            part.thoughtSignature = signature;
+        }
+    }
+}
+export function prepareAntigravityThoughtSignatureForGeminiRequest(payload, adapterContext) {
+    if (!shouldEnableForAdapter(adapterContext)) {
+        return payload;
+    }
+    const stableSessionId = resolveStableSessionId(adapterContext);
+    const derivedSessionId = extractAntigravityGeminiSessionId(payload);
+    const sessionId = stableSessionId || derivedSessionId;
+    const ctxAny = adapterContext;
+    const keys = [
+        adapterContext.requestId,
+        typeof ctxAny.clientRequestId === 'string' ? String(ctxAny.clientRequestId) : '',
+        typeof ctxAny.groupRequestId === 'string' ? String(ctxAny.groupRequestId) : ''
+    ].filter((k) => typeof k === 'string' && k.trim().length);
+    const root = payload;
+    const contentsNode = locateGeminiContentsNode(root);
+    const messageCount = contentsNode && Array.isArray(contentsNode.contents) ? contentsNode.contents.length : 1;
+    for (const key of keys) {
+        cacheAntigravityRequestSessionMeta(key, { sessionId, messageCount });
+    }
+    const cached = getAntigravitySessionSignatureEntry(sessionId);
+    if (!cached) {
+        return payload;
+    }
+    if (typeof messageCount === 'number' && messageCount > 0 && messageCount < cached.messageCount) {
+        // Rewind detected: do not inject a "future" signature; clear and wait for a fresh signature from upstream.
+        clearAntigravitySessionSignature(sessionId);
+        return payload;
+    }
+    if (!contentsNode) {
+        return payload;
+    }
+    injectThoughtSignatureIntoFunctionCalls(contentsNode, cached.signature);
+    return payload;
+}

package/dist/conversion/compat/antigravity-session-signature.d.ts

@@ -1,6 +1,14 @@
 export declare const DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
 export declare function cacheAntigravityRequestSessionId(requestId: string, sessionId: string): void;
+export declare function cacheAntigravityRequestSessionMeta(requestId: string, meta: {
+    sessionId: string;
+    messageCount?: number;
+}): void;
 export declare function getAntigravityRequestSessionId(requestId: string): string | undefined;
+export declare function getAntigravityRequestSessionMeta(requestId: string): {
+    sessionId: string;
+    messageCount: number;
+} | undefined;
 /**
  * Antigravity-Manager alignment: derive a stable session fingerprint for Gemini native requests.
  * - sha256(first user text parts joined), if len>10 and no "<system-reminder>"
@@ -10,4 +18,9 @@ export declare function getAntigravityRequestSessionId(requestId: string): strin
 export declare function extractAntigravityGeminiSessionId(payload: unknown): string;
 export declare function cacheAntigravitySessionSignature(sessionId: string, signature: string, messageCount?: number): void;
 export declare function getAntigravitySessionSignature(sessionId: string): string | undefined;
+export declare function getAntigravitySessionSignatureEntry(sessionId: string): {
+    signature: string;
+    messageCount: number;
+} | undefined;
+export declare function clearAntigravitySessionSignature(sessionId: string): void;
 export declare function shouldTreatAsMissingThoughtSignature(value: unknown): boolean;

package/dist/conversion/compat/antigravity-session-signature.js

@@ -95,13 +95,19 @@ function ensureCacheLimit() {
     }
 }
 export function cacheAntigravityRequestSessionId(requestId, sessionId) {
+    cacheAntigravityRequestSessionMeta(requestId, { sessionId });
+}
+export function cacheAntigravityRequestSessionMeta(requestId, meta) {
     const rid = typeof requestId === 'string' ? requestId.trim() : '';
-    const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+    const sid = typeof meta?.sessionId === 'string' ? meta.sessionId.trim() : '';
     if (!rid || !sid) {
         return;
     }
+    const messageCount = typeof meta?.messageCount === 'number' && Number.isFinite(meta.messageCount) && meta.messageCount > 0
+        ? Math.floor(meta.messageCount)
+        : 1;
     const ts = nowMs();
-    requestSessionIds.set(rid, { sessionId: sid, timestamp: ts });
+    requestSessionIds.set(rid, { sessionId: sid, messageCount, timestamp: ts });
     if (requestSessionIds.size <= SESSION_CACHE_LIMIT) {
         return;
     }
@@ -116,6 +122,10 @@ export function cacheAntigravityRequestSessionId(requestId, sessionId) {
     }
 }
 export function getAntigravityRequestSessionId(requestId) {
+    const meta = getAntigravityRequestSessionMeta(requestId);
+    return meta?.sessionId;
+}
+export function getAntigravityRequestSessionMeta(requestId) {
     const rid = typeof requestId === 'string' ? requestId.trim() : '';
     if (!rid) {
         return undefined;
@@ -129,7 +139,7 @@ export function getAntigravityRequestSessionId(requestId) {
         requestSessionIds.delete(rid);
         return undefined;
     }
-    return entry.sessionId;
+    return { sessionId: entry.sessionId, messageCount: entry.messageCount };
 }
 function findGeminiContentsNode(payload) {
     if (!isRecord(payload)) {
@@ -221,6 +231,9 @@ export function cacheAntigravitySessionSignature(sessionId, signature, messageCo
     ensureCacheLimit();
 }
 export function getAntigravitySessionSignature(sessionId) {
+    return getAntigravitySessionSignatureEntry(sessionId)?.signature;
+}
+export function getAntigravitySessionSignatureEntry(sessionId) {
     if (typeof sessionId !== 'string' || !sessionId.trim()) {
         return undefined;
     }
@@ -234,7 +247,13 @@ export function getAntigravitySessionSignature(sessionId) {
         sessionSignatures.delete(key);
         return undefined;
     }
-    return entry.signature;
+    return { signature: entry.signature, messageCount: entry.messageCount };
+}
+export function clearAntigravitySessionSignature(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+        return;
+    }
+    sessionSignatures.delete(sessionId.trim());
 }
 export function shouldTreatAsMissingThoughtSignature(value) {
     if (typeof value !== 'string') {

package/dist/conversion/compat/profiles/anthropic-claude-code.json

@@ -0,0 +1,26 @@
+{
+  "id": "anthropic:claude-code",
+  "protocol": "anthropic-messages",
+  "request": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      { "action": "set_default", "path": "metadata", "value": {} },
+      { "action": "set", "path": "metadata.userAgent", "value": "Claude-Code/2.1.25 (macos; arm64)" },
+      { "action": "set", "path": "metadata.clientOriginator", "value": "claude-code" },
+      { "action": "set_default", "path": "metadata.clientHeaders", "value": {} },
+      { "action": "set", "path": "metadata.clientHeaders.User-Agent", "value": "Claude-Code/2.1.25 (macos; arm64)" },
+      { "action": "set", "path": "metadata.clientHeaders.originator", "value": "claude-code" },
+      { "action": "set", "path": "metadata.clientHeaders.X-App", "value": "claude-code" },
+      { "action": "set", "path": "metadata.clientHeaders.x-app-version", "value": "2.1.25" },
+      { "action": "set", "path": "metadata.clientHeaders.anthropic-beta", "value": "claude-code-20250219,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05" },
+      {
+        "action": "anthropic_claude_code_system_prompt",
+        "config": { "preserveExistingSystemAsUserMessage": true }
+      },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  },
+  "response": {
+    "mappings": []
+  }
+}

package/dist/conversion/compat/profiles/chat-claude-code.json

@@ -0,0 +1,18 @@
+{
+  "id": "chat:claude-code",
+  "protocol": "anthropic-messages",
+  "request": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      {
+        "action": "anthropic_claude_code_system_prompt",
+        "config": { "preserveExistingSystemAsUserMessage": true }
+      },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  },
+  "response": {
+    "mappings": []
+  }
+}
+

package/dist/conversion/compat/profiles/chat-gemini-cli.json

@@ -22,6 +22,8 @@
     ]
   },
   "response": {
-    "mappings": []
+    "mappings": [
+      { "action": "antigravity_thought_signature_cache" }
+    ]
   }
 }

package/dist/conversion/compat/profiles/chat-gemini.json

@@ -5,6 +5,7 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "claude_thinking_tool_schema" },
+      { "action": "antigravity_thought_signature_prepare" },
       {
         "action": "gemini_web_search_request"
       },

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -18,7 +18,9 @@ import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image
 import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
 import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
 import { wrapGeminiCliRequest } from '../../../compat/actions/gemini-cli-request.js';
+import { prepareAntigravityThoughtSignatureForGeminiRequest } from '../../../compat/actions/antigravity-thought-signature-prepare.js';
 import { cacheAntigravityThoughtSignatureFromGeminiResponse } from '../../../compat/actions/antigravity-thought-signature-cache.js';
+import { applyAnthropicClaudeCodeSystemPromptCompat } from '../../../compat/actions/anthropic-claude-code-system-prompt.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -26,6 +28,9 @@ export function runRequestCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'request');
     if (!stage) {
         return { payload };
@@ -47,6 +52,9 @@ export function runResponseCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'response');
     if (!stage) {
         return { payload };
@@ -93,6 +101,16 @@ function pickStageConfig(profile, stage) {
     }
     return null;
 }
+function isProtocolCompatible(profile, adapterContext) {
+    const required = typeof profile.protocol === 'string' ? profile.protocol.trim().toLowerCase() : '';
+    if (!required) {
+        return true;
+    }
+    const actual = typeof adapterContext?.providerProtocol === 'string' && adapterContext.providerProtocol.trim()
+        ? adapterContext.providerProtocol.trim().toLowerCase()
+        : '';
+    return Boolean(actual) && actual === required;
+}
 function applyMapping(root, mapping, state) {
     switch (mapping.action) {
         case 'remove':
@@ -207,11 +225,21 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, wrapGeminiCliRequest(root, state.adapterContext));
             }
             break;
+        case 'antigravity_thought_signature_prepare':
+            if (state.direction === 'request') {
+                replaceRoot(root, prepareAntigravityThoughtSignatureForGeminiRequest(root, state.adapterContext));
+            }
+            break;
         case 'antigravity_thought_signature_cache':
             if (state.direction === 'response') {
                 replaceRoot(root, cacheAntigravityThoughtSignatureFromGeminiResponse(root, state.adapterContext));
             }
             break;
+        case 'anthropic_claude_code_system_prompt':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyAnthropicClaudeCodeSystemPromptCompat(root, mapping.config));
+            }
+            break;
         case 'glm_image_content':
             if (state.direction === 'request') {
                 replaceRoot(root, applyGlmImageContentTransform(root));

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -118,8 +118,25 @@ export type MappingInstruction = {
     action: 'claude_thinking_tool_schema';
 } | {
     action: 'gemini_cli_request_wrap';
+} | {
+    action: 'antigravity_thought_signature_prepare';
 } | {
     action: 'antigravity_thought_signature_cache';
+} | {
+    action: 'anthropic_claude_code_system_prompt';
+    config?: AnthropicClaudeCodeSystemPromptConfig;
+};
+export type AnthropicClaudeCodeSystemPromptConfig = {
+    /**
+     * Force the Anthropic `system` prompt to match Claude Code official format.
+     * Defaults to "You are Claude Code, Anthropic's official CLI for Claude."
+     */
+    systemText?: string;
+    /**
+     * When replacing an existing system prompt, optionally move the previous
+     * system text into the beginning of the user message history.
+     */
+    preserveExistingSystemAsUserMessage?: boolean;
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/dist/conversion/shared/compaction-detect.js

@@ -1,8 +1,14 @@
 function hasCompactionMarker(value) {
-    const lower = value.toLowerCase();
-    return (lower.includes('context checkpoint compaction') ||
-        lower.includes('checkpoint compaction') ||
-        lower.includes('handoff summary for another llm'));
+    // Compaction markers are intended to be explicit “header-like” sentinels produced by
+    // our own compaction flows, not arbitrary substrings inside user/dev instructions.
+    //
+    // If we treat any occurrence as a compaction request, normal conversations that
+    // contain phrases like “handoff summary …” (e.g. debug summaries pasted into chat)
+    // will get misclassified and will disable stopMessage / other servertools.
+    const lower = value.trimStart().toLowerCase();
+    return (lower.startsWith('context checkpoint compaction') ||
+        lower.startsWith('checkpoint compaction') ||
+        lower.startsWith('handoff summary for another llm'));
 }
 function containsMarker(value) {
     if (typeof value === 'string') {

package/dist/router/virtual-router/engine-health.js

@@ -104,6 +104,7 @@ const antigravityRiskBySignature = new Map();
 const ANTIGRAVITY_RISK_RESET_WINDOW_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_RISK_RESET_WINDOW', 30 * 60_000);
 const ANTIGRAVITY_RISK_COOLDOWN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_RISK_COOLDOWN', 5 * 60_000);
 const ANTIGRAVITY_RISK_BAN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_RISK_BAN', 24 * 60 * 60_000);
+const ANTIGRAVITY_AUTH_VERIFY_BAN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_AUTH_VERIFY_BAN', 24 * 60 * 60_000);
 function isAntigravityEvent(event) {
     const runtime = event?.runtime;
     if (!runtime || typeof runtime !== 'object') {
@@ -116,6 +117,60 @@ function isAntigravityEvent(event) {
     const providerKey = typeof runtime.providerKey === 'string' ? runtime.providerKey.trim().toLowerCase() : '';
     return providerKey.startsWith('antigravity.');
 }
+function isGoogleAccountVerificationRequired(event) {
+    const sources = [];
+    const message = typeof event.message === 'string' ? event.message : '';
+    if (message)
+        sources.push(message);
+    const details = event.details;
+    if (details && typeof details === 'object' && !Array.isArray(details)) {
+        const upstreamMessage = details.upstreamMessage;
+        if (typeof upstreamMessage === 'string' && upstreamMessage.trim()) {
+            sources.push(upstreamMessage);
+        }
+        const meta = details.meta;
+        if (meta && typeof meta === 'object' && !Array.isArray(meta)) {
+            const metaUpstream = meta.upstreamMessage;
+            if (typeof metaUpstream === 'string' && metaUpstream.trim()) {
+                sources.push(metaUpstream);
+            }
+            const metaMessage = meta.message;
+            if (typeof metaMessage === 'string' && metaMessage.trim()) {
+                sources.push(metaMessage);
+            }
+        }
+    }
+    if (sources.length === 0) {
+        return false;
+    }
+    const lowered = sources.join(' | ').toLowerCase();
+    return (lowered.includes('verify your account') ||
+        lowered.includes('accounts.google.com/signin/continue') ||
+        lowered.includes('support.google.com/accounts?p=al_alert'));
+}
+function resolveAntigravityRuntimeKey(event) {
+    const runtime = event.runtime;
+    if (!runtime || typeof runtime !== 'object') {
+        return null;
+    }
+    const target = runtime.target && typeof runtime.target === 'object' ? runtime.target : null;
+    const byTarget = target && typeof target.runtimeKey === 'string' && target.runtimeKey.trim() ? target.runtimeKey.trim() : '';
+    if (byTarget) {
+        return byTarget;
+    }
+    const providerKey = (typeof runtime.providerKey === 'string' && runtime.providerKey.trim() ? runtime.providerKey.trim() : '') ||
+        (target && typeof target.providerKey === 'string' && String(target.providerKey).trim()
+            ? String(target.providerKey).trim()
+            : '');
+    if (!providerKey) {
+        return null;
+    }
+    const parts = providerKey.split('.').filter(Boolean);
+    if (parts.length < 2) {
+        return null;
+    }
+    return `${parts[0]}.${parts[1]}`;
+}
 function shouldTriggerAntigravityRiskPolicy(event) {
     const status = typeof event.status === 'number' ? event.status : undefined;
     if (typeof status === 'number' && Number.isFinite(status)) {
@@ -142,12 +197,47 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
     if (!shouldTriggerAntigravityRiskPolicy(event)) {
         return;
     }
+    const runtimeKey = resolveAntigravityRuntimeKey(event);
+    const verificationRequired = Boolean(runtimeKey) && isGoogleAccountVerificationRequired(event);
+    // Account verification errors are per-account and must be handled immediately:
+    // - blacklist only the affected runtimeKey (do NOT penalize other Antigravity accounts)
+    // - require user to complete OAuth verification to recover
+    if (verificationRequired && runtimeKey) {
+        const providerKeys = providerRegistry
+            .listProviderKeys('antigravity')
+            .filter((key) => typeof key === 'string' && key.startsWith(`${runtimeKey}.`));
+        if (providerKeys.length === 0) {
+            return;
+        }
+        for (const key of providerKeys) {
+            try {
+                if (!healthManager.isAvailable(key)) {
+                    continue;
+                }
+                healthManager.tripProvider(key, 'auth_verify', ANTIGRAVITY_AUTH_VERIFY_BAN_MS);
+                markProviderCooldown(key, ANTIGRAVITY_AUTH_VERIFY_BAN_MS);
+            }
+            catch {
+                // ignore lookup failures
+            }
+        }
+        debug?.log?.('[virtual-router] antigravity auth verify blacklist', {
+            runtimeKey,
+            cooldownMs: ANTIGRAVITY_AUTH_VERIFY_BAN_MS,
+            affected: providerKeys
+        });
+        return;
+    }
     const signature = computeAntigravityRiskSignature(event);
     if (!signature || signature === 'unknown') {
         return;
     }
+    // Antigravity-Manager alignment: account verification errors are per-account (runtimeKey) and should not
+    // penalize all other Antigravity accounts. Request-shape/auth policy failures are still treated globally.
+    const runtimeScoped = Boolean(runtimeKey) && isGoogleAccountVerificationRequired(event);
+    const riskKey = runtimeScoped ? `${signature}|${runtimeKey}` : signature;
     const now = Date.now();
-    const prev = antigravityRiskBySignature.get(signature);
+    const prev = antigravityRiskBySignature.get(riskKey);
     let count = 1;
     if (prev) {
         const elapsed = now - prev.lastAt;
@@ -155,12 +245,17 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
             count = prev.count + 1;
         }
     }
-    antigravityRiskBySignature.set(signature, { count, lastAt: now });
+    antigravityRiskBySignature.set(riskKey, { count, lastAt: now });
     // Escalation ladder (Antigravity account safety):
     // 1) First/second occurrence: normal retry/fallback logic handles per-request behavior.
-    // 2) Third occurrence: cooldown all Antigravity providerKeys for 5 minutes.
-    // 3) Fourth+ occurrence: effectively remove Antigravity from routing (long ban window).
-    const providerKeys = providerRegistry.listProviderKeys('antigravity');
+    // 2) Third occurrence: cooldown Antigravity providerKeys for 5 minutes (scoped for account verification errors).
+    // 3) Fourth+ occurrence: effectively remove Antigravity from routing (long ban window; scoped for account verification errors).
+    const allProviderKeys = providerRegistry.listProviderKeys('antigravity');
+    const providerKeys = runtimeScoped
+        ? allProviderKeys.filter((key) => {
+            return typeof key === 'string' && runtimeKey ? key.startsWith(`${runtimeKey}.`) : false;
+        })
+        : allProviderKeys;
     if (providerKeys.length === 0) {
         return;
     }
@@ -176,6 +271,7 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
         }
         debug?.log?.('[virtual-router] antigravity risk cooldown', {
             signature,
+            ...(runtimeScoped ? { runtimeKey } : {}),
             count,
             cooldownMs: ANTIGRAVITY_RISK_COOLDOWN_MS,
             affected: providerKeys
@@ -194,6 +290,7 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
         }
         debug?.log?.('[virtual-router] antigravity risk blacklist', {
             signature,
+            ...(runtimeScoped ? { runtimeKey } : {}),
             count,
             cooldownMs: ttl,
             affected: providerKeys

package/dist/router/virtual-router/engine-selection/tier-selection.js

@@ -4,6 +4,17 @@ import { resolveHealthWeightedConfig } from '../health-weighted.js';
 import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
 import { selectProviderKeyFromCandidatePool } from './tier-selection-select.js';
+function shouldAvoidAllAntigravityOnRetry(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    return rt.antigravityAvoidAllOnRetry === true;
+}
 function shouldAvoidAntigravityAfterRepeatedError(metadata) {
     if (!metadata || typeof metadata !== 'object') {
         return false;
@@ -13,6 +24,9 @@ function shouldAvoidAntigravityAfterRepeatedError(metadata) {
         return false;
     }
     const rt = rtRaw;
+    if (rt.antigravityAvoidAllOnRetry === true) {
+        return true;
+    }
     const signature = typeof rt.antigravityRetryErrorSignature === 'string' ? rt.antigravityRetryErrorSignature.trim() : '';
     const consecutive = typeof rt.antigravityRetryErrorConsecutive === 'number' && Number.isFinite(rt.antigravityRetryErrorConsecutive)
         ? Math.max(0, Math.floor(rt.antigravityRetryErrorConsecutive))
@@ -49,6 +63,11 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         targets = targets.filter((key) => !excludedKeys.has(key));
     }
     const isRecoveryAttempt = excludedKeys.size > 0;
+    // Antigravity safety: for certain retry signals (e.g. account verification required),
+    // avoid hitting *any* Antigravity alias on retries to prevent cross-account risk cascades.
+    if (isRecoveryAttempt && shouldAvoidAllAntigravityOnRetry(features.metadata)) {
+        targets = targets.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
+    }
     const singleCandidateFallback = targets.length === 1 ? targets[0] : undefined;
     if (targets.length > 0) {
         // Always respect cooldown signals. If a route/tier is depleted due to cooldown,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.1435",
+  "version": "0.6.1462",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -27,7 +27,7 @@
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-prefer-autoclear.mjs && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs && node scripts/tests/virtual-router-antigravity-alias-pin.mjs",
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-prefer-autoclear.mjs && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs && node scripts/tests/virtual-router-antigravity-alias-pin.mjs && node scripts/tests/virtual-router-antigravity-auth-verify.mjs",
     "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs",
     "test:golden": "npm run build:ci && node scripts/tests/chat-golden-roundtrip.mjs && node scripts/tests/anthropic-golden-roundtrip.mjs",
     "test:coverage": "node scripts/run-ci-coverage.mjs"