@jsonstudio/llms 0.6.1449 → 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,10 +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 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.
+ * 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,62 +1,185 @@
+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 extractSystemText(system) {
+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) => {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return;
+        }
+        blocks.push({
+            ...(extra ?? {}),
+            type: 'text',
+            text: trimmed
+        });
+    };
     if (typeof system === 'string') {
-        return system.trim();
+        pushText(system);
+        return blocks;
     }
     if (Array.isArray(system)) {
-        const parts = [];
         for (const entry of system) {
             if (typeof entry === 'string') {
-                if (entry.trim())
-                    parts.push(entry.trim());
+                pushText(entry);
                 continue;
             }
-            if (!isRecord(entry))
+            if (!isRecord(entry)) {
                 continue;
-            const text = typeof entry.text === 'string' ? entry.text.trim() : '';
-            if (text)
-                parts.push(text);
+            }
+            const text = typeof entry.text === 'string' ? entry.text : '';
+            if (text) {
+                const extra = { ...entry };
+                delete extra.type;
+                delete extra.text;
+                pushText(text, extra);
+            }
         }
-        return parts.join('\n').trim();
+        return blocks;
     }
     if (isRecord(system)) {
-        const text = typeof system.text === 'string' ? system.text.trim() : '';
-        return text;
+        const text = typeof system.text === 'string' ? system.text : '';
+        if (text) {
+            const extra = { ...system };
+            delete extra.type;
+            delete extra.text;
+            pushText(text, extra);
+        }
     }
-    return '';
+    return blocks;
 }
-function ensureUserMessage(messages) {
-    const first = messages[0];
-    if (isRecord(first) && typeof first.role === 'string' && first.role.toLowerCase() === 'user') {
-        return first;
+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 });
     }
-    const created = { role: 'user', content: '' };
-    messages.unshift(created);
-    return created;
+    return result;
 }
-function appendUserText(message, text) {
-    if (!text.trim()) {
+function prependUserContent(messages, blocks) {
+    if (!Array.isArray(messages) || blocks.length === 0) {
         return;
     }
-    const existing = message.content;
-    if (typeof existing === 'string') {
-        message.content = existing.trim() ? `${text}\n\n${existing}` : text;
+    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;
     }
-    // Anthropic supports content blocks, but many upstreams accept string; fall back to string.
-    message.content = text;
+    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 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.
+ * 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;
     }
@@ -64,17 +187,32 @@ export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config) {
     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;
+    // 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 = {};
+    }
+    // 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;
+        }
+    }
+    catch {
+        // best-effort: never block compat due to metadata shaping failures
     }
-    const preserve = config?.preserveExistingSystemAsUserMessage !== false;
-    if (!already && preserve && existingSystemText && existingSystemText !== 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) {
-            const msg = ensureUserMessage(messages);
-            appendUserText(msg, existingSystemText);
+            prependUserContent(messages, existingBlocks);
             root.messages = messages;
         }
     }

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

@@ -1,7 +1,42 @@
-import { cacheAntigravitySessionSignature, getAntigravityRequestSessionId } 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,18 +72,28 @@ 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 = getAntigravityRequestSessionId(key);
-        if (resolved && resolved.trim().length) {
-            sessionId = resolved.trim();
+        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;
     }
-    const messageCount = 1;
     const candidatesRaw = payload.candidates;
     const candidates = Array.isArray(candidatesRaw) ? candidatesRaw : [];
     for (const candidate of candidates) {
@@ -46,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,4 +1,4 @@
-import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, 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);
 }
@@ -10,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)) {
@@ -28,6 +50,80 @@ function locateGeminiContentsNode(root) {
     }
     return 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 stripThoughtSignatures(contentsNode) {
+    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 ('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;
     if (!Array.isArray(contentsRaw)) {
@@ -58,25 +154,84 @@ export function prepareAntigravityThoughtSignatureForGeminiRequest(payload, adap
     if (!shouldEnableForAdapter(adapterContext)) {
         return payload;
     }
-    const sessionId = extractAntigravityGeminiSessionId(payload);
+    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,
         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;
+    // 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) {
-        cacheAntigravityRequestSessionId(key, sessionId);
+        cacheAntigravityRequestSessionMeta(key, { aliasKey, sessionId: effectiveSessionId, messageCount });
     }
-    const signature = getAntigravitySessionSignature(sessionId);
-    if (!signature) {
+    const cached = typeof lookup.signature === 'string' && typeof lookup.messageCount === 'number'
+        ? { signature: lookup.signature, messageCount: lookup.messageCount }
+        : undefined;
+    if (!cached) {
+        return payload;
+    }
+    // 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(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;
     }
-    const root = payload;
-    const contentsNode = locateGeminiContentsNode(root);
     if (!contentsNode) {
         return payload;
     }
-    injectThoughtSignatureIntoFunctionCalls(contentsNode, signature);
+    injectThoughtSignatureIntoFunctionCalls(contentsNode, cached.signature);
     return payload;
 }