@jsonstudio/llms 0.6.1462 → 0.6.1643

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -176,9 +176,10 @@ export function buildOpenAIChatFromGeminiRequest(payload) {
 }
 export function buildOpenAIChatFromGeminiResponse(payload) {
     const candidates = Array.isArray(payload?.candidates) ? payload.candidates : [];
+    const errorNode = payload?.error;
     const primary = candidates[0] && typeof candidates[0] === 'object' ? candidates[0] : {};
     const content = primary?.content || {};
-    const role = mapGeminiRoleToChat(content.role);
+    const role = candidates.length > 0 ? mapGeminiRoleToChat(content.role) : 'assistant';
     const rawFinishReason = primary?.finishReason;
     const finishReasonUpper = typeof rawFinishReason === 'string' ? rawFinishReason.trim().toUpperCase() : '';
     const parts = Array.isArray(content.parts) ? content.parts : [];
@@ -420,6 +421,10 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
             }
         ]
     };
+    // Preserve upstream error envelope (used by servertool auto flows and host status mapping).
+    if (errorNode && typeof errorNode === 'object' && !Array.isArray(errorNode)) {
+        chatResp.error = errorNode;
+    }
     if (Object.keys(usage).length > 0) {
         chatResp.usage = usage;
     }

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

@@ -1,11 +1,8 @@
 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).
+ * Canonicalizes the Anthropic `system` prompt into a single text block.
+ * Optionally preserves previous system blocks by prepending them to the first user message,
+ * so request semantics are preserved after normalization.
  */
-export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig): JsonObject;
+export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig, adapterContext?: unknown): JsonObject;

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

@@ -1,7 +1,97 @@
+import { createHash, randomUUID } from 'node:crypto';
 const DEFAULT_SYSTEM_TEXT = "You are Claude Code, Anthropic's official CLI for Claude.";
