@jsonstudio/llms 0.6.1423 → 0.6.1449

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

@@ -0,0 +1,10 @@
+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 forces the Anthropic `system` prompt to Claude Code's official string.
+ * Optionally preserves the previous system prompt by moving it into the user message stream.
+ */
+export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig): JsonObject;

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

@@ -0,0 +1,82 @@
+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 extractSystemText(system) {
+    if (typeof system === 'string') {
+        return system.trim();
+    }
+    if (Array.isArray(system)) {
+        const parts = [];
+        for (const entry of system) {
+            if (typeof entry === 'string') {
+                if (entry.trim())
+                    parts.push(entry.trim());
+                continue;
+            }
+            if (!isRecord(entry))
+                continue;
+            const text = typeof entry.text === 'string' ? entry.text.trim() : '';
+            if (text)
+                parts.push(text);
+        }
+        return parts.join('\n').trim();
+    }
+    if (isRecord(system)) {
+        const text = typeof system.text === 'string' ? system.text.trim() : '';
+        return text;
+    }
+    return '';
+}
+function ensureUserMessage(messages) {
+    const first = messages[0];
+    if (isRecord(first) && typeof first.role === 'string' && first.role.toLowerCase() === 'user') {
+        return first;
+    }
+    const created = { role: 'user', content: '' };
+    messages.unshift(created);
+    return created;
+}
+function appendUserText(message, text) {
+    if (!text.trim()) {
+        return;
+    }
+    const existing = message.content;
+    if (typeof existing === 'string') {
+        message.content = existing.trim() ? `${text}\n\n${existing}` : text;
+        return;
+    }
+    // Anthropic supports content blocks, but many upstreams accept string; fall back to string.
+    message.content = text;
+}
+/**
+ * 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 forces the Anthropic `system` prompt to Claude Code's official string.
+ * Optionally preserves the previous system prompt by moving it into the user message stream.
+ */
+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 existingSystemText = extractSystemText(root.system);
+    const already = existingSystemText === systemText;
+    if (!already) {
+        root.system = systemText;
+    }
+    const preserve = config?.preserveExistingSystemAsUserMessage !== false;
+    if (!already && preserve && existingSystemText && existingSystemText !== systemText) {
+        const messages = Array.isArray(root.messages) ? root.messages : [];
+        if (messages.length || root.messages !== undefined) {
+            const msg = ensureUserMessage(messages);
+            appendUserText(msg, existingSystemText);
+            root.messages = messages;
+        }
+    }
+    return root;
+}

package/dist/conversion/compat/actions/antigravity-thought-signature-cache.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 cacheAntigravityThoughtSignatureFromGeminiResponse(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

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

@@ -0,0 +1,60 @@
+import { cacheAntigravitySessionSignature, getAntigravityRequestSessionId } 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';
+}
+export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adapterContext) {
+    if (!shouldEnableForAdapter(adapterContext)) {
+        return payload;
+    }
+    const ctxAny = adapterContext;
+    const payloadAny = payload;
+    const keyCandidates = [
+        adapterContext?.requestId,
+        typeof ctxAny.clientRequestId === 'string' ? String(ctxAny.clientRequestId) : '',
+        typeof ctxAny.groupRequestId === 'string' ? String(ctxAny.groupRequestId) : '',
+        typeof payloadAny.request_id === 'string' ? String(payloadAny.request_id) : '',
+        typeof payloadAny.requestId === 'string' ? String(payloadAny.requestId) : ''
+    ].filter((k) => typeof k === 'string' && k.trim().length);
+    let sessionId = '';
+    for (const key of keyCandidates) {
+        const resolved = getAntigravityRequestSessionId(key);
+        if (resolved && resolved.trim().length) {
+            sessionId = resolved.trim();
+            break;
+        }
+    }
+    if (!sessionId) {
+        return payload;
+    }
+    const messageCount = 1;
+    const candidatesRaw = payload.candidates;
+    const candidates = Array.isArray(candidatesRaw) ? candidatesRaw : [];
+    for (const candidate of candidates) {
+        const content = isRecord(candidate.content) ? candidate.content : undefined;
+        const partsRaw = content?.parts;
+        const parts = Array.isArray(partsRaw) ? partsRaw : [];
+        for (const part of parts) {
+            if (!isRecord(part.functionCall)) {
+                continue;
+            }
+            const sig = typeof part.thoughtSignature === 'string' ? String(part.thoughtSignature) : '';
+            if (!sig.trim().length) {
+                continue;
+            }
+            cacheAntigravitySessionSignature(sessionId, sig.trim(), messageCount);
+        }
+    }
+    return payload;
+}

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,82 @@
+import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, 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 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 sessionId = extractAntigravityGeminiSessionId(payload);
+    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);
+    for (const key of keys) {
+        cacheAntigravityRequestSessionId(key, sessionId);
+    }
+    const signature = getAntigravitySessionSignature(sessionId);
+    if (!signature) {
+        return payload;
+    }
+    const root = payload;
+    const contentsNode = locateGeminiContentsNode(root);
+    if (!contentsNode) {
+        return payload;
+    }
+    injectThoughtSignatureIntoFunctionCalls(contentsNode, signature);
+    return payload;
+}

package/dist/conversion/compat/actions/gemini-cli-request.js

