@jsonstudio/llms 0.6.1403 → 0.6.1435

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

@@ -5,7 +5,6 @@ import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
 import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 import { ProviderProtocolError } from '../shared/errors.js';
-const DUMMY_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -229,9 +228,13 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         // 5. Function call (tool call)
         if (pObj.functionCall && typeof pObj.functionCall === 'object') {
             const fc = pObj.functionCall;
-            const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
+            let name = typeof fc.name === 'string' ? String(fc.name) : undefined;
             if (!name)
                 continue;
+            // Gemini "websearch" is a transport alias for the canonical server-side tool "web_search".
+            if (name === 'websearch' || name.startsWith('websearch_')) {
+                name = 'web_search';
+            }
             let id = typeof fc.id === 'string' && fc.id.trim().length ? String(fc.id).trim() : undefined;
             const argsRaw = (fc.args ?? fc.arguments);
             let argsStr;
@@ -268,7 +271,10 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         if (pObj.functionResponse && typeof pObj.functionResponse === 'object') {
             const fr = pObj.functionResponse;
             const callId = typeof fr.id === 'string' && fr.id.trim().length ? String(fr.id) : undefined;
-            const name = typeof fr.name === 'string' && fr.name.trim().length ? String(fr.name) : undefined;
+            let name = typeof fr.name === 'string' && fr.name.trim().length ? String(fr.name) : undefined;
+            if (name && (name === 'websearch' || name.startsWith('websearch_'))) {
+                name = 'web_search';
+            }
             const resp = fr.response;
             let contentStr = '';
             if (typeof resp === 'string') {
@@ -568,7 +574,7 @@ export function buildGeminiFromOpenAIChat(chatResp) {
         const id = typeof tc.id === 'string' ? String(tc.id) : undefined;
         if (id)
             functionCall.id = id;
-        const thoughtSignature = extractThoughtSignatureFromToolCall(tc) ?? DUMMY_THOUGHT_SIGNATURE;
+        const thoughtSignature = extractThoughtSignatureFromToolCall(tc);
         const partEntry = { functionCall };
         if (thoughtSignature) {
             partEntry.thoughtSignature = thoughtSignature;

package/dist/conversion/compat/actions/antigravity-thought-signature-cache.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 cacheAntigravityThoughtSignatureFromGeminiResponse(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

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

@@ -0,0 +1,60 @@
+import { cacheAntigravitySessionSignature, getAntigravityRequestSessionId } 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';
+}
+export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adapterContext) {
+    if (!shouldEnableForAdapter(adapterContext)) {
+        return payload;
+    }
+    const ctxAny = adapterContext;
+    const payloadAny = payload;
+    const keyCandidates = [
+        adapterContext?.requestId,
+        typeof ctxAny.clientRequestId === 'string' ? String(ctxAny.clientRequestId) : '',
+        typeof ctxAny.groupRequestId === 'string' ? String(ctxAny.groupRequestId) : '',
+        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 sessionId = '';
+    for (const key of keyCandidates) {
+        const resolved = getAntigravityRequestSessionId(key);
+        if (resolved && resolved.trim().length) {
+            sessionId = resolved.trim();
+            break;
+        }
+    }
+    if (!sessionId) {
+        return payload;
+    }
+    const messageCount = 1;
+    const candidatesRaw = payload.candidates;
+    const candidates = Array.isArray(candidatesRaw) ? candidatesRaw : [];
+    for (const candidate of candidates) {
+        const content = isRecord(candidate.content) ? candidate.content : undefined;
+        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;
+            }
+            cacheAntigravitySessionSignature(sessionId, sig.trim(), messageCount);
+        }
+    }
+    return payload;
+}

package/dist/conversion/compat/actions/gemini-cli-request.d.ts

@@ -1,2 +1,3 @@
 import type { JsonObject } from '../../hub/types/json.js';
-export declare function wrapGeminiCliRequest(payload: JsonObject): JsonObject;
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+export declare function wrapGeminiCliRequest(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

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

@@ -1,3 +1,4 @@
+import { cacheAntigravityRequestSessionId, extractAntigravityGeminiSessionId, getAntigravitySessionSignature, shouldTreatAsMissingThoughtSignature } from '../antigravity-session-signature.js';
 const REQUEST_FIELDS = [
     'contents',
     'systemInstruction',
@@ -368,7 +369,6 @@ function normalizeFunctionCallArgs(node) {
             const fnCall = part.functionCall;
             if (!isRecord(fnCall))
                 continue;
-            part.thoughtSignature = 'skip_thought_signature_validator';
             const rawName = typeof fnCall.name === 'string' ? fnCall.name.trim() : '';
             const normalizedName = (TOOL_NAME_ALIASES[rawName] ?? rawName).trim();
             fnCall.name = normalizedName;
@@ -453,7 +453,50 @@ function stripWebSearchTools(requestNode) {
         delete requestNode.tools;
     }
 }
-export function wrapGeminiCliRequest(payload) {
+function shouldEnableAntigravitySignature(adapterContext) {
+    // Prefer adapterContext (canonical) but fall back to transport hints for cases where
+    // host doesn't populate providerId (e.g. certain v1/v2 bridges).
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return false;
+    }
+    const protocol = typeof adapterContext.providerProtocol === 'string' ? adapterContext.providerProtocol.trim().toLowerCase() : '';
+    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.
+    // Treat the first segment as the effective provider id for compatibility checks.
+    const providerIdOrKey = typeof adapterContext.providerId === 'string' ? adapterContext.providerId.trim().toLowerCase() : '';
+    const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
+    return effectiveProviderId === 'antigravity';
+}
+function injectAntigravityThoughtSignature(requestNode) {
+    const sessionId = extractAntigravityGeminiSessionId(requestNode);
+    const signature = getAntigravitySessionSignature(sessionId);
+    if (!signature) {
+        return;
+    }
+    const contents = requestNode.contents;
+    if (!Array.isArray(contents)) {
+        return;
+    }
+    for (const item of contents) {
+        if (!isRecord(item))
+            continue;
+        const parts = Array.isArray(item.parts) ? item.parts : [];
+        for (const part of parts) {
+            if (!isRecord(part))
+                continue;
+            if (!isRecord(part.functionCall))
+                continue;
+            const existing = part.thoughtSignature;
+            if (shouldTreatAsMissingThoughtSignature(existing)) {
+                part.thoughtSignature = signature;
+            }
+        }
+    }
+}
+export function wrapGeminiCliRequest(payload, adapterContext) {
     const root = { ...payload };
     const existingRequest = isRecord(root.request) ? normalizeRequestNode(root.request) : undefined;
     const requestNode = existingRequest ?? {};
@@ -471,6 +514,32 @@ export function wrapGeminiCliRequest(payload) {
     stripWebSearchTools(requestNode);
     normalizeToolDeclarations(requestNode);
     normalizeFunctionCallArgs(requestNode);
+    const enableSignature = shouldEnableAntigravitySignature(adapterContext) ||
+        (typeof requestNode.userAgent === 'string' && requestNode.userAgent.trim().toLowerCase() === 'antigravity') ||
+        (typeof requestNode.requestId === 'string' && requestNode.requestId.trim().toLowerCase().startsWith('agent-')) ||
+        (typeof root.userAgent === 'string' && root.userAgent.trim().toLowerCase() === 'antigravity') ||
+        (typeof root.requestId === 'string' && root.requestId.trim().toLowerCase().startsWith('agent-'));
+    if (enableSignature) {
+        // Antigravity-Manager alignment:
+        if (adapterContext) {
+            try {
+                const sessionId = extractAntigravityGeminiSessionId(requestNode);
+                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);
+                }
+            }
+            catch {
+                // best-effort only
+            }
+        }
+        injectAntigravityThoughtSignature(requestNode);
+    }
     // Cloud Code Assist request wrapper should not carry metadata/action/web_search/stream.
     delete requestNode.metadata;
     delete requestNode.action;

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

@@ -0,0 +1,13 @@
+export declare const DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export declare function cacheAntigravityRequestSessionId(requestId: string, sessionId: string): void;
+export declare function getAntigravityRequestSessionId(requestId: string): string | 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>"
+ * - else sha256(JSON body)
+ * - sid = "sid-" + first 16 hex chars
+ */
+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 shouldTreatAsMissingThoughtSignature(value: unknown): boolean;

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

@@ -0,0 +1,245 @@
+import { createHash } from 'node:crypto';
+export const DUMMY_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+// Antigravity-Manager alignment: Node proxy uses 2 hours TTL.
+const SIGNATURE_TTL_MS = 2 * 60 * 60 * 1000;
+const MIN_SIGNATURE_LENGTH = 50;
+const SESSION_CACHE_LIMIT = 1000;
+const GLOBAL_SIGNATURE_CACHE_KEY = '__LLMSWITCH_ANTIGRAVITY_SESSION_SIGNATURE_CACHE__';
+const GLOBAL_REQUEST_SESSION_CACHE_KEY = '__LLMSWITCH_ANTIGRAVITY_REQUEST_SESSION_ID_CACHE__';
+function getGlobalSignatureCache() {
+    const g = globalThis;
+    const existing = g[GLOBAL_SIGNATURE_CACHE_KEY];
+    if (existing instanceof Map) {
+        return existing;
+    }
+    const created = new Map();
+    g[GLOBAL_SIGNATURE_CACHE_KEY] = created;
+    return created;
+}
+const sessionSignatures = getGlobalSignatureCache();
+function getGlobalRequestSessionCache() {
+    const g = globalThis;
+    const existing = g[GLOBAL_REQUEST_SESSION_CACHE_KEY];
+    if (existing instanceof Map) {
+        return existing;
+    }
+    const created = new Map();
+    g[GLOBAL_REQUEST_SESSION_CACHE_KEY] = created;
+    return created;
+}
+const requestSessionIds = getGlobalRequestSessionCache();
+function nowMs() {
+    return Date.now();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stableStringify(value) {
+    if (value === null || value === undefined) {
+        return String(value);
+    }
+    if (typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`);
+    return `{${entries.join(',')}}`;
+}
+function jsonStringifyFallback(value) {
+    // Antigravity-Manager uses `serde_json::Value::to_string()` for the fallback seed.
+    // In JS, JSON.stringify preserves insertion order and is the closest equivalent.
+    try {
+        return JSON.stringify(value ?? null) ?? 'null';
+    }
+    catch {
+        return stableStringify(value);
+    }
+}
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function isExpired(entry, ts) {
+    return ts - entry.timestamp > SIGNATURE_TTL_MS;
+}
+function isRequestSessionExpired(entry, ts) {
+    return ts - entry.timestamp > SIGNATURE_TTL_MS;
+}
+function pruneExpired() {
+    const ts = nowMs();
+    for (const [key, entry] of sessionSignatures.entries()) {
+        if (isExpired(entry, ts)) {
+            sessionSignatures.delete(key);
+        }
+    }
+}
+function ensureCacheLimit() {
+    if (sessionSignatures.size <= SESSION_CACHE_LIMIT) {
+        return;
+    }
+    pruneExpired();
+    if (sessionSignatures.size <= SESSION_CACHE_LIMIT) {
+        return;
+    }
+    // Best-effort: remove the oldest entries until within limit.
+    const entries = Array.from(sessionSignatures.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const overflow = sessionSignatures.size - SESSION_CACHE_LIMIT;
+    for (let i = 0; i < overflow; i++) {
+        const key = entries[i]?.[0];
+        if (key) {
+            sessionSignatures.delete(key);
+        }
+    }
+}
+export function cacheAntigravityRequestSessionId(requestId, sessionId) {
+    const rid = typeof requestId === 'string' ? requestId.trim() : '';
+    const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+    if (!rid || !sid) {
+        return;
+    }
+    const ts = nowMs();
+    requestSessionIds.set(rid, { sessionId: sid, timestamp: ts });
+    if (requestSessionIds.size <= SESSION_CACHE_LIMIT) {
+        return;
+    }
+    // Best-effort cleanup to avoid unbounded growth.
+    const entries = Array.from(requestSessionIds.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const overflow = requestSessionIds.size - SESSION_CACHE_LIMIT;
+    for (let i = 0; i < overflow; i++) {
+        const key = entries[i]?.[0];
+        if (key) {
+            requestSessionIds.delete(key);
+        }
+    }
+}
+export function getAntigravityRequestSessionId(requestId) {
+    const rid = typeof requestId === 'string' ? requestId.trim() : '';
+    if (!rid) {
+        return undefined;
+    }
+    const entry = requestSessionIds.get(rid);
+    if (!entry) {
+        return undefined;
+    }
+    const ts = nowMs();
+    if (isRequestSessionExpired(entry, ts)) {
+        requestSessionIds.delete(rid);
+        return undefined;
+    }
+    return entry.sessionId;
+}
+function findGeminiContentsNode(payload) {
+    if (!isRecord(payload)) {
+        return undefined;
+    }
+    if (Array.isArray(payload.contents)) {
+        return payload;
+    }
+    const nested = payload.request;
+    if (isRecord(nested) && Array.isArray(nested.contents)) {
+        return nested;
+    }
+    const data = payload.data;
+    if (isRecord(data)) {
+        return findGeminiContentsNode(data);
+    }
+    return payload;
+}
+/**
+ * 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>"
+ * - else sha256(JSON body)
+ * - sid = "sid-" + first 16 hex chars
+ */
+export function extractAntigravityGeminiSessionId(payload) {
+    const node = findGeminiContentsNode(payload) ?? {};
+    let seed;
+    const contentsRaw = node.contents;
+    const contents = Array.isArray(contentsRaw) ? contentsRaw : [];
+    for (const content of contents) {
+        if (!isRecord(content))
+            continue;
+        if (typeof content.role !== 'string' || content.role !== 'user')
+            continue;
+        const partsRaw = content.parts;
+        const parts = Array.isArray(partsRaw) ? partsRaw : [];
+        const texts = [];
+        for (const part of parts) {
+            if (!isRecord(part))
+                continue;
+            const text = typeof part.text === 'string' ? part.text : '';
+            if (text) {
+                texts.push(text);
+            }
+        }
+        const combined = texts.join(' ').trim();
+        if (combined.length > 10 && !combined.includes('<system-reminder>')) {
+            seed = combined;
+            break;
+        }
+    }
+    if (!seed) {
+        seed = jsonStringifyFallback(node);
+    }
+    const hash = sha256Hex(seed);
+    return `sid-${hash.slice(0, 16)}`;
+}
+export function cacheAntigravitySessionSignature(sessionId, signature, messageCount = 1) {
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+        return;
+    }
+    if (typeof signature !== 'string' || signature.length < MIN_SIGNATURE_LENGTH) {
+        return;
+    }
+    const key = sessionId.trim();
+    const ts = nowMs();
+    const existing = sessionSignatures.get(key);
+    let shouldStore = false;
+    if (!existing) {
+        shouldStore = true;
+    }
+    else if (isExpired(existing, ts)) {
+        shouldStore = true;
+    }
+    else if (messageCount < existing.messageCount) {
+        // Rewind detected: allow overwrite.
+        shouldStore = true;
+    }
+    else if (messageCount === existing.messageCount) {
+        shouldStore = signature.length > existing.signature.length;
+    }
+    else {
+        shouldStore = true;
+    }
+    if (!shouldStore) {
+        return;
+    }
+    sessionSignatures.set(key, { signature, messageCount, timestamp: ts });
+    ensureCacheLimit();
+}
+export function getAntigravitySessionSignature(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+        return undefined;
+    }
+    const key = sessionId.trim();
+    const entry = sessionSignatures.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    const ts = nowMs();
+    if (isExpired(entry, ts)) {
+        sessionSignatures.delete(key);
+        return undefined;
+    }
+    return entry.signature;
+}
+export function shouldTreatAsMissingThoughtSignature(value) {
+    if (typeof value !== 'string') {
+        return true;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 || trimmed === DUMMY_THOUGHT_SIGNATURE;
+}

package/dist/conversion/compat/profiles/chat-gemini.json

@@ -29,6 +29,8 @@
     ]
   },
   "response": {
-    "mappings": []
+    "mappings": [
+      { "action": "antigravity_thought_signature_cache" }
+    ]
   }
 }

package/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper.js

@@ -108,6 +108,25 @@ function hasFunctionDeclarations(tools) {
         return Array.isArray(record.functionDeclarations) && record.functionDeclarations.length > 0;
     });
 }
+function hasNonNetworkingFunctionDeclarations(tools) {
+    if (!Array.isArray(tools))
+        return false;
+    for (const tool of tools) {
+        if (!tool || typeof tool !== 'object')
+            continue;
+        const record = tool;
+        const decls = Array.isArray(record.functionDeclarations)
+            ? record.functionDeclarations
+            : [];
+        for (const decl of decls) {
+            const name = typeof decl?.name === 'string' ? String(decl.name) : '';
+            if (name && !isNetworkingToolName(name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function injectGoogleSearchTool(request) {
     const toolsRaw = request.tools;
     if (!Array.isArray(toolsRaw)) {
@@ -137,7 +156,8 @@ function pruneSearchFunctionDeclarations(request) {
         const record = tool;
         if (!Array.isArray(record.functionDeclarations))
             continue;
-        record.functionDeclarations = record.functionDeclarations.filter((decl) => {
+        const decls = record.functionDeclarations;
+        const filtered = decls.filter((decl) => {
             if (!decl || typeof decl !== 'object')
                 return false;
             const name = typeof decl.name === 'string'
@@ -145,7 +165,18 @@ function pruneSearchFunctionDeclarations(request) {
                 : '';
             return name ? !isNetworkingToolName(name) : true;
         });
+        if (filtered.length === 0) {
+            delete record.functionDeclarations;
+        }
+        else {
+            record.functionDeclarations = filtered;
+        }
     }
+    request.tools = toolsRaw.filter((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return true;
+        return Object.keys(tool).length > 0;
+    });
 }
 function deepCleanUndefined(value) {
     if (Array.isArray(value)) {
@@ -244,9 +275,19 @@ function resolveAntigravityRequestConfig(options) {
             imageConfig: parsed.imageConfig
         };
     }
-    const enableNetworking = original.endsWith('-online') || detectsNetworkingTool(options.tools);
+    // Gemini v1internal constraint (Antigravity manager alignment):
+    // - "web_search" requests must NOT mix googleSearch with functionDeclarations.
+    // - If the request includes any non-networking function declarations (e.g. MCP/local tools),
+    //   we must disable networking and keep the request as "agent" to avoid upstream schema errors.
+    const wantsNetworking = original.endsWith('-online') || detectsNetworkingTool(options.tools);
+    const hasLocalFunctions = hasNonNetworkingFunctionDeclarations(options.tools);
+    const enableNetworking = wantsNetworking && !hasLocalFunctions;
     let finalModel = stripOnlineSuffix(mapped);
     finalModel = normalizePreviewAlias(finalModel);
+    // Only gemini-2.5-flash reliably supports googleSearch in v1internal; downgrade for networking.
+    if (enableNetworking && finalModel !== 'gemini-2.5-flash') {
+        finalModel = 'gemini-2.5-flash';
+    }
     return {
         requestType: enableNetworking ? 'web_search' : 'agent',
         injectGoogleSearch: enableNetworking,
@@ -640,7 +681,33 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const semanticsNode = readGeminiSemantics(chat);
     const systemTextBlocksFromSemantics = readSystemTextBlocksFromSemantics(chat);
     let antigravityRequestType;
+    // Gemini series alignment:
+    // - Client/tool surface uses canonical name: "web_search"
+    // - Gemini upstream receives a function tool name: "websearch" (no underscore)
+    //   then ServerTool intercepts and executes the web_search route.
+    const mapToolNameForGemini = (nameRaw) => {
+        const name = typeof nameRaw === 'string' ? nameRaw.trim() : '';
+        if (!name)
+            return undefined;
+        if (name === 'web_search' || name.startsWith('web_search_')) {
+            return 'websearch';
+        }
+        return name;
+    };
     const bridgeDefs = chat.tools && chat.tools.length ? mapChatToolsToBridge(chat.tools) : undefined;
+    if (bridgeDefs && bridgeDefs.length) {
+        for (const def of bridgeDefs) {
+            if (!def || typeof def !== 'object')
+                continue;
+            const mapped = mapToolNameForGemini(def.name);
+            if (mapped && mapped !== def.name) {
+                def.name = mapped;
+                if (def.function && typeof def.function === 'object') {
+                    def.function.name = mapped;
+                }
+            }
+        }
+    }
     const toolSchemaKeys = bridgeDefs ? buildToolSchemaKeyMap(bridgeDefs) : new Map();
     const sourceMessages = chat.messages;
     // 收集当前 ChatEnvelope 中 assistant/tool_calls 的 id，用于过滤孤立的 tool_result：
@@ -670,6 +737,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             if (allowFunctionCallingProtocol) {
                 const toolOutput = convertToolMessageToOutput(message, assistantToolCallIds);
                 if (toolOutput) {
+                    toolOutput.name = mapToolNameForGemini(toolOutput.name);
                     contents.push(buildFunctionResponseEntry(toolOutput, { includeCallId: includeToolCallIds }));
                     emittedToolOutputs.add(toolOutput.tool_call_id);
                 }
@@ -699,7 +767,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
                 continue;
             }
             const fn = tc.function || {};
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
+            const name = mapToolNameForGemini(typeof fn.name === 'string' ? fn.name : undefined);
             if (!name)
                 continue;
             let argsStruct;
@@ -726,11 +794,10 @@ function buildGeminiRequestFromChat(chat, metadata) {
             if (includeToolCallIds && typeof tc.id === 'string' && tc.id.trim().length) {
                 part.functionCall.id = String(tc.id).trim();
             }
-            // gcli2api alignment: Gemini CLI / antigravity functionCall parts always include a thoughtSignature
-            // (Cloud Code Assist expects it even when no real signature exists).
-            if (requiresThoughtSignature && !Object.prototype.hasOwnProperty.call(part, 'thoughtSignature')) {
-                part.thoughtSignature = 'skip_thought_signature_validator';
-            }
+            // Antigravity-Manager alignment:
+            // - Do NOT invent a dummy thoughtSignature in conversion.
+            // - Only inject a real thoughtSignature when the compat layer has a cached signature.
+            // This avoids sending a placeholder that may be treated as an invalid fingerprint upstream.
             entry.parts.push(part);
         }
         if (entry.parts.length) {
@@ -756,6 +823,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             if (emittedToolOutputs.has(output.tool_call_id)) {
                 continue;
             }
+            output.name = mapToolNameForGemini(output.name);
             contents.push(buildFunctionResponseEntry(output, { includeCallId: includeToolCallIds }));
             emittedToolOutputs.add(output.tool_call_id);
         }
@@ -856,7 +924,9 @@ function buildGeminiRequestFromChat(chat, metadata) {
     if (isAntigravityProvider && typeof request.model === 'string') {
         const requestPayload = request;
         const original = requestPayload.model;
-        const mapped = stripTierSuffix(original);
+        // Antigravity v1internal model IDs are tiered (e.g. gemini-3-pro-high/low) and must be preserved.
+        // Align with fetchAvailableModels: do NOT strip "-high"/"-low" suffixes for upstream requests.
+        const mapped = stripOnlineSuffix(original);
         const size = typeof chat.parameters?.size === 'string' ? String(chat.parameters.size) : undefined;
         const quality = typeof chat.parameters?.quality === 'string' ? String(chat.parameters.quality) : undefined;
         const config = resolveAntigravityRequestConfig({
@@ -941,14 +1011,9 @@ function buildGeminiRequestFromChat(chat, metadata) {
                             if (!Array.isArray(parts))
                                 continue;
                             const first = parts[0];
-                            const firstIsThinking = isJsonObject(first) &&
-                                ('thought' in first || 'thoughtSignature' in first);
-                            if (!firstIsThinking) {
-                                content.parts = [
-                                    { text: '...', thoughtSignature: 'skip_thought_signature_validator' },
-                                    ...parts
-                                ];
-                            }
+                            const firstIsThinking = isJsonObject(first) && ('thought' in first || 'thoughtSignature' in first);
+                            // Antigravity-Manager alignment: do not inject placeholder thoughtSignature blocks.
+                            // If the upstream requires a signature, it must come from cached candidate parts.
                             break;
                         }
                         gc.thinkingConfig = thinkingConfig;

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

@@ -18,6 +18,7 @@ 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 { cacheAntigravityThoughtSignatureFromGeminiResponse } from '../../../compat/actions/antigravity-thought-signature-cache.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -203,7 +204,12 @@ function applyMapping(root, mapping, state) {
             break;
         case 'gemini_cli_request_wrap':
             if (state.direction === 'request') {
-                replaceRoot(root, wrapGeminiCliRequest(root));
+                replaceRoot(root, wrapGeminiCliRequest(root, state.adapterContext));
+            }
+            break;
+        case 'antigravity_thought_signature_cache':
+            if (state.direction === 'response') {
+                replaceRoot(root, cacheAntigravityThoughtSignatureFromGeminiResponse(root, state.adapterContext));
             }
             break;
         case 'glm_image_content':

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -118,6 +118,8 @@ export type MappingInstruction = {
     action: 'claude_thinking_tool_schema';
 } | {
     action: 'gemini_cli_request_wrap';
+} | {
+    action: 'antigravity_thought_signature_cache';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/dist/conversion/hub/response/provider-response.js

@@ -261,10 +261,16 @@ export async function convertProviderResponse(options) {
     const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
     // 是否跳过 ServerTool 编排：
     // - Provider 不支持 ServerTool（没有 invoker/reenterPipeline）时跳过；
-    // - 对于 serverToolFollowup=true 的二/三跳内部请求，必须跳过：
-    //   followup 的语义是“本轮 ServerTool 已决定并发起下一跳”，下一跳响应不应再次触发 ServerTool，
-    //   否则会形成嵌套/循环（例如 stop_message_flow 反复触发）。
-    const skipServerTools = isFollowup || !hasServerToolSupport;
+    // - 对于 serverToolFollowup=true 的二/三跳内部请求，通常需要跳过以防嵌套；
+    // - 例外：stop_message_flow 允许链式触发（同一 flow 内重复检查直到 maxRepeats）。
+    const rt = readRuntimeMetadata(options.context);
+    const loopState = rt?.serverToolLoopState;
+    const flowId = loopState && typeof loopState === 'object' && !Array.isArray(loopState)
+        ? String(loopState.flowId || '').trim()
+        : '';
+    const isStopMessageFlow = flowId === 'stop_message_flow';
+    // stop_message_flow 的 followup 允许再次触发（直到 maxRepeats），其他 followup 跳过。
+    const skipServerTools = (isFollowup && !isStopMessageFlow) || !hasServerToolSupport;
     // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
     // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
     // __sse_responses 可读流。

package/dist/router/virtual-router/engine-health.d.ts

@@ -5,6 +5,7 @@ type DebugLike = {
     log?: (...args: unknown[]) => void;
 } | Console | undefined;
 export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
+export declare function applyAntigravityRiskPolicyImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
 export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
 export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
 export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;

package/dist/router/virtual-router/engine-health.js

@@ -100,6 +100,106 @@ export function resetRateLimitBackoffForProvider(providerKey) {
     }
     rateLimitBackoffByProvider.delete(providerKey);
 }
+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);
+function isAntigravityEvent(event) {
+    const runtime = event?.runtime;
+    if (!runtime || typeof runtime !== 'object') {
+        return false;
+    }
+    const providerId = typeof runtime.providerId === 'string' ? runtime.providerId.trim().toLowerCase() : '';
+    if (providerId === 'antigravity') {
+        return true;
+    }
+    const providerKey = typeof runtime.providerKey === 'string' ? runtime.providerKey.trim().toLowerCase() : '';
+    return providerKey.startsWith('antigravity.');
+}
+function shouldTriggerAntigravityRiskPolicy(event) {
+    const status = typeof event.status === 'number' ? event.status : undefined;
+    if (typeof status === 'number' && Number.isFinite(status)) {
+        // Focus on "dirty request" / auth / permission class issues. Avoid 429 which already has backoff.
+        return status >= 400 && status < 500 && status !== 429;
+    }
+    // If status is missing, fall back to known HTTP-ish error codes.
+    return typeof event.code === 'string' && /^HTTP_4\d\d$/.test(event.code.trim());
+}
+function computeAntigravityRiskSignature(event) {
+    const status = typeof event.status === 'number' && Number.isFinite(event.status) ? String(event.status) : '';
+    const code = typeof event.code === 'string' && event.code.trim() ? event.code.trim() : '';
+    const stage = typeof event.stage === 'string' && event.stage.trim() ? event.stage.trim() : '';
+    const parts = [status, code, stage].filter((p) => p.length > 0);
+    return parts.length ? parts.join(':') : 'unknown';
+}
+export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthManager, markProviderCooldown, debug) {
+    if (!event) {
+        return;
+    }
+    if (!isAntigravityEvent(event)) {
+        return;
+    }
+    if (!shouldTriggerAntigravityRiskPolicy(event)) {
+        return;
+    }
+    const signature = computeAntigravityRiskSignature(event);
+    if (!signature || signature === 'unknown') {
+        return;
+    }
+    const now = Date.now();
+    const prev = antigravityRiskBySignature.get(signature);
+    let count = 1;
+    if (prev) {
+        const elapsed = now - prev.lastAt;
+        if (Number.isFinite(elapsed) && elapsed >= 0 && elapsed < ANTIGRAVITY_RISK_RESET_WINDOW_MS) {
+            count = prev.count + 1;
+        }
+    }
+    antigravityRiskBySignature.set(signature, { 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');
+    if (providerKeys.length === 0) {
+        return;
+    }
+    if (count === 3) {
+        for (const key of providerKeys) {
+            try {
+                healthManager.tripProvider(key, 'risk_cooldown', ANTIGRAVITY_RISK_COOLDOWN_MS);
+                markProviderCooldown(key, ANTIGRAVITY_RISK_COOLDOWN_MS);
+            }
+            catch {
+                // ignore lookup failures
+            }
+        }
+        debug?.log?.('[virtual-router] antigravity risk cooldown', {
+            signature,
+            count,
+            cooldownMs: ANTIGRAVITY_RISK_COOLDOWN_MS,
+            affected: providerKeys
+        });
+    }
+    else if (count >= 4) {
+        const ttl = Math.max(ANTIGRAVITY_RISK_BAN_MS, ANTIGRAVITY_RISK_COOLDOWN_MS);
+        for (const key of providerKeys) {
+            try {
+                healthManager.tripProvider(key, 'risk_blacklist', ttl);
+                markProviderCooldown(key, ttl);
+            }
+            catch {
+                // ignore lookup failures
+            }
+        }
+        debug?.log?.('[virtual-router] antigravity risk blacklist', {
+            signature,
+            count,
+            cooldownMs: ttl,
+            affected: providerKeys
+        });
+    }
+}
 export function handleProviderFailureImpl(event, healthManager, healthConfig, markProviderCooldown) {
     if (!event || !event.providerKey) {
         return;

package/dist/router/virtual-router/engine-selection/tier-selection.js

@@ -4,6 +4,34 @@ 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 shouldAvoidAntigravityAfterRepeatedError(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;
+    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))
+        : 0;
+    return signature.length > 0 && signature !== 'unknown' && consecutive >= 2;
+}
+function preferNonAntigravityWhenPossible(candidates) {
+    if (!Array.isArray(candidates) || candidates.length < 2) {
+        return candidates;
+    }
+    const nonAntigravity = candidates.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
+    return nonAntigravity.length > 0 ? nonAntigravity : candidates;
+}
+function extractNonAntigravityTargets(targets) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return [];
+    }
+    return targets.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
+}
 export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features, deps, options) {
     const { disabledProviders, disabledKeysMap, allowedProviders, disabledModels, requiredProviderKeys } = options;
     let targets = Array.isArray(tier.targets) ? tier.targets : [];
@@ -124,19 +152,28 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
     }
     const contextResult = deps.contextAdvisor.classify(targets, estimatedTokens, (key) => deps.providerRegistry.get(key));
     const prioritizedPools = buildContextCandidatePools(contextResult);
+    const avoidAntigravityOnRetry = isRecoveryAttempt && shouldAvoidAntigravityAfterRepeatedError(features.metadata);
+    const nonAntigravityTargets = avoidAntigravityOnRetry ? extractNonAntigravityTargets(targets) : [];
+    const poolsToTry = avoidAntigravityOnRetry && nonAntigravityTargets.length > 0
+        ? [nonAntigravityTargets, ...prioritizedPools]
+        : prioritizedPools;
     const quotaView = deps.quotaView;
     const now = quotaView ? Date.now() : 0;
     const healthWeightedCfg = resolveHealthWeightedConfig(deps.loadBalancer.getPolicy().healthWeighted);
     const contextWeightedCfg = resolveContextWeightedConfig(deps.loadBalancer.getPolicy().contextWeighted);
     const warnRatio = deps.contextAdvisor.getConfig().warnRatio;
     const nowForWeights = Date.now();
-    for (const candidatePool of prioritizedPools) {
+    for (const candidatePool of poolsToTry) {
+        const isSafePool = candidatePool === contextResult.safe;
+        const candidatesForSelect = avoidAntigravityOnRetry
+            ? preferNonAntigravityWhenPossible(candidatePool)
+            : candidatePool;
         const providerKey = selectProviderKeyFromCandidatePool({
             routeName,
             tier,
             stickyKey,
-            candidates: candidatePool,
-            isSafePool: candidatePool === contextResult.safe,
+            candidates: candidatesForSelect,
+            isSafePool,
             deps,
             options,
             contextResult,

package/dist/router/virtual-router/engine.js

@@ -10,7 +10,7 @@ import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRo
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
 import { buildHitReason, formatVirtualRouterHit } from './engine-logging.js';
 import { selectDirectProviderModel, selectFromStickyPool, selectProviderImpl } from './engine-selection.js';
-import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
+import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, applyAntigravityRiskPolicyImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
 import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
 export class VirtualRouterEngine {
     routing = {};
@@ -623,6 +623,9 @@ export class VirtualRouterEngine {
                 // ignore persistence errors
             }
         }
+        // Antigravity account safety policy should apply even when quotaView is enabled.
+        // It uses router-local cooldown TTLs (not quotaView) to temporarily remove Antigravity from selection.
+        applyAntigravityRiskPolicyImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
         // 当 Host 注入 quotaView 时，VirtualRouter 的入池/优先级决策应以 quota 为准；
         // 此时不再在 engine-health 内部进行 429/backoff/series cooldown 等健康决策，
         // 以避免与 daemon/quota-center 的长期熔断策略重复维护并导致日志噪声。

package/dist/servertool/engine.js

@@ -428,8 +428,8 @@ export async function runServerToolOrchestration(options) {
     // stopMessage 是一种“状态型” servertool：一旦触发，我们需要尽量避免因 followup 失败而把状态留在可继续触发的位置，
     // 否则会出现下一轮仍然自动触发 → 再次失败 → 客户端永远 502 的死循环。
     //
-    // 因此这里对 stop_message_flow 做一次性 reservation，并在最终判定 followup 为空时清理 stopMessage 状态。
-    const stopMessageReservation = isStopMessageFlow ? reserveStopMessageUsage(options.adapterContext) : null;
+    // stop_message_flow 的计数器递增由 handler 在决定触发时处理，engine 不再提前递增。
+    const stopMessageReservation = null;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         try {
             followup = await withTimeout(options.reenterPipeline({
@@ -521,61 +521,6 @@ export async function runServerToolOrchestration(options) {
         flowId: engineResult.execution.flowId
     };
 }
-function reserveStopMessageUsage(adapterContext) {
-    if (!adapterContext || typeof adapterContext !== 'object') {
-        return null;
-    }
-    const sessionId = typeof adapterContext.sessionId === 'string'
-        ? adapterContext.sessionId.trim()
-        : '';
-    const conversationId = typeof adapterContext.conversationId === 'string'
-        ? adapterContext.conversationId.trim()
-        : '';
-    const stickyKey = sessionId ? `session:${sessionId}` : conversationId ? `conversation:${conversationId}` : '';
-    if (!stickyKey) {
-        return null;
-    }
-    let state = loadRoutingInstructionStateSync(stickyKey);
-    if (!state || !state.stopMessageText || !state.stopMessageMaxRepeats) {
-        const rt = readRuntimeMetadata(adapterContext);
-        const fallback = resolveStopMessageSnapshot(rt?.stopMessageState);
-        if (!fallback) {
-            return null;
-        }
-        state = createStopMessageState(fallback);
-    }
-    const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
-    const maxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-        ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
-        : 0;
-    if (!text || maxRepeats <= 0) {
-        return null;
-    }
-    const previousState = cloneRoutingInstructionState(state);
-    const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-        ? Math.max(0, Math.floor(state.stopMessageUsed))
-        : 0;
-    const nextUsed = used + 1;
-    state.stopMessageUsed = nextUsed;
-    const now = Date.now();
-    state.stopMessageLastUsedAt = now;
-    if (nextUsed >= maxRepeats) {
-        // Auto-clear after reaching max repeats. This avoids leaving an "exhausted" stopMessage
-        // stuck in sticky state and ensures a fresh `<**stopMessage:...**>` can re-arm cleanly.
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageSource = undefined;
-        // Keep monotonic timestamps as a tombstone to prevent accidental re-application from replayed history.
-        state.stopMessageUpdatedAt = now;
-        state.stopMessageLastUsedAt = now;
-    }
-    saveRoutingInstructionStateSync(stickyKey, state);
-    return { stickyKey, previousState };
-}
-function rollbackStopMessageUsage(reservation) {
-    saveRoutingInstructionStateSync(reservation.stickyKey, reservation.previousState);
-}
 function disableStopMessageAfterFailedFollowup(adapterContext, reservation) {
     try {
         const key = reservation && typeof reservation.stickyKey === 'string' && reservation.stickyKey.trim()

package/dist/servertool/handlers/stop-message-auto.js

@@ -148,7 +148,24 @@ const handler = async (ctx) => {
         debugLog('skip_failed_build_followup', { stickyKey });
         return null;
     }
-    const assistantMessage = extractAssistantMessageForFollowup(ctx.base);
+    // Extract assistant message for potential followup injection (no-op today; keeps compat).
+    void extractAssistantMessageForFollowup(ctx.base);
+    // Increment stopMessage usage counter when we decide to trigger followup.
+    const nextUsed = used + 1;
+    state.stopMessageUsed = nextUsed;
+    state.stopMessageLastUsedAt = Date.now();
+    // If this will be the last allowed trigger, mark it for cleanup.
+    // We still return the followup plan for this trigger, but clear the config
+    // so the next response won't trigger again.
+    if (nextUsed >= maxRepeats) {
+        const now = Date.now();
+        state.stopMessageText = undefined;
+        state.stopMessageMaxRepeats = undefined;
+        state.stopMessageUsed = undefined;
+        state.stopMessageSource = undefined;
+        state.stopMessageUpdatedAt = now;
+    }
+    saveRoutingInstructionStateAsync(stickyKey, state);
     return {
         flowId: FLOW_ID,
         finalize: async () => ({

package/package.json

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