+const DEFAULT_USER_ID_ENV = 'ROUTECODEX_CLAUDE_CODE_USER_ID';
+const DEFAULT_ACCOUNT_SEED_ENV = 'ROUTECODEX_CLAUDE_CODE_ACCOUNT_SEED';
+const CLAUDE_CODE_USER_ID_REGEX = /^user_[0-9a-f]{64}_account__session_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const HEX_32_REGEX = /^[0-9a-f]{32}$/i;
+const SESSION_TOKEN_REGEX = /session[_:\-\s]?([0-9a-f]{8,}(?:-[0-9a-f]{4,}){0,5})/i;
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
+function readTrimmedString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function isClaudeCodeUserId(value) {
+    const trimmed = readTrimmedString(value);
+    if (!trimmed)
+        return false;
+    return CLAUDE_CODE_USER_ID_REGEX.test(trimmed);
+}
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function formatUuidFromHex32(hex32) {
+    const hex = hex32.toLowerCase();
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function uuidFromSeed(seed) {
+    const hex = sha256Hex(seed);
+    // Make it UUIDv4-ish (version nibble "4", variant "8") so regex validators accept it.
+    const chars = hex.split('');
+    if (chars.length >= 32) {
+        chars[12] = '4';
+        chars[16] = '8';
+    }
+    return formatUuidFromHex32(chars.slice(0, 32).join(''));
+}
+function normalizeSessionUuid(candidate) {
+    const raw = readTrimmedString(candidate);
+    if (!raw)
+        return undefined;
+    const match = raw.match(SESSION_TOKEN_REGEX);
+    const trimmed = (match && match[1] ? match[1] : raw).trim();
+    if (UUID_REGEX.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    const compact = trimmed.replace(/-/g, '');
+    if (HEX_32_REGEX.test(compact)) {
+        return formatUuidFromHex32(compact);
+    }
+    return uuidFromSeed(trimmed);
+}
+function resolveClaudeCodeUserId(metadata, adapterContext) {
+    const existing = readTrimmedString(metadata.user_id);
+    if (isClaudeCodeUserId(existing)) {
+        return existing;
+    }
+    const envUserId = readTrimmedString(process.env[DEFAULT_USER_ID_ENV]);
+    if (isClaudeCodeUserId(envUserId)) {
+        return envUserId;
+    }
+    const clientHeaders = isRecord(metadata.clientHeaders) ? metadata.clientHeaders : undefined;
+    const ctx = isRecord(adapterContext) ? adapterContext : undefined;
+    const sessionUuid = normalizeSessionUuid(existing) ||
+        normalizeSessionUuid(envUserId) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.session_id)) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.['anthropic-session-id'])) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.['x-session-id'])) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.conversation_id)) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.['anthropic-conversation-id'])) ||
+        normalizeSessionUuid(readTrimmedString(clientHeaders?.['openai-conversation-id'])) ||
+        normalizeSessionUuid(readTrimmedString(metadata.sessionId)) ||
+        normalizeSessionUuid(readTrimmedString(metadata.conversationId)) ||
+        normalizeSessionUuid(readTrimmedString(ctx?.sessionId)) ||
+        normalizeSessionUuid(readTrimmedString(ctx?.conversationId));
+    const accountSeed = readTrimmedString(process.env[DEFAULT_ACCOUNT_SEED_ENV]) ||
+        readTrimmedString(process.env.USER) ||
+        'routecodex';
+    try {
+        const accountHash = sha256Hex(accountSeed);
+        const session = sessionUuid ?? randomUUID();
+        return `user_${accountHash}_account__session_${session}`;
+    }
+    catch {
+        // As a last resort, keep compatibility best-effort.
+        const session = sessionUuid ?? randomUUID();
+        return `user_${'0'.repeat(64)}_account__session_${session}`;
+    }
+    // unreachable
+}
 function normalizeSystemBlocks(system) {
     const blocks = [];
     const pushText = (text, extra) => {
@@ -63,15 +153,33 @@ function dedupeSystemBlocksByText(blocks) {
     }
     return result;
 }
+function prependUserContent(messages, blocks) {
+    if (!Array.isArray(messages) || blocks.length === 0) {
+        return;
+    }
+    const first = messages[0];
+    if (isRecord(first) && typeof first.role === 'string' && first.role.toLowerCase() === 'user') {
+        const existing = first.content;
+        if (typeof existing === 'string') {
+            const injected = blocks.map((b) => b.text).filter(Boolean).join('\n\n');
+            first.content = existing.trim() ? `${injected}\n\n${existing}` : injected;
+            return;
+        }
+        if (Array.isArray(existing)) {
+            first.content = [...blocks, ...existing];
+            return;
+        }
+        first.content = [...blocks];
+        return;
+    }
+    messages.unshift({ role: 'user', content: [...blocks] });
+}
 /**
- * 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).
+ * Canonicalizes the Anthropic `system` prompt into a single text block.
+ * Optionally preserves previous system blocks by prepending them to the first user message,
+ * so request semantics are preserved after normalization.
  */
-export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config) {
+export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config, adapterContext) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return payload;
     }
@@ -79,23 +187,34 @@ export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config) {
     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];
+    // Some Claude-Code-gated Anthropic proxies require the top-level `metadata` field to exist.
+    // We don't inspect/repair semantics: just ensure the field is present as an object.
+    if (!isRecord(root.metadata)) {
+        root.metadata = {};
     }