@@ -1,4 +1,4 @@
-import { extractAntigravityGeminiSessionId, getAntigravitySessionSignature, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
+import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
 const REQUEST_FIELDS = [
     'contents',
     'systemInstruction',
@@ -515,9 +515,29 @@ export function wrapGeminiCliRequest(payload, adapterContext) {
     normalizeToolDeclarations(requestNode);
     normalizeFunctionCallArgs(requestNode);
     const enableSignature = shouldEnableAntigravitySignature(adapterContext) ||
+        (typeof requestNode.userAgent === 'string' && requestNode.userAgent.trim().toLowerCase() === 'antigravity') ||
+        (typeof requestNode.requestId === 'string' && requestNode.requestId.trim().toLowerCase().startsWith('agent-')) ||
         (typeof root.userAgent === 'string' && root.userAgent.trim().toLowerCase() === 'antigravity') ||
         (typeof root.requestId === 'string' && root.requestId.trim().toLowerCase().startsWith('agent-'));
     if (enableSignature) {
+        // Antigravity-Manager alignment:
+        if (adapterContext) {
+            try {
+                const sessionId = extractAntigravityGeminiSessionId(requestNode);
+                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);
+                for (const key of keys) {
+                    cacheAntigravityRequestSessionId(key, sessionId);
+                }
+            }
+            catch {
+                // best-effort only
+            }
+        }
         injectAntigravityThoughtSignature(requestNode);
     }
     // Cloud Code Assist request wrapper should not carry metadata/action/web_search/stream.

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

@@ -1,4 +1,6 @@
 export declare const DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export declare function cacheAntigravityRequestSessionId(requestId: string, sessionId: string): void;
+export declare function getAntigravityRequestSessionId(requestId: string): string | 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>"

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

@@ -5,6 +5,7 @@ const SIGNATURE_TTL_MS = 2 * 60 * 60 * 1000;
 const MIN_SIGNATURE_LENGTH = 50;
 const SESSION_CACHE_LIMIT = 1000;
 const GLOBAL_SIGNATURE_CACHE_KEY = '__LLMSWITCH_ANTIGRAVITY_SESSION_SIGNATURE_CACHE__';
+const GLOBAL_REQUEST_SESSION_CACHE_KEY = '__LLMSWITCH_ANTIGRAVITY_REQUEST_SESSION_ID_CACHE__';
 function getGlobalSignatureCache() {
     const g = globalThis;
     const existing = g[GLOBAL_SIGNATURE_CACHE_KEY];
@@ -16,6 +17,17 @@ function getGlobalSignatureCache() {
     return created;
 }
 const sessionSignatures = getGlobalSignatureCache();
+function getGlobalRequestSessionCache() {
+    const g = globalThis;
+    const existing = g[GLOBAL_REQUEST_SESSION_CACHE_KEY];
+    if (existing instanceof Map) {
+        return existing;
+    }
+    const created = new Map();
+    g[GLOBAL_REQUEST_SESSION_CACHE_KEY] = created;
+    return created;
+}
+const requestSessionIds = getGlobalRequestSessionCache();
 function nowMs() {
     return Date.now();
 }
@@ -53,6 +65,9 @@ function sha256Hex(value) {
 function isExpired(entry, ts) {
     return ts - entry.timestamp > SIGNATURE_TTL_MS;
 }
+function isRequestSessionExpired(entry, ts) {
+    return ts - entry.timestamp > SIGNATURE_TTL_MS;
+}
 function pruneExpired() {
     const ts = nowMs();
     for (const [key, entry] of sessionSignatures.entries()) {
@@ -79,6 +94,43 @@ function ensureCacheLimit() {
         }
     }
 }
+export function cacheAntigravityRequestSessionId(requestId, sessionId) {
+    const rid = typeof requestId === 'string' ? requestId.trim() : '';
+    const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+    if (!rid || !sid) {
+        return;
+    }
+    const ts = nowMs();
+    requestSessionIds.set(rid, { sessionId: sid, timestamp: ts });
+    if (requestSessionIds.size <= SESSION_CACHE_LIMIT) {
+        return;
+    }
+    // Best-effort cleanup to avoid unbounded growth.
+    const entries = Array.from(requestSessionIds.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const overflow = requestSessionIds.size - SESSION_CACHE_LIMIT;
+    for (let i = 0; i < overflow; i++) {
+        const key = entries[i]?.[0];
+        if (key) {
+            requestSessionIds.delete(key);
+        }
+    }
+}
+export function getAntigravityRequestSessionId(requestId) {
+    const rid = typeof requestId === 'string' ? requestId.trim() : '';
+    if (!rid) {
+        return undefined;
+    }
+    const entry = requestSessionIds.get(rid);
+    if (!entry) {
+        return undefined;
+    }
+    const ts = nowMs();
+    if (isRequestSessionExpired(entry, ts)) {
+        requestSessionIds.delete(rid);
+        return undefined;
+    }
+    return entry.sessionId;
+}
 function findGeminiContentsNode(payload) {
     if (!isRecord(payload)) {
         return undefined;

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"
       },
@@ -29,6 +30,8 @@
     ]
   },
   "response": {
-    "mappings": []
+    "mappings": [
+      { "action": "antigravity_thought_signature_cache" }
+    ]
   }
 }

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

@@ -18,6 +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) {
@@ -206,6 +209,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,6 +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.1423",
+  "version": "0.6.1449",
   "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"