@jsonstudio/llms 0.6.1449 → 0.6.1462

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

@@ -4,7 +4,8 @@ import type { AnthropicClaudeCodeSystemPromptConfig } from '../../hub/pipeline/c
  * 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.
+ * 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).
  */
 export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig): JsonObject;

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

@@ -2,59 +2,74 @@ const DEFAULT_SYSTEM_TEXT = "You are Claude Code, Anthropic's official CLI for C
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
-function extractSystemText(system) {
+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;
-    }
-    return '';
-}
-function ensureUserMessage(messages) {
-    const first = messages[0];
-    if (isRecord(first) && typeof first.role === 'string' && first.role.toLowerCase() === 'user') {
-        return first;
+        const text = typeof system.text === 'string' ? system.text : '';
+        if (text) {
+            const extra = { ...system };
+            delete extra.type;
+            delete extra.text;
+            pushText(text, extra);
+        }
     }
-    const created = { role: 'user', content: '' };
-    messages.unshift(created);
-    return created;
+    return blocks;
 }
-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;
+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 });
     }
-    // Anthropic supports content blocks, but many upstreams accept string; fall back to string.
-    message.content = text;
+    return result;
 }
 /**
  * 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.
+ * 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).
  */
 export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
@@ -64,19 +79,23 @@ 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;
+    const preserveExisting = config?.preserveExistingSystemAsUserMessage !== false;
+    const existingBlocks = dedupeSystemBlocksByText(normalizeSystemBlocks(root.system));
+    const official = { type: 'text', text: systemText };
+    let nextBlocks = [];
+    if (!preserveExisting) {
+        nextBlocks = [official];
     }
-    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;
-        }
+    else if (existingBlocks.length === 0) {
+        nextBlocks = [official];
+    }
+    else if (existingBlocks[0].text !== systemText) {
+        nextBlocks = [official, ...existingBlocks.filter((b) => b.text !== systemText)];
+    }
+    else {
+        nextBlocks = [existingBlocks[0], ...existingBlocks.slice(1).filter((b) => b.text !== systemText)];
+        nextBlocks[0] = { ...nextBlocks[0], type: 'text', text: systemText };
     }
+    root.system = nextBlocks;
     return root;
 }

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

@@ -1,4 +1,4 @@
-import { cacheAntigravitySessionSignature, getAntigravityRequestSessionId } from '../antigravity-session-signature.js';
+import { cacheAntigravitySessionSignature, getAntigravityRequestSessionMeta } from '../antigravity-session-signature.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -28,17 +28,18 @@ export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adap
         typeof payloadAny.requestId === 'string' ? String(payloadAny.requestId) : ''
     ].filter((k) => typeof k === 'string' && k.trim().length);
     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) {
+            sessionId = resolved.sessionId.trim();
+            messageCount = resolved.messageCount;
             break;
         }
     }
     if (!sessionId) {
         return payload;
     }
