@jsonstudio/llms 0.6.1435 → 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-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/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) {
@@ -207,11 +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,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.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"