@jsonstudio/llms 0.6.1449 → 0.6.1643

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

@@ -1,4 +1,4 @@
-import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
+import { ANTIGRAVITY_GLOBAL_ALIAS_KEY, cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, lookupAntigravitySessionSignatureEntry, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
 const REQUEST_FIELDS = [
     'contents',
     'systemInstruction',
@@ -29,6 +29,51 @@ const TOOL_PARAM_WHITELIST = {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function extractAntigravityAliasKeyFromRequestId(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const raw = value.trim();
+    if (!raw) {
+        return undefined;
+    }
+    const match = raw.match(/antigravity\.([^.\\s]+)/i);
+    const alias = match && match[1] ? match[1].trim() : '';
+    if (!alias) {
+        return undefined;
+    }
+    return `antigravity.${alias}`.toLowerCase();
+}
+function resolveAntigravityAliasKey(adapterContext, requestIdHint) {
+    const ctxAny = adapterContext;
+    const candidates = [
+        ctxAny && typeof ctxAny.runtimeKey === 'string' ? String(ctxAny.runtimeKey) : '',
+        ctxAny && typeof ctxAny.providerKey === 'string' ? String(ctxAny.providerKey) : '',
+        ctxAny && typeof ctxAny.providerId === 'string' ? String(ctxAny.providerId) : '',
+        ctxAny && typeof ctxAny.requestId === 'string' ? String(ctxAny.requestId) : '',
+        typeof requestIdHint === 'string' ? String(requestIdHint) : ''
+    ].filter((v) => typeof v === 'string' && v.trim().length);
+    for (const value of candidates) {
+        const trimmed = value.trim();
+        const lower = trimmed.toLowerCase();
+        if (lower === 'antigravity') {
+            continue;
+        }
+        if (lower.startsWith('antigravity.')) {
+            const parts = trimmed.split('.');
+            if (parts.length >= 2 && parts[0] && parts[1]) {
+                return `${parts[0].trim()}.${parts[1].trim()}`.toLowerCase();
+            }
+            const extracted = extractAntigravityAliasKeyFromRequestId(trimmed);
+            if (extracted)
+                return extracted;
+        }
+        const extracted = extractAntigravityAliasKeyFromRequestId(trimmed);
+        if (extracted)
+            return extracted;
+    }
+    return 'antigravity.unknown';
+}
 function normalizeSchemaTypes(value) {
     if (!value || typeof value !== 'object')
         return value;
@@ -463,19 +508,23 @@ function shouldEnableAntigravitySignature(adapterContext) {
     if (protocol !== 'gemini-chat') {
         return false;
     }
-    // NOTE: In Hub adapterContext, `providerId` is historically populated with providerKey
-    // (e.g. "antigravity.<alias>.<model>") rather than the bare provider id.
+    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)
+                : '';
+    // NOTE: AdapterContext may carry providerKey (e.g. "antigravity.<alias>.<model>") instead of bare providerId.
     // Treat the first segment as the effective provider id for compatibility checks.
-    const providerIdOrKey = typeof adapterContext.providerId === 'string' ? adapterContext.providerId.trim().toLowerCase() : '';
+    const providerIdOrKey = providerIdOrKeyRaw.trim().toLowerCase();
     const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
     return effectiveProviderId === 'antigravity';
 }
-function injectAntigravityThoughtSignature(requestNode) {
-    const sessionId = extractAntigravityGeminiSessionId(requestNode);
-    const signature = getAntigravitySessionSignature(sessionId);
-    if (!signature) {
+function injectAntigravityThoughtSignature(requestNode, signature) {
+    if (!signature || !signature.trim())
         return;
-    }
     const contents = requestNode.contents;
     if (!Array.isArray(contents)) {
         return;
@@ -491,7 +540,7 @@ function injectAntigravityThoughtSignature(requestNode) {
                 continue;
             const existing = part.thoughtSignature;
             if (shouldTreatAsMissingThoughtSignature(existing)) {
-                part.thoughtSignature = signature;
+                part.thoughtSignature = signature.trim();
             }
         }
     }
@@ -520,10 +569,18 @@ export function wrapGeminiCliRequest(payload, adapterContext) {
         (typeof root.userAgent === 'string' && root.userAgent.trim().toLowerCase() === 'antigravity') ||
         (typeof root.requestId === 'string' && root.requestId.trim().toLowerCase().startsWith('agent-'));
     if (enableSignature) {
+        const aliasKey = resolveAntigravityAliasKey(adapterContext, root.requestId);
+        // Antigravity-Manager alignment: derive sessionId from request contents (first user text / JSON fallback),
+        // not from external session/conversation identifiers injected by other clients/hosts.
+        const sessionId = extractAntigravityGeminiSessionId(requestNode);
+        const directLookup = lookupAntigravitySessionSignatureEntry(aliasKey, sessionId, { hydrate: true });
+        const lookup = typeof directLookup.signature === 'string' && directLookup.signature.trim().length
+            ? directLookup
+            : lookupAntigravitySessionSignatureEntry(ANTIGRAVITY_GLOBAL_ALIAS_KEY, sessionId, { hydrate: true });
+        const effectiveSessionId = typeof lookup.sourceSessionId === 'string' && lookup.sourceSessionId.trim().length ? lookup.sourceSessionId.trim() : sessionId;
         // Antigravity-Manager alignment:
         if (adapterContext) {
             try {
-                const sessionId = extractAntigravityGeminiSessionId(requestNode);
                 const ctxAny = adapterContext;
                 const keys = [
                     adapterContext.requestId,
@@ -531,14 +588,16 @@ export function wrapGeminiCliRequest(payload, adapterContext) {
                     typeof ctxAny.groupRequestId === 'string' ? String(ctxAny.groupRequestId) : ''
                 ].filter((k) => typeof k === 'string' && k.trim().length);
                 for (const key of keys) {
-                    cacheAntigravityRequestSessionId(key, sessionId);
+                    cacheAntigravityRequestSessionId(key, aliasKey, effectiveSessionId);
                 }
             }
             catch {
                 // best-effort only
             }
         }
-        injectAntigravityThoughtSignature(requestNode);
+        if (typeof lookup.signature === 'string' && lookup.signature.trim().length) {
+            injectAntigravityThoughtSignature(requestNode, lookup.signature);
+        }
     }
     // Cloud Code Assist request wrapper should not carry metadata/action/web_search/stream.
     delete requestNode.metadata;

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

@@ -1,6 +1,26 @@
-export declare const DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export declare function configureAntigravitySessionSignaturePersistence(input: {
+    stateDir: string;
+    fileName?: string;
+} | null): void;
+export declare function flushAntigravitySessionSignaturePersistenceSync(): void;
+export declare const ANTIGRAVITY_GLOBAL_ALIAS_KEY = "antigravity.global";
+export declare function getAntigravityThoughtSignatureSentinel(): string;
+export declare function getAntigravityLatestSignatureSessionIdForAlias(aliasKeyInput: string, options?: {
+    hydrate?: boolean;
+}): string | undefined;
+export declare function cacheAntigravityRequestSessionId(requestId: string, aliasKey: string, sessionId: string): void;
 export declare function cacheAntigravityRequestSessionId(requestId: string, sessionId: string): void;
+export declare function cacheAntigravityRequestSessionMeta(requestId: string, meta: {
+    aliasKey?: string;
+    sessionId: string;
+    messageCount?: number;
+}): void;
 export declare function getAntigravityRequestSessionId(requestId: string): string | undefined;
+export declare function getAntigravityRequestSessionMeta(requestId: string): {
+    aliasKey: string;
+    sessionId: string;
+    messageCount: number;
+} | undefined;
 /**
  * Antigravity-Manager alignment: derive a stable session fingerprint for Gemini native requests.
  * - sha256(first user text parts joined), if len>10 and no "<system-reminder>"
@@ -8,6 +28,53 @@ export declare function getAntigravityRequestSessionId(requestId: string): strin
  * - sid = "sid-" + first 16 hex chars
  */
 export declare function extractAntigravityGeminiSessionId(payload: unknown): string;
+export declare function cacheAntigravitySessionSignature(aliasKey: string, sessionId: string, signature: string, messageCount?: number): void;
 export declare function cacheAntigravitySessionSignature(sessionId: string, signature: string, messageCount?: number): void;
+export declare function lookupAntigravityPinnedAliasForSessionId(sessionIdInput: string, options?: {
+    hydrate?: boolean;
+}): string | undefined;
+export declare function unpinAntigravitySessionAliasForSessionId(sessionIdInput: string): void;
+export declare function getAntigravitySessionSignature(aliasKey: string, sessionId: string): string | undefined;
 export declare function getAntigravitySessionSignature(sessionId: string): string | undefined;
+export type AntigravityThoughtSignatureLookupSource = 'session_cache' | 'miss' | 'blocked_unknown_alias' | 'blocked_rewind' | 'expired';
+export type AntigravityThoughtSignatureLookupResult = {
+    aliasKey: string;
+    sessionId: string;
+    cacheKey: string;
+    source: AntigravityThoughtSignatureLookupSource;
+    signature?: string;
+    messageCount?: number;
+    sourceSessionId?: string;
+    sourceTimestamp?: number;
+};
+export declare function lookupAntigravitySessionSignatureEntry(aliasKeyInput: string, sessionIdInput: string, options?: {
+    hydrate?: boolean;
+}): AntigravityThoughtSignatureLookupResult;
+export declare function getAntigravitySessionSignatureEntry(aliasKey: string, sessionId: string): {
+    signature: string;
+    messageCount: number;
+} | undefined;
+export declare function getAntigravitySessionSignatureEntry(aliasKey: string, sessionId: string, options?: {
+    hydrate?: boolean;
+}): {
+    signature: string;
+    messageCount: number;
+} | undefined;
+export declare function getAntigravitySessionSignatureEntry(sessionId: string, options?: {
+    hydrate?: boolean;
+}): {
+    signature: string;
+    messageCount: number;
+} | undefined;
+export declare function clearAntigravitySessionSignature(aliasKey: string, sessionId: string): void;
+export declare function clearAntigravitySessionSignature(sessionId: string): void;
+export declare function markAntigravitySessionSignatureRewind(aliasKey: string, sessionId: string, messageCount?: number): void;
+/**
+ * Clear thoughtSignature caches + pins for a specific (aliasKey, sessionId).
+ *
+ * Used for "Invalid signature / Corrupted thought signature / thinking.signature" style upstream errors,
+ * where keeping a persisted signature would cause repeated 400s after restart.
+ */
+export declare function invalidateAntigravitySessionSignature(aliasKeyInput: string, sessionIdInput: string): void;
+export declare function resetAntigravitySessionSignatureCachesForTests(): void;
 export declare function shouldTreatAsMissingThoughtSignature(value: unknown): boolean;