-    const messageCount = 1;
     const candidatesRaw = payload.candidates;
     const candidates = Array.isArray(candidatesRaw) ? candidatesRaw : [];
     for (const candidate of candidates) {

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

@@ -1,4 +1,5 @@
-import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
+import { createHash } from 'node:crypto';
+import { cacheAntigravityRequestSessionMeta, clearAntigravitySessionSignature, extractAntigravityGeminiSessionId, getAntigravitySessionSignatureEntry, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -28,6 +29,24 @@ function locateGeminiContentsNode(root) {
     }
     return undefined;
 }
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+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;
+    }
+    if (raw.toLowerCase().startsWith('sid-')) {
+        return raw;
+    }
+    return `sid-${sha256Hex(raw).slice(0, 16)}`;
+}
 function injectThoughtSignatureIntoFunctionCalls(contentsNode, signature) {
     const contentsRaw = contentsNode.contents;
     if (!Array.isArray(contentsRaw)) {
@@ -58,25 +77,33 @@ export function prepareAntigravityThoughtSignatureForGeminiRequest(payload, adap
     if (!shouldEnableForAdapter(adapterContext)) {
         return payload;
     }
-    const sessionId = extractAntigravityGeminiSessionId(payload);
+    const stableSessionId = resolveStableSessionId(adapterContext);
+    const derivedSessionId = extractAntigravityGeminiSessionId(payload);
+    const sessionId = stableSessionId || derivedSessionId;
     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;
     for (const key of keys) {
-        cacheAntigravityRequestSessionId(key, sessionId);
+        cacheAntigravityRequestSessionMeta(key, { sessionId, messageCount });
     }
-    const signature = getAntigravitySessionSignature(sessionId);
-    if (!signature) {
+    const cached = getAntigravitySessionSignatureEntry(sessionId);
+    if (!cached) {
+        return payload;
+    }
+    if (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);
         return payload;
     }
-    const root = payload;
-    const contentsNode = locateGeminiContentsNode(root);
     if (!contentsNode) {
         return payload;
     }
-    injectThoughtSignatureIntoFunctionCalls(contentsNode, signature);
+    injectThoughtSignatureIntoFunctionCalls(contentsNode, cached.signature);
     return payload;
 }

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

@@ -1,6 +1,14 @@
 export declare const DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
 export declare function cacheAntigravityRequestSessionId(requestId: string, sessionId: string): void;
+export declare function cacheAntigravityRequestSessionMeta(requestId: string, meta: {
+    sessionId: string;
+    messageCount?: number;
+}): void;
 export declare function getAntigravityRequestSessionId(requestId: string): string | undefined;
+export declare function getAntigravityRequestSessionMeta(requestId: 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>"
@@ -10,4 +18,9 @@ export declare function getAntigravityRequestSessionId(requestId: string): strin
 export declare function extractAntigravityGeminiSessionId(payload: unknown): string;
 export declare function cacheAntigravitySessionSignature(sessionId: string, signature: string, messageCount?: number): void;
 export declare function getAntigravitySessionSignature(sessionId: string): string | undefined;
+export declare function getAntigravitySessionSignatureEntry(sessionId: string): {
+    signature: string;
+    messageCount: number;
+} | undefined;
+export declare function clearAntigravitySessionSignature(sessionId: string): void;
 export declare function shouldTreatAsMissingThoughtSignature(value: unknown): boolean;

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

@@ -95,13 +95,19 @@ function ensureCacheLimit() {
     }
 }
 export function cacheAntigravityRequestSessionId(requestId, sessionId) {
+    cacheAntigravityRequestSessionMeta(requestId, { sessionId });
+}
+export function cacheAntigravityRequestSessionMeta(requestId, meta) {
     const rid = typeof requestId === 'string' ? requestId.trim() : '';
-    const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+    const sid = typeof meta?.sessionId === 'string' ? meta.sessionId.trim() : '';
     if (!rid || !sid) {
         return;
     }
+    const messageCount = typeof meta?.messageCount === 'number' && Number.isFinite(meta.messageCount) && meta.messageCount > 0
+        ? Math.floor(meta.messageCount)
+        : 1;
     const ts = nowMs();
-    requestSessionIds.set(rid, { sessionId: sid, timestamp: ts });
+    requestSessionIds.set(rid, { sessionId: sid, messageCount, timestamp: ts });
     if (requestSessionIds.size <= SESSION_CACHE_LIMIT) {
         return;
     }
@@ -116,6 +122,10 @@ export function cacheAntigravityRequestSessionId(requestId, sessionId) {
     }
 }
 export function getAntigravityRequestSessionId(requestId) {
+    const meta = getAntigravityRequestSessionMeta(requestId);
+    return meta?.sessionId;
+}
+export function getAntigravityRequestSessionMeta(requestId) {
     const rid = typeof requestId === 'string' ? requestId.trim() : '';
     if (!rid) {
         return undefined;
@@ -129,7 +139,7 @@ export function getAntigravityRequestSessionId(requestId) {
         requestSessionIds.delete(rid);
         return undefined;
     }
-    return entry.sessionId;
+    return { sessionId: entry.sessionId, messageCount: entry.messageCount };
 }
 function findGeminiContentsNode(payload) {
     if (!isRecord(payload)) {
@@ -221,6 +231,9 @@ export function cacheAntigravitySessionSignature(sessionId, signature, messageCo
     ensureCacheLimit();
 }
 export function getAntigravitySessionSignature(sessionId) {
+    return getAntigravitySessionSignatureEntry(sessionId)?.signature;
+}
+export function getAntigravitySessionSignatureEntry(sessionId) {
     if (typeof sessionId !== 'string' || !sessionId.trim()) {
         return undefined;
     }
@@ -234,7 +247,13 @@ export function getAntigravitySessionSignature(sessionId) {
         sessionSignatures.delete(key);
         return undefined;
     }
-    return entry.signature;
+    return { signature: entry.signature, messageCount: entry.messageCount };
+}
+export function clearAntigravitySessionSignature(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+        return;
+    }
+    sessionSignatures.delete(sessionId.trim());
 }
 export function shouldTreatAsMissingThoughtSignature(value) {
     if (typeof value !== 'string') {

package/dist/conversion/compat/profiles/anthropic-claude-code.json

@@ -0,0 +1,26 @@
+{
+  "id": "anthropic:claude-code",
+  "protocol": "anthropic-messages",
+  "request": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      { "action": "set_default", "path": "metadata", "value": {} },
+      { "action": "set", "path": "metadata.userAgent", "value": "Claude-Code/2.1.25 (macos; arm64)" },
+      { "action": "set", "path": "metadata.clientOriginator", "value": "claude-code" },
+      { "action": "set_default", "path": "metadata.clientHeaders", "value": {} },
+      { "action": "set", "path": "metadata.clientHeaders.User-Agent", "value": "Claude-Code/2.1.25 (macos; arm64)" },
+      { "action": "set", "path": "metadata.clientHeaders.originator", "value": "claude-code" },
+      { "action": "set", "path": "metadata.clientHeaders.X-App", "value": "claude-code" },
+      { "action": "set", "path": "metadata.clientHeaders.x-app-version", "value": "2.1.25" },
+      { "action": "set", "path": "metadata.clientHeaders.anthropic-beta", "value": "claude-code-20250219,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05" },
+      {
+        "action": "anthropic_claude_code_system_prompt",
+        "config": { "preserveExistingSystemAsUserMessage": true }
+      },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  },
+  "response": {
+    "mappings": []
+  }
+}

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

@@ -28,6 +28,9 @@ export function runRequestCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'request');
     if (!stage) {
         return { payload };
@@ -49,6 +52,9 @@ export function runResponseCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'response');
     if (!stage) {
         return { payload };
@@ -95,6 +101,16 @@ function pickStageConfig(profile, stage) {
     }
     return null;
 }
+function isProtocolCompatible(profile, adapterContext) {
+    const required = typeof profile.protocol === 'string' ? profile.protocol.trim().toLowerCase() : '';
+    if (!required) {
+        return true;
+    }
+    const actual = typeof adapterContext?.providerProtocol === 'string' && adapterContext.providerProtocol.trim()
+        ? adapterContext.providerProtocol.trim().toLowerCase()
+        : '';
+    return Boolean(actual) && actual === required;
+}
 function applyMapping(root, mapping, state) {
     switch (mapping.action) {
         case 'remove':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.1449",
+  "version": "0.6.1462",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",