-    else if (existingBlocks.length === 0) {
-        nextBlocks = [official];
+    // Some proxies also require `metadata.user_id` to be present.
+    // Fill it with Claude Code's canonical `user_<sha256>_account__session_<uuid>` shape.
+    try {
+        const userId = resolveClaudeCodeUserId(root.metadata, adapterContext);
+        const current = readTrimmedString(root.metadata.user_id);
+        if (userId && !isClaudeCodeUserId(current)) {
+            root.metadata.user_id = userId;
+        }
     }
-    else if (existingBlocks[0].text !== systemText) {
-        nextBlocks = [official, ...existingBlocks.filter((b) => b.text !== systemText)];
+    catch {
+        // best-effort: never block compat due to metadata shaping failures
     }
-    else {
-        nextBlocks = [existingBlocks[0], ...existingBlocks.slice(1).filter((b) => b.text !== systemText)];
-        nextBlocks[0] = { ...nextBlocks[0], type: 'text', text: systemText };
+    const preserveExisting = config?.preserveExistingSystemAsUserMessage !== false;
+    const existingBlocks = dedupeSystemBlocksByText(normalizeSystemBlocks(root.system))
+        .filter((b) => b.text !== systemText);
+    // Normalize: force system into a single text block.
+    root.system = [{ type: 'text', text: systemText }];
+    if (preserveExisting && existingBlocks.length) {
+        const messages = Array.isArray(root.messages) ? root.messages : [];
+        if (messages.length || root.messages !== undefined) {
+            prependUserContent(messages, existingBlocks);
+            root.messages = messages;
+        }
     }
-    root.system = nextBlocks;
     return root;
 }

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

@@ -1,7 +1,42 @@
-import { cacheAntigravitySessionSignature, getAntigravityRequestSessionMeta } from '../antigravity-session-signature.js';
+import { ANTIGRAVITY_GLOBAL_ALIAS_KEY, cacheAntigravitySessionSignature, getAntigravityRequestSessionMeta } from '../antigravity-session-signature.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+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;
+    }
+    // Antigravity-Manager alignment: never hash/derive session ids from external session/conversation identifiers here.
+    // If the caller already provides a proper fingerprint (sid-*), we can use it as a last-resort fallback.
+    return raw.toLowerCase().startsWith('sid-') ? raw : undefined;
+}
+function resolveAntigravityAliasKey(adapterContext) {
+    if (!adapterContext) {
+        return 'antigravity.unknown';
+    }
+    const ctxAny = adapterContext;
+    const candidates = [ctxAny.runtimeKey, ctxAny.providerKey, ctxAny.providerId].filter((v) => typeof v === 'string');
+    for (const value of candidates) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            continue;
+        const lower = trimmed.toLowerCase();
+        if (lower.startsWith('antigravity.')) {
+            const parts = trimmed.split('.');
+            if (parts.length >= 2 && parts[0] && parts[1]) {
+                return `${parts[0].trim()}.${parts[1].trim()}`;
+            }
+        }
+        return trimmed;
+    }
+    return 'antigravity.unknown';
+}
 function shouldEnableForAdapter(adapterContext) {
     if (!adapterContext) {
         return false;
@@ -10,14 +45,24 @@ function shouldEnableForAdapter(adapterContext) {
     if (protocol !== 'gemini-chat') {
         return false;
     }
-    const providerIdOrKey = typeof adapterContext.providerId === 'string' ? adapterContext.providerId.trim().toLowerCase() : '';
+    const ctxAny = adapterContext;
+    const providerIdOrKeyRaw = typeof ctxAny.providerId === 'string'
+        ? String(ctxAny.providerId)
+        : typeof ctxAny.providerKey === 'string'
+            ? String(ctxAny.providerKey)
+            : typeof ctxAny.runtimeKey === 'string'
+                ? String(ctxAny.runtimeKey)
+                : '';
+    const providerIdOrKey = providerIdOrKeyRaw.trim().toLowerCase();
     const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
-    return effectiveProviderId === 'antigravity';
+    // Antigravity-Manager alignment: thoughtSignature compat applies to both Antigravity and Gemini CLI.
+    return effectiveProviderId === 'antigravity' || effectiveProviderId === 'gemini-cli';
 }
 export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adapterContext) {
     if (!shouldEnableForAdapter(adapterContext)) {
         return payload;
     }
+    const fallbackAliasKey = resolveAntigravityAliasKey(adapterContext);
     const ctxAny = adapterContext;
     const payloadAny = payload;
     const keyCandidates = [
@@ -27,16 +72,25 @@ export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adap
         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 aliasKey = fallbackAliasKey;
     let sessionId = '';
     let messageCount = 1;
     for (const key of keyCandidates) {
         const resolved = getAntigravityRequestSessionMeta(key);
         if (resolved && resolved.sessionId.trim().length) {
+            aliasKey = typeof resolved.aliasKey === 'string' && resolved.aliasKey.trim().length ? resolved.aliasKey.trim() : fallbackAliasKey;
             sessionId = resolved.sessionId.trim();
             messageCount = resolved.messageCount;
             break;
         }
     }
+    if (!sessionId) {
+        const stable = resolveStableSessionId(adapterContext);
+        if (stable) {
+            sessionId = stable;
+            messageCount = 1;
+        }
+    }
     if (!sessionId) {
         return payload;
     }
@@ -47,14 +101,18 @@ export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adap
         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;
+            const sig = typeof part.thoughtSignature === 'string'
+                ? String(part.thoughtSignature)
+                : typeof part.thought_signature === 'string'
+                    ? String(part.thought_signature)
+                    : '';
+            if (sig.trim().length) {
+                cacheAntigravitySessionSignature(aliasKey, sessionId, sig.trim(), messageCount);
+                // Antigravity-Manager alignment: also store into the global signature store for this session.
+                if (aliasKey !== ANTIGRAVITY_GLOBAL_ALIAS_KEY) {
+                    cacheAntigravitySessionSignature(ANTIGRAVITY_GLOBAL_ALIAS_KEY, sessionId, sig.trim(), messageCount);
+                }
             }
-            cacheAntigravitySessionSignature(sessionId, sig.trim(), messageCount);
         }
     }
     return payload;

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

@@ -1,5 +1,4 @@
-import { createHash } from 'node:crypto';
-import { cacheAntigravityRequestSessionMeta, clearAntigravitySessionSignature, extractAntigravityGeminiSessionId, getAntigravitySessionSignatureEntry, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
+import { ANTIGRAVITY_GLOBAL_ALIAS_KEY, cacheAntigravityRequestSessionMeta, clearAntigravitySessionSignature, extractAntigravityGeminiSessionId, getAntigravityLatestSignatureSessionIdForAlias, lookupAntigravitySessionSignatureEntry, markAntigravitySessionSignatureRewind, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -11,9 +10,31 @@ function shouldEnableForAdapter(adapterContext) {
     if (protocol !== 'gemini-chat') {
         return false;
     }
-    const providerIdOrKey = typeof adapterContext.providerId === 'string' ? adapterContext.providerId.trim().toLowerCase() : '';
+    const ctxAny = adapterContext;
+    const providerIdOrKeyRaw = typeof ctxAny.providerId === 'string'
+        ? String(ctxAny.providerId)
+        : typeof ctxAny.providerKey === 'string'
+            ? String(ctxAny.providerKey)
+            : typeof ctxAny.runtimeKey === 'string'
+                ? String(ctxAny.runtimeKey)
+                : '';
+    const providerIdOrKey = providerIdOrKeyRaw.trim().toLowerCase();
     const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
-    return effectiveProviderId === 'antigravity';
+    // Antigravity-Manager alignment: thoughtSignature compat applies to both Antigravity and Gemini CLI
+    // (both route to Google Gemini internals that enforce thoughtSignature on tool loops).
+    return effectiveProviderId === 'antigravity' || effectiveProviderId === 'gemini-cli';
+}
+function shouldEnableSignatureRecovery(adapterContext) {
+    if (!adapterContext) {
+        return false;
+    }
+    const ctxAny = adapterContext;
+    const rtRaw = ctxAny.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    return rt.antigravityThoughtSignatureRecovery === true;
 }
 function locateGeminiContentsNode(root) {
     if (Array.isArray(root.contents)) {
@@ -29,23 +50,79 @@ function locateGeminiContentsNode(root) {
     }
     return undefined;
 }
-function sha256Hex(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function resolveStableSessionId(adapterContext) {
+function resolveAntigravityAliasKey(adapterContext) {
     if (!adapterContext) {
-        return undefined;
+        return 'antigravity.unknown';
     }
     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;
+    const candidates = [ctxAny.runtimeKey, ctxAny.providerKey, ctxAny.providerId].filter((v) => typeof v === 'string');
+    for (const value of candidates) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            continue;
+        const lower = trimmed.toLowerCase();
+        if (lower.startsWith('antigravity.')) {
+            const parts = trimmed.split('.');
+            if (parts.length >= 2 && parts[0] && parts[1]) {
+                return `${parts[0].trim()}.${parts[1].trim()}`;
+            }
+        }
+        return trimmed;
     }
-    if (raw.toLowerCase().startsWith('sid-')) {
-        return raw;
+    return 'antigravity.unknown';
+}
+function stripThoughtSignatures(contentsNode) {
+    const contentsRaw = contentsNode.contents;
+    if (!Array.isArray(contentsRaw)) {
+        return;
     }
-    return `sid-${sha256Hex(raw).slice(0, 16)}`;
+    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 ('thoughtSignature' in part) {
+                delete part.thoughtSignature;
+            }
+            if ('thought_signature' in part) {
+                delete part.thought_signature;
+            }
+        }
+    }
+}
+const ANTIGRAVITY_SIGNATURE_RECOVERY_PROMPT = "\n\n[System Recovery] Your previous output contained an invalid signature. Please regenerate the response without the corrupted signature block.";
+function injectSignatureRecoveryPrompt(contentsNode) {
+    const contentsRaw = contentsNode.contents;
+    if (!Array.isArray(contentsRaw) || contentsRaw.length === 0) {
+        return;
+    }
+    const contents = contentsRaw;
+    const last = contents[contents.length - 1];
+    if (!isRecord(last)) {
+        return;
+    }
+    const partsRaw = last.parts;
+    if (!Array.isArray(partsRaw)) {
+        last.parts = [];
+    }
+    const parts = (Array.isArray(last.parts) ? last.parts : []);
+    const alreadyInjected = parts.some((part) => {
+        if (!isRecord(part))
+            return false;
+        const text = typeof part.text === 'string' ? String(part.text) : '';
+        return text.includes('[System Recovery]');
+    });
+    if (alreadyInjected) {
+        return;
+    }
+    parts.push({ text: ANTIGRAVITY_SIGNATURE_RECOVERY_PROMPT });
+    last.parts = parts;
 }
 function injectThoughtSignatureIntoFunctionCalls(contentsNode, signature) {
     const contentsRaw = contentsNode.contents;
@@ -77,9 +154,12 @@ export function prepareAntigravityThoughtSignatureForGeminiRequest(payload, adap
     if (!shouldEnableForAdapter(adapterContext)) {
         return payload;
     }
-    const stableSessionId = resolveStableSessionId(adapterContext);
-    const derivedSessionId = extractAntigravityGeminiSessionId(payload);
-    const sessionId = stableSessionId || derivedSessionId;
+    const aliasKey = resolveAntigravityAliasKey(adapterContext);
+    // Antigravity-Manager alignment: sessionId is derived from the first user text (or JSON fallback),
+    // not from external session/conversation identifiers injected by other clients/hosts.
+    const originalSessionId = extractAntigravityGeminiSessionId(payload);
+    let sessionId = originalSessionId;
+    let usedLeasedSession = false;
     const ctxAny = adapterContext;
     const keys = [
         adapterContext.requestId,
@@ -89,16 +169,64 @@ export function prepareAntigravityThoughtSignatureForGeminiRequest(payload, adap
     const root = payload;
     const contentsNode = locateGeminiContentsNode(root);
     const messageCount = contentsNode && Array.isArray(contentsNode.contents) ? contentsNode.contents.length : 1;
+    // Recovery mode: strip any user-provided / stale signatures and do not lease/inject from cache.
+    if (shouldEnableSignatureRecovery(adapterContext)) {
+        if (contentsNode) {
+            stripThoughtSignatures(contentsNode);
+            // Antigravity-Manager alignment: append a repair hint so Gemini can regenerate without a corrupted signature.
+            injectSignatureRecoveryPrompt(contentsNode);
+        }
+        for (const key of keys) {
+            cacheAntigravityRequestSessionMeta(key, { aliasKey, sessionId: originalSessionId, messageCount });
+        }
+        return payload;
+    }
+    const resolveLookup = (sid) => {
+        const direct = lookupAntigravitySessionSignatureEntry(aliasKey, sid, { hydrate: true });
+        if (typeof direct.signature === 'string' && direct.signature.trim().length) {
+            return direct;
+        }
+        return lookupAntigravitySessionSignatureEntry(ANTIGRAVITY_GLOBAL_ALIAS_KEY, sid, { hydrate: true });
+    };
+    let lookup = resolveLookup(sessionId);
+    const hasSignature = typeof lookup.signature === 'string' && lookup.signature.trim().length && typeof lookup.messageCount === 'number';
+    if (!hasSignature) {
+        // Requested behavior:
+        // - Once an alias has ever obtained a signature, remember its sessionId.
+        // - For new sessions hitting the same alias, temporarily use that signature sessionId.
+        // This avoids cold-start tool-call failures when the current request's derived sessionId has no cached signature yet.
+        const leasedSessionId = getAntigravityLatestSignatureSessionIdForAlias(aliasKey, { hydrate: true });
+        if (leasedSessionId && leasedSessionId.trim().length && leasedSessionId.trim() !== sessionId) {
+            const leasedLookup = resolveLookup(leasedSessionId.trim());
+            const leasedHasSignature = typeof leasedLookup.signature === 'string' &&
+                leasedLookup.signature.trim().length &&
+                typeof leasedLookup.messageCount === 'number';
+            if (leasedHasSignature) {
+                sessionId = leasedSessionId.trim();
+                lookup = leasedLookup;
+                usedLeasedSession = true;
+            }
+        }
+    }
+    const effectiveSessionId = sessionId;
     for (const key of keys) {
-        cacheAntigravityRequestSessionMeta(key, { sessionId, messageCount });
+        cacheAntigravityRequestSessionMeta(key, { aliasKey, sessionId: effectiveSessionId, messageCount });
     }
-    const cached = getAntigravitySessionSignatureEntry(sessionId);
+    const cached = typeof lookup.signature === 'string' && typeof lookup.messageCount === 'number'
+        ? { signature: lookup.signature, messageCount: lookup.messageCount }
+        : undefined;
     if (!cached) {
         return payload;
     }
-    if (typeof messageCount === 'number' && messageCount > 0 && messageCount < cached.messageCount) {
+    // Rewind detection is meaningful within the SAME session. When we lease a prior sessionId to reuse
+    // an existing signature, messageCount comparisons may be unrelated and should not invalidate the cache.
+    if (!usedLeasedSession && 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);
+        clearAntigravitySessionSignature(aliasKey, effectiveSessionId);
+        markAntigravitySessionSignatureRewind(aliasKey, effectiveSessionId, messageCount);
+        // Antigravity-Manager alignment: global signature store must also be blocked on rewinds.
+        clearAntigravitySessionSignature(ANTIGRAVITY_GLOBAL_ALIAS_KEY, effectiveSessionId);
+        markAntigravitySessionSignatureRewind(ANTIGRAVITY_GLOBAL_ALIAS_KEY, effectiveSessionId, messageCount);
         return payload;
     }
     if (!contentsNode) {