@jsonstudio/llms 0.6.586 → 0.6.631

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

@@ -1,4 +1,5 @@
 import { Readable } from 'node:stream';
+import { isJsonObject } from '../types/json.js';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
 import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
@@ -311,7 +312,11 @@ export class HubPipeline {
         const contextNode = metadataNode && metadataNode.context && typeof metadataNode.context === 'object'
             ? metadataNode.context
             : undefined;
-        return coerceAliasMap(contextNode?.anthropicToolNameMap);
+        const fromContextNode = coerceAliasMap(contextNode?.anthropicToolNameMap);
+        if (fromContextNode) {
+            return fromContextNode;
+        }
+        return readAliasMapFromSemantics(chatEnvelope);
     }
     resolveProtocolHooks(protocol) {
         switch (protocol) {
@@ -398,6 +403,11 @@ export class HubPipeline {
         if (responsesResume) {
             adapterContext.responsesResume = responsesResume;
         }
+        // 透传 gemini_empty_reply_continue 的重试计数，便于在多次空回复后终止自动续写。
+        const emptyReplyCount = metadata.geminiEmptyReplyCount;
+        if (typeof emptyReplyCount === 'number' && Number.isFinite(emptyReplyCount)) {
+            adapterContext.geminiEmptyReplyCount = emptyReplyCount;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }
@@ -674,3 +684,13 @@ function coerceAliasMap(candidate) {
     }
     return Object.keys(normalized).length ? normalized : undefined;
 }
+function readAliasMapFromSemantics(chatEnvelope) {
+    if (!chatEnvelope?.semantics || typeof chatEnvelope.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chatEnvelope.semantics.anthropic;
+    if (!node || !isJsonObject(node)) {
+        return undefined;
+    }
+    return coerceAliasMap(node.toolAliasMap);
+}

package/dist/conversion/hub/process/chat-process.js

@@ -1,6 +1,7 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
+import { isJsonObject } from '../types/json.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -403,9 +404,15 @@ function maybeInjectWebSearchTool(request, metadata) {
     if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
         return request;
     }
-    const injectPolicy = rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
-        ? rawConfig.injectPolicy
-        : 'selective';
+    const semanticsWebSearch = extractWebSearchSemantics(request.semantics);
+    if (semanticsWebSearch?.disable === true) {
+        return request;
+    }
+    const injectPolicy = semanticsWebSearch?.force === true
+        ? 'always'
+        : rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
+            ? rawConfig.injectPolicy
+            : 'selective';
     const intent = detectWebSearchIntent(request);
     if (injectPolicy === 'selective') {
         // 仅当当前这一轮用户输入明确表达“联网搜索”意图时才注入 web_search。
@@ -512,6 +519,30 @@ function maybeInjectWebSearchTool(request, metadata) {
         tools: [...existingTools, webSearchTool]
     };
 }
+function extractWebSearchSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object') {
+        return undefined;
+    }
+    const extras = semantics.providerExtras;
+    if (!extras || !isJsonObject(extras)) {
+        return undefined;
+    }
+    const hint = extras.webSearch;
+    if (typeof hint === 'boolean') {
+        return hint ? { force: true } : { disable: true };
+    }
+    if (isJsonObject(hint)) {
+        const normalized = {};
+        if (hint.force === true) {
+            normalized.force = true;
+        }
+        if (hint.disable === true) {
+            normalized.disable = true;
+        }
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    return undefined;
+}
 function detectWebSearchIntent(request) {
     const messages = Array.isArray(request.messages) ? request.messages : [];
     if (!messages.length) {

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

@@ -21,6 +21,15 @@ function flattenAnthropicContent(content) {
     }
     return '';
 }
+function sanitizeAnthropicToolUseId(raw) {
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (trimmed && /^[A-Za-z0-9_-]+$/.test(trimmed)) {
+            return trimmed;
+        }
+    }
+    return `call_${Math.random().toString(36).slice(2, 10)}`;
+}
 function createToolNameResolver(options) {
     const reverse = new Map();
     const aliasMap = options?.aliasMap;
@@ -281,6 +290,39 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     }
     return chatResponse;
 }
+function mapShellCommandArgsForAnthropic(raw) {
+    const result = {};
+    const source = (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw : {};
+    const commandRaw = typeof source.command === 'string' && source.command.trim().length
+        ? source.command
+        : typeof source.cmd === 'string' && source.cmd.trim().length
+            ? source.cmd
+            : '';
+    const command = commandRaw.trim();
+    if (command) {
+        result.command = command;
+    }
+    const timeoutRaw = source.timeout_ms ?? source.timeout;
+    if (typeof timeoutRaw === 'number' && Number.isFinite(timeoutRaw)) {
+        result.timeout = timeoutRaw;
+    }
+    else if (typeof timeoutRaw === 'string' && timeoutRaw.trim().length) {
+        const parsed = Number(timeoutRaw.trim());
+        if (Number.isFinite(parsed)) {
+            result.timeout = parsed;
+        }
+    }
+    if (typeof source.description === 'string' && source.description.trim().length) {
+        result.description = source.description;
+    }
+    if (typeof source.run_in_background === 'boolean') {
+        result.run_in_background = source.run_in_background;
+    }
+    if (typeof source.dangerouslyDisableSandbox === 'boolean') {
+        result.dangerouslyDisableSandbox = source.dangerouslyDisableSandbox;
+    }
+    return result;
+}
 export function buildAnthropicResponseFromChat(chatResponse, options) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
@@ -327,6 +369,7 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         const fn = call.function || {};
         if (typeof fn?.name !== 'string')
             continue;
+        const canonicalName = normalizeAnthropicToolName(fn.name) ?? fn.name;
         const serializedName = outboundAliasSerializer(fn.name);
         let parsedArgs = {};
         const args = fn.arguments;
@@ -341,9 +384,12 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         else {
             parsedArgs = args ?? {};
         }
+        if ((canonicalName || '').trim() === 'shell_command') {
+            parsedArgs = mapShellCommandArgsForAnthropic(parsedArgs);
+        }
         contentBlocks.push({
             type: 'tool_use',
-            id: typeof call.id === 'string' ? call.id : `call_${Math.random().toString(36).slice(2, 8)}`,
+            id: sanitizeAnthropicToolUseId(call.id),
             name: serializedName,
             input: parsedArgs
         });

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.js

@@ -34,6 +34,43 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
 ]);
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+function ensureSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    return chat.semantics;
+}
+function ensureAnthropicSemanticsNode(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.anthropic || !isJsonObject(semantics.anthropic)) {
+        semantics.anthropic = {};
+    }
+    return semantics.anthropic;
+}
+function markExplicitEmptyTools(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.tools || !isJsonObject(semantics.tools)) {
+        semantics.tools = {};
+    }
+    semantics.tools.explicitEmpty = true;
+}
+function readAnthropicSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.anthropic;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function hasExplicitEmptyToolsSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return false;
+    }
+    const toolsNode = chat.semantics.tools;
+    if (!toolsNode || !isJsonObject(toolsNode)) {
+        return false;
+    }
+    return Boolean(toolsNode.explicitEmpty);
+}
 function sanitizeAnthropicPayload(payload) {
     for (const key of Object.keys(payload)) {
         if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
@@ -91,6 +128,7 @@ export class AnthropicSemanticMapper {
         const metadata = chatEnvelope.metadata ?? { context: canonicalContext };
         chatEnvelope.metadata = metadata;
         metadata.context = canonicalContext;
+        let semanticsNode;
         const resolveExtraFields = () => {
             if (!isJsonObject(metadata.extraFields)) {
                 metadata.extraFields = {};
@@ -101,10 +139,13 @@ export class AnthropicSemanticMapper {
         const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
         if (systemBlocks) {
             protocolState.systemBlocks = systemBlocks;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.systemBlocks = jsonClone(systemBlocks);
         }
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
             metadata.toolsFieldPresent = true;
             resolveExtraFields().toolsFieldPresent = true;
+            markExplicitEmptyTools(chatEnvelope);
         }
         const aliasMap = buildAnthropicToolAliasMap(payload.tools);
         if (aliasMap) {
@@ -113,6 +154,8 @@ export class AnthropicSemanticMapper {
             canonicalContext.anthropicToolNameMap = aliasMap;
             metadata.anthropicToolNameMap = aliasMap;
             extraFields.anthropicToolNameMap = aliasMap;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.toolAliasMap = jsonClone(aliasMap);
         }
         if (Array.isArray(payload.messages) && payload.messages.length) {
             const shapes = payload.messages.map((entry) => {
@@ -137,6 +180,8 @@ export class AnthropicSemanticMapper {
                 : {};
             mirrorNode.messageContentShape = shapes;
             extraFields.anthropicMirror = mirrorNode;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.mirror = jsonClone(mirrorNode);
         }
         if (missing.length) {
             metadata.missingFields = Array.isArray(metadata.missingFields)
@@ -147,6 +192,8 @@ export class AnthropicSemanticMapper {
             (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
         if (providerMetadata) {
             metadata.providerMetadata = providerMetadata;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.providerMetadata = jsonClone(providerMetadata);
         }
         const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
         const mergeParameters = (source) => {
@@ -217,6 +264,8 @@ export class AnthropicSemanticMapper {
             messages: chat.messages,
             tools: chat.tools
         };
+        const semanticsNode = readAnthropicSemantics(chat);
+        const explicitEmptyTools = (chat.metadata?.toolsFieldPresent === true) || hasExplicitEmptyToolsSemantics(chat);
         const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
         if (trimmedParameters) {
             for (const [key, value] of Object.entries(trimmedParameters)) {
@@ -245,16 +294,19 @@ export class AnthropicSemanticMapper {
         if (baseRequest.max_output_tokens && !baseRequest.max_tokens) {
             baseRequest.max_tokens = baseRequest.max_output_tokens;
         }
-        if (isJsonObject(chat.metadata?.providerMetadata)) {
-            baseRequest.metadata = jsonClone(chat.metadata?.providerMetadata);
-        }
-        if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
+        // 出站阶段不再直接透传其它协议的 providerMetadata，避免跨协议打洞；
+        // Anthropic 自身入口的 metadata 已在入站阶段通过 collectParameters/encodeMetadataPassthrough
+        // 按白名单收集，这里仅依赖这些显式映射结果。
+        if (explicitEmptyTools && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
             baseRequest.tools = [];
         }
         const protocolState = getProtocolState(chat.metadata, 'anthropic');
         if (protocolState?.systemBlocks !== undefined) {
             baseRequest.system = jsonClone(protocolState.systemBlocks);
         }
+        else if (semanticsNode?.systemBlocks !== undefined) {
+            baseRequest.system = jsonClone(semanticsNode.systemBlocks);
+        }
         if (chat.metadata &&
             typeof chat.metadata === 'object' &&
             chat.metadata.extraFields &&
@@ -262,6 +314,9 @@ export class AnthropicSemanticMapper {
             chat.metadata.extraFields.anthropicMirror) {
             baseRequest.__anthropicMirror = jsonClone(chat.metadata.extraFields.anthropicMirror ?? {});
         }
+        else if (semanticsNode?.mirror && isJsonObject(semanticsNode.mirror)) {
+            baseRequest.__anthropicMirror = jsonClone(semanticsNode.mirror);
+        }
         const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
         const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
         if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {

package/dist/conversion/hub/semantic-mappers/chat-mapper.d.ts

@@ -0,0 +1,8 @@
+import type { SemanticMapper } from '../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+export declare function maybeAugmentApplyPatchErrorContent(content: string, toolName?: string): string;
+export declare class ChatSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}

package/dist/conversion/hub/semantic-mappers/chat-mapper.js

@@ -59,6 +59,22 @@ function normalizeToolContent(content) {
         return String(content ?? '');
     }
 }
+export function maybeAugmentApplyPatchErrorContent(content, toolName) {
+    if (!content)
+        return content;
+    const lower = content.toLowerCase();
+    const isApplyPatch = (typeof toolName === 'string' && toolName.trim() === 'apply_patch') ||
+        lower.includes('apply_patch verification failed');
+    if (!isApplyPatch) {
+        return content;
+    }
+    // 避免重复追加提示。
+    if (content.includes('[apply_patch hint]')) {
+        return content;
+    }
+    const hint = '\n\n[apply_patch hint] 在使用 apply_patch 之前，请先读取目标文件的最新内容，并基于该内容生成补丁；同时确保补丁格式符合工具规范（统一补丁格式或结构化参数），避免上下文不匹配或语法错误。';
+    return content + hint;
+}
 function recordToolCallIssues(message, messageIndex, missing) {
     const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
     if (!toolCalls?.length)
@@ -158,11 +174,13 @@ function normalizeChatMessages(raw) {
                 norm.missingFields.push({ path: `messages[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
                 return;
             }
+            const nameValue = typeof value.name === 'string' && value.name.trim().length ? value.name : undefined;
             const outputEntry = {
                 tool_call_id: toolCallId,
                 content: normalizeToolContent(value.content ?? value.output),
-                name: typeof value.name === 'string' && value.name.trim().length ? value.name : undefined
+                name: nameValue
             };
+            outputEntry.content = maybeAugmentApplyPatchErrorContent(outputEntry.content, outputEntry.name);
             norm.toolOutputs.push(outputEntry);
         }
     });
@@ -183,10 +201,13 @@ function normalizeStandaloneToolOutputs(raw, missing) {
             missing.push({ path: `tool_outputs[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
             return;
         }
+        const nameValue = typeof entry.name === 'string' && entry.name.trim().length ? entry.name : undefined;
+        const rawContent = normalizeToolContent(entry.content ?? entry.output);
+        const content = maybeAugmentApplyPatchErrorContent(rawContent, nameValue);
         outputs.push({
             tool_call_id: toolCallId,
-            content: normalizeToolContent(entry.content ?? entry.output),
-            name: typeof entry.name === 'string' && entry.name.trim().length ? entry.name : undefined
+            content,
+            name: nameValue
         });
     });
     return outputs;
@@ -225,15 +246,67 @@ function collectExtraFields(body) {
     }
     return Object.keys(extras).length ? extras : undefined;
 }
-function applyExtraFields(body, metadata) {
-    if (!metadata || !metadata.extraFields || !isJsonObject(metadata.extraFields)) {
+function extractOpenAIExtraFieldsFromSemantics(semantics) {
+    if (!semantics || !semantics.providerExtras || !isJsonObject(semantics.providerExtras)) {
+        return undefined;
+    }
+    const openaiExtras = semantics.providerExtras.openaiChat;
+    if (!openaiExtras || !isJsonObject(openaiExtras)) {
+        return undefined;
+    }
+    const stored = openaiExtras.extraFields;
+    if (!stored || !isJsonObject(stored)) {
+        return undefined;
+    }
+    return stored;
+}
+function hasExplicitEmptyToolsSemantics(semantics) {
+    if (!semantics || !semantics.tools || !isJsonObject(semantics.tools)) {
+        return false;
+    }
+    const flag = semantics.tools.explicitEmpty;
+    return flag === true;
+}
+function buildOpenAISemantics(options) {
+    const semantics = {};
+    if (options.systemSegments && options.systemSegments.length) {
+        semantics.system = {
+            textBlocks: options.systemSegments.map((segment) => segment)
+        };
+    }
+    if (options.extraFields && Object.keys(options.extraFields).length) {
+        semantics.providerExtras = {
+            openaiChat: {
+                extraFields: jsonClone(options.extraFields)
+            }
+        };
+    }
+    if (options.explicitEmptyTools) {
+        semantics.tools = {
+            explicitEmpty: true
+        };
+    }
+    return Object.keys(semantics).length ? semantics : undefined;
+}
+function applyExtraFields(body, metadata, semantics) {
+    const sources = [];
+    const semanticsExtras = extractOpenAIExtraFieldsFromSemantics(semantics);
+    if (semanticsExtras) {
+        sources.push(semanticsExtras);
+    }
+    if (metadata?.extraFields && isJsonObject(metadata.extraFields)) {
+        sources.push(metadata.extraFields);
+    }
+    if (!sources.length) {
         return;
     }
-    for (const [key, value] of Object.entries(metadata.extraFields)) {
-        if (body[key] !== undefined) {
-            continue;
+    for (const source of sources) {
+        for (const [key, value] of Object.entries(source)) {
+            if (body[key] !== undefined) {
+                continue;
+            }
+            body[key] = jsonClone(value);
         }
-        body[key] = jsonClone(value);
     }
 }
 export class ChatSemanticMapper {
@@ -285,24 +358,32 @@ export class ChatSemanticMapper {
         catch {
             // noop: best-effort policy application
         }
-        if (Array.isArray(payload.tools) && payload.tools.length === 0) {
+        const explicitEmptyTools = Array.isArray(payload.tools) && payload.tools.length === 0;
+        if (explicitEmptyTools) {
             metadata.toolsFieldPresent = true;
         }
+        const semantics = buildOpenAISemantics({
+            systemSegments: normalized.systemSegments,
+            extraFields,
+            explicitEmptyTools
+        });
         return {
             messages: normalized.messages,
             tools: normalizeTools(payload.tools, normalized.missingFields),
             toolOutputs: toolOutputs.length ? toolOutputs : undefined,
             parameters: extractParameters(payload),
+            semantics,
             metadata
         };
     }
     async fromChat(chat, ctx) {
+        const shouldEmitEmptyTools = hasExplicitEmptyToolsSemantics(chat.semantics) || chat.metadata?.toolsFieldPresent === true;
         const payload = {
             messages: chat.messages,
-            tools: chat.tools ?? (chat.metadata?.toolsFieldPresent ? [] : undefined),
+            tools: chat.tools ?? (shouldEmitEmptyTools ? [] : undefined),
             ...(chat.parameters || {})
         };
-        applyExtraFields(payload, chat.metadata);
+        applyExtraFields(payload, chat.metadata, chat.semantics);
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-chat' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');

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

@@ -25,6 +25,67 @@ function coerceThoughtSignature(value) {
     }
     return undefined;
 }
+function ensureGeminiSemanticsNode(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    if (!chat.semantics.gemini || !isJsonObject(chat.semantics.gemini)) {
+        chat.semantics.gemini = {};
+    }
+    return chat.semantics.gemini;
+}
+function ensureSystemSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    if (!chat.semantics.system || !isJsonObject(chat.semantics.system)) {
+        chat.semantics.system = {};
+    }
+    return chat.semantics.system;
+}
+function markGeminiExplicitEmptyTools(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    if (!chat.semantics.tools || !isJsonObject(chat.semantics.tools)) {
+        chat.semantics.tools = {};
+    }
+    chat.semantics.tools.explicitEmpty = true;
+}
+function readGeminiSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.gemini;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function hasExplicitEmptyToolsSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return false;
+    }
+    const toolsNode = chat.semantics.tools;
+    if (!toolsNode || !isJsonObject(toolsNode)) {
+        return false;
+    }
+    return Boolean(toolsNode.explicitEmpty);
+}
+function readSystemTextBlocksFromSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const systemNode = chat.semantics.system;
+    if (!systemNode || !isJsonObject(systemNode)) {
+        return undefined;
+    }
+    const rawBlocks = systemNode.textBlocks;
+    if (!Array.isArray(rawBlocks)) {
+        return undefined;
+    }
+    const normalized = rawBlocks
+        .map((entry) => (typeof entry === 'string' ? entry : undefined))
+        .filter((value) => typeof value === 'string' && value.trim().length > 0);
+    return normalized.length ? normalized : undefined;
+}
 function extractThoughtSignatureFromToolCall(tc) {
     if (!tc || typeof tc !== 'object') {
         return undefined;
@@ -104,18 +165,42 @@ function normalizeToolContent(value) {
         return String(value ?? '');
     }
 }
-function convertToolMessageToOutput(message) {
+function convertToolMessageToOutput(message, allowedIds) {
     const rawId = (message.tool_call_id ?? message.id);
     const callId = typeof rawId === 'string' && rawId.trim().length ? rawId.trim() : undefined;
     if (!callId) {
         return null;
     }
+    if (allowedIds && !allowedIds.has(callId)) {
+        return null;
+    }
     return {
         tool_call_id: callId,
         content: normalizeToolContent(message.content),
         name: typeof message.name === 'string' ? message.name : undefined
     };
 }
+function selectAntigravityClaudeThinkingMessages(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages ?? [];
+    }
+    // 为了与 Responses 入口对齐，Claude-thinking 在发往 Antigravity 时仅保留
+    // 当前这一轮的 user 消息，丢弃历史 model/assistant 片段（例如错误日志中的「{」）。
+    let lastUserIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object')
+            continue;
+        if (msg.role === 'user') {
+            lastUserIndex = i;
+            break;
+        }
+    }
+    if (lastUserIndex === -1) {
+        return messages;
+    }
+    return [messages[lastUserIndex]];
+}
 function buildFunctionResponseEntry(output) {
     const parsedPayload = safeParseJson(output.content);
     const normalizedPayload = ensureFunctionResponsePayload(cloneAsJsonValue(parsedPayload));
@@ -288,19 +373,46 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const emittedToolOutputs = new Set();
     const adapterContext = metadata?.context;
     const rawProviderId = adapterContext?.providerId;
+    const entryEndpointRaw = adapterContext?.entryEndpoint;
+    const entryEndpoint = typeof entryEndpointRaw === 'string' ? entryEndpointRaw.trim().toLowerCase() : '';
+    const isAnthropicEntry = entryEndpoint === '/v1/messages';
     const normalizedProviderId = typeof rawProviderId === 'string' ? rawProviderId.toLowerCase() : '';
     const providerIdPrefix = normalizedProviderId.split('.')[0];
+    const isAntigravityClaudeThinking = providerIdPrefix === 'antigravity' &&
+        typeof chat.parameters?.model === 'string' &&
+        chat.parameters.model.includes('claude-sonnet-4-5-thinking');
     // 保持对通用 gemini-cli 的保护（避免上游直接执行 functionCall），
     // 但对于 antigravity.* 明确允许通过 Gemini functionCall 协议执行工具，
     // 以便完整打通 tools → functionCall → functionResponse 链路。
     const omitFunctionCallPartsForCli = providerIdPrefix === 'gemini-cli';
-    for (const message of chat.messages) {
+    const semanticsNode = readGeminiSemantics(chat);
+    const systemTextBlocksFromSemantics = readSystemTextBlocksFromSemantics(chat);
+    const sourceMessages = chat.messages;
+    // 收集当前 ChatEnvelope 中 assistant/tool_calls 的 id，用于过滤孤立的 tool_result：
+    // 只有在本轮对话中存在对应 tool_call 的 tool_result 才允许映射为 Gemini functionResponse。
+    const assistantToolCallIds = new Set();
+    for (const msg of sourceMessages) {
+        if (!msg || typeof msg !== 'object')
+            continue;
+        if (msg.role !== 'assistant')
+            continue;
+        const tcs = Array.isArray(msg.tool_calls)
+            ? msg.tool_calls
+            : [];
+        for (const tc of tcs) {
+            const id = typeof tc.id === 'string' ? tc.id.trim() : '';
+            if (id) {
+                assistantToolCallIds.add(id);
+            }
+        }
+    }
+    for (const message of sourceMessages) {
         if (!message || typeof message !== 'object')
             continue;
         if (message.role === 'system')
             continue;
         if (message.role === 'tool') {
-            const toolOutput = convertToolMessageToOutput(message);
+            const toolOutput = convertToolMessageToOutput(message, assistantToolCallIds);
             if (toolOutput) {
                 contents.push(buildFunctionResponseEntry(toolOutput));
                 emittedToolOutputs.add(toolOutput.tool_call_id);
@@ -384,15 +496,21 @@ function buildGeminiRequestFromChat(chat, metadata) {
         contents
     };
     const geminiState = getProtocolState(metadata, 'gemini');
-    if (geminiState?.systemInstruction !== undefined) {
+    if (semanticsNode?.systemInstruction !== undefined) {
+        request.systemInstruction = jsonClone(semanticsNode.systemInstruction);
+    }
+    else if (geminiState?.systemInstruction !== undefined) {
         request.systemInstruction = jsonClone(geminiState.systemInstruction);
     }
-    else if (metadata?.systemInstructions && Array.isArray(metadata.systemInstructions)) {
-        const sysBlocks = metadata.systemInstructions
-            .filter((value) => typeof value === 'string' && value.trim().length > 0)
-            .map((value) => ({ text: value }));
-        if (sysBlocks.length) {
-            request.systemInstruction = { role: 'system', parts: sysBlocks };
+    else {
+        const fallbackSystemInstructions = systemTextBlocksFromSemantics;
+        if (fallbackSystemInstructions && fallbackSystemInstructions.length) {
+            const sysBlocks = fallbackSystemInstructions
+                .filter((value) => typeof value === 'string' && value.trim().length > 0)
+                .map((value) => ({ text: value }));
+            if (sysBlocks.length) {
+                request.systemInstruction = { role: 'system', parts: sysBlocks };
+            }
         }
     }
     if (chat.tools && chat.tools.length) {
@@ -403,17 +521,43 @@ function buildGeminiRequestFromChat(chat, metadata) {
         }
     }
     const generationConfig = buildGenerationConfigFromParameters(chat.parameters || {});
+    if (semanticsNode?.generationConfig && isJsonObject(semanticsNode.generationConfig)) {
+        for (const [key, value] of Object.entries(semanticsNode.generationConfig)) {
+            if (generationConfig[key] !== undefined) {
+                continue;
+            }
+            generationConfig[key] = jsonClone(value);
+        }
+    }
     if (Object.keys(generationConfig).length) {
         request.generationConfig = generationConfig;
     }
-    if (metadata?.providerMetadata && isJsonObject(metadata.providerMetadata)) {
-        request.metadata = jsonClone(metadata.providerMetadata);
+    if (semanticsNode?.safetySettings !== undefined) {
+        request.safetySettings = jsonClone(semanticsNode.safetySettings);
+    }
+    if (chat.parameters?.tool_config && isJsonObject(chat.parameters.tool_config)) {
+        request.toolConfig = jsonClone(chat.parameters.tool_config);
+    }
+    else if (semanticsNode?.toolConfig && isJsonObject(semanticsNode.toolConfig)) {
+        request.toolConfig = jsonClone(semanticsNode.toolConfig);
+    }
+    // 为了保持协议解耦，只在 Gemini 自身或开放式 Chat 入口下透传 providerMetadata；
+    // 对于 Anthropic (/v1/messages) 等其它协议的入口，不再将其 metadata 整块转发给 Gemini，
+    // 避免跨协议泄漏上游专有字段。
+    if (!isAnthropicEntry) {
+        if (semanticsNode?.providerMetadata && isJsonObject(semanticsNode.providerMetadata)) {
+            request.metadata = jsonClone(semanticsNode.providerMetadata);
+        }
+        else if (metadata?.providerMetadata && isJsonObject(metadata.providerMetadata)) {
+            request.metadata = jsonClone(metadata.providerMetadata);
+        }
     }
     if (chat.parameters && chat.parameters.stream !== undefined) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_stream = chat.parameters.stream;
     }
-    if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
+    if ((chat.metadata?.toolsFieldPresent || hasExplicitEmptyToolsSemantics(chat)) &&
+        (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_tools_field_present = '1';
     }
@@ -427,8 +571,9 @@ function buildGeminiRequestFromChat(chat, metadata) {
             request.metadata[key] = value;
         }
     }
-    // Apply claude-thinking compat directly at Gemini mapping time to ensure it is always active
-    // for antigravity.*.claude-sonnet-4-5-thinking, regardless of compatibilityProfile wiring.
+    // Apply claude-thinking compat at Gemini mapping time to ensure it is always active
+    // for Claude models, regardless of compatibilityProfile wiring. Provider层负责进一步的
+    // 传输层收紧（如 session_id / generationConfig），这里不做非标裁剪。
     const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
     return compatRequest;
 }
@@ -514,16 +659,10 @@ export class GeminiSemanticMapper {
         let parameters = collectParameters(payload);
         const metadata = { context: ctx };
         const systemSegments = collectSystemSegments(payload.systemInstruction);
-        if (systemSegments.length) {
-            metadata.systemInstructions = systemSegments;
-        }
         if (payload.systemInstruction !== undefined) {
             const rawSystem = jsonClone(payload.systemInstruction);
             ensureProtocolState(metadata, 'gemini').systemInstruction = rawSystem;
         }
-        if (payload.safetySettings) {
-            metadata.safetySettings = jsonClone(payload.safetySettings);
-        }
         if (missing.length) {
             metadata.missingFields = missing;
         }
@@ -559,32 +698,64 @@ export class GeminiSemanticMapper {
             parameters = { ...(parameters || {}), ...passthrough.passthrough };
         }
         const providerMetadataSource = passthrough.metadata ?? payload.metadata;
+        let providerMetadata;
+        let explicitEmptyTools = Array.isArray(payload.tools) && payload.tools.length === 0;
         if (providerMetadataSource) {
-            const providerMetadata = jsonClone(providerMetadataSource);
+            const cloned = jsonClone(providerMetadataSource);
             let toolsFieldPresent = false;
-            if (isJsonObject(providerMetadata)) {
-                delete providerMetadata.__rcc_stream;
-                if (Object.prototype.hasOwnProperty.call(providerMetadata, '__rcc_tools_field_present')) {
-                    const sentinel = providerMetadata.__rcc_tools_field_present;
+            if (isJsonObject(cloned)) {
+                delete cloned.__rcc_stream;
+                if (Object.prototype.hasOwnProperty.call(cloned, '__rcc_tools_field_present')) {
+                    const sentinel = cloned.__rcc_tools_field_present;
                     toolsFieldPresent = sentinel === '1' || sentinel === true;
-                    delete providerMetadata.__rcc_tools_field_present;
+                    delete cloned.__rcc_tools_field_present;
                 }
-                if (Object.prototype.hasOwnProperty.call(providerMetadata, '__rcc_raw_system')) {
-                    delete providerMetadata.__rcc_raw_system;
+                if (Object.prototype.hasOwnProperty.call(cloned, '__rcc_raw_system')) {
+                    delete cloned.__rcc_raw_system;
                 }
             }
             if (toolsFieldPresent) {
                 metadata.toolsFieldPresent = true;
+                explicitEmptyTools = true;
             }
+            providerMetadata = cloned;
             metadata.providerMetadata = providerMetadata;
         }
-        return {
+        const chatEnvelope = {
             messages,
             tools,
             toolOutputs,
             parameters,
             metadata
         };
+        if (systemSegments.length) {
+            const systemNode = ensureSystemSemantics(chatEnvelope);
+            systemNode.textBlocks = systemSegments.map((segment) => segment);
+        }
+        let semanticsNode;
+        const ensureSemanticsNode = () => {
+            semanticsNode = semanticsNode ?? ensureGeminiSemanticsNode(chatEnvelope);
+            return semanticsNode;
+        };
+        if (payload.systemInstruction !== undefined) {
+            ensureSemanticsNode().systemInstruction = jsonClone(payload.systemInstruction);
+        }
+        if (payload.safetySettings) {
+            ensureSemanticsNode().safetySettings = jsonClone(payload.safetySettings);
+        }
+        if (payload.generationConfig && isJsonObject(payload.generationConfig)) {
+            ensureSemanticsNode().generationConfig = jsonClone(payload.generationConfig);
+        }
+        if (payload.toolConfig && isJsonObject(payload.toolConfig)) {
+            ensureSemanticsNode().toolConfig = jsonClone(payload.toolConfig);
+        }
+        if (providerMetadata) {
+            ensureSemanticsNode().providerMetadata = jsonClone(providerMetadata);
+        }
+        if (explicitEmptyTools) {
+            markGeminiExplicitEmptyTools(chatEnvelope);
+        }
+        return chatEnvelope;
     }
     async fromChat(chat, ctx) {
         try {

package/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -2,6 +2,7 @@ import { isJsonObject, jsonClone } from '../types/json.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../responses/responses-openai-bridge.js';
+import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
 const RESPONSES_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -46,10 +47,12 @@ function mapToolOutputs(entries, missing) {
                 content = String(entry.output);
             }
         }
+        const nameValue = typeof entry.name === 'string' ? entry.name : undefined;
+        const augmented = maybeAugmentApplyPatchErrorContent(content, nameValue);
         outputs.push({
             tool_call_id: String(callId),
-            content,
-            name: typeof entry.name === 'string' ? entry.name : undefined
+            content: augmented,
+            name: nameValue
         });
     });
     return outputs.length ? outputs : undefined;
@@ -205,6 +208,67 @@ function isSubmitToolOutputsEndpoint(ctx) {
     const entry = typeof ctx.entryEndpoint === 'string' ? ctx.entryEndpoint.trim().toLowerCase() : '';
     return entry === RESPONSES_SUBMIT_ENDPOINT;
 }
+function attachResponsesSemantics(existing, context, resume) {
+    if (!context && !resume) {
+        return existing;
+    }
+    const next = existing ? { ...existing } : {};
+    const currentNode = next.responses && isJsonObject(next.responses) ? { ...next.responses } : {};
+    if (context) {
+        currentNode.context = jsonClone(context);
+    }
+    if (resume) {
+        currentNode.resume = jsonClone(resume);
+    }
+    next.responses = currentNode;
+    return next;
+}
+function extractResponsesSemanticsNode(chat) {
+    if (!chat?.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.responses;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function readResponsesContextFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const contextNode = node.context;
+    if (!contextNode || !isJsonObject(contextNode)) {
+        return undefined;
+    }
+    return jsonClone(contextNode);
+}
+function readResponsesResumeFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const resumeNode = node.resume;
+    if (!resumeNode || !isJsonObject(resumeNode)) {
+        return undefined;
+    }
+    return jsonClone(resumeNode);
+}
+function selectResponsesContextSnapshot(chat, envelopeMetadata) {
+    const semanticsContext = readResponsesContextFromSemantics(chat);
+    const metadataContextCandidate = chat.metadata?.responsesContext;
+    const metadataContext = metadataContextCandidate && isJsonObject(metadataContextCandidate)
+        ? jsonClone(metadataContextCandidate)
+        : undefined;
+    const context = semanticsContext ??
+        metadataContext ??
+        {
+            metadata: envelopeMetadata
+        };
+    const mergedMetadata = mergeMetadata(context.metadata ?? undefined, envelopeMetadata);
+    if (mergedMetadata) {
+        context.metadata = mergedMetadata;
+    }
+    return context;
+}
 function resolveSubmitResponseId(ctx, responsesContext) {
     const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
         ? ctx.responsesResume
@@ -441,25 +505,23 @@ export class ResponsesSemanticMapper {
         if (responsesContext.responseFormat) {
             metadata.responseFormat = jsonClone(responsesContext.responseFormat);
         }
+        metadata.responsesContext = jsonClone(responsesContext);
+        const resumeNode = ctx.responsesResume && isJsonObject(ctx.responsesResume)
+            ? ctx.responsesResume
+            : undefined;
+        const semantics = attachResponsesSemantics(undefined, responsesContext, resumeNode);
         return {
             messages,
             tools: normalizeTools(toolsNormalized, missingFields),
             toolOutputs,
             parameters,
+            semantics,
             metadata
         };
     }
     async fromChat(chat, ctx) {
-        const capturedContext = chat.metadata?.responsesContext;
         const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
-        const responsesContext = isJsonObject(capturedContext)
-            ? {
-                ...capturedContext,
-                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata)
-            }
-            : {
-                metadata: envelopeMetadata
-            };
+        const responsesContext = selectResponsesContextSnapshot(chat, envelopeMetadata);
         if (isSubmitToolOutputsEndpoint(ctx)) {
             const submitPayload = buildSubmitToolOutputsPayload(chat, ctx, responsesContext);
             return {

package/dist/conversion/hub/standardized-bridge.js

@@ -5,6 +5,7 @@ export function chatEnvelopeToStandardized(chat, options) {
     const model = extractModel(parameters);
     const messages = chat.messages.map((message) => normalizeChatMessage(message));
     const tools = normalizeTools(chat.tools);
+    const semantics = cloneSemantics(chat.semantics);
     const metadataCaptured = {};
     const hubState = {};
     if (Array.isArray(chat.metadata?.missingFields) && chat.metadata?.missingFields.length) {
@@ -35,7 +36,8 @@ export function chatEnvelopeToStandardized(chat, options) {
             capturedContext: metadataCaptured,
             requestId: options.requestId,
             stream: parameters.stream === true
-        }
+        },
+        semantics
     };
     return standardized;
 }
@@ -93,7 +95,8 @@ export function standardizedToChatEnvelope(request, options) {
         messages,
         tools,
         parameters,
-        metadata
+        metadata,
+        semantics: cloneSemantics(request.semantics)
     };
 }
 function extractModel(parameters) {
@@ -103,6 +106,12 @@ function extractModel(parameters) {
     }
     throw new Error('ChatEnvelope parameters must include model string');
 }
+function cloneSemantics(value) {
+    if (!value) {
+        return value;
+    }
+    return jsonClone(value);
+}
 function normalizeChatMessage(message) {
     const normalized = {
         role: message.role,

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -56,11 +56,21 @@ export interface AdapterContext {
     responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }
+export interface ChatSemantics extends JsonObject {
+    session?: JsonObject;
+    system?: JsonObject;
+    tools?: JsonObject;
+    responses?: JsonObject;
+    anthropic?: JsonObject;
+    gemini?: JsonObject;
+    providerExtras?: JsonObject;
+}
 export interface ChatEnvelope {
     messages: ChatMessage[];
     tools?: ChatToolDefinition[];
     toolOutputs?: ChatToolOutput[];
     parameters?: JsonObject;
+    semantics?: ChatSemantics;
     metadata: {
         context: AdapterContext;
         missingFields?: MissingField[];

package/dist/conversion/hub/types/standardized.d.ts

@@ -1,4 +1,4 @@
-import type { ChatMessageContentPart } from './chat-envelope.js';
+import type { ChatMessageContentPart, ChatSemantics } from './chat-envelope.js';
 import type { JsonObject } from './json.js';
 export type ToolChoice = 'none' | 'auto' | 'required' | {
     type: 'function';
@@ -74,6 +74,7 @@ export interface StandardizedRequest {
     tools?: StandardizedTool[];
     parameters: StandardizedParameters;
     metadata: StandardizedMetadata;
+    semantics?: ChatSemantics;
 }
 export interface ProcessedRequest extends StandardizedRequest {
     processed: {

package/dist/conversion/shared/gemini-tool-utils.js

@@ -13,11 +13,11 @@ function cloneParameters(value) {
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
             // Gemini function_declarations.parameters only support a subset of JSON Schema.
-            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum.
+            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum/propertyNames.
             if (typeof key === 'string') {
                 if (key.startsWith('$'))
                     continue;
-                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum')
+                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum' || key === 'propertyNames')
                     continue;
             }
             cloned[key] = cloneParameters(entry);

package/dist/conversion/shared/text-markup-normalizer.js

@@ -262,9 +262,16 @@ export function extractXMLToolCallsFromText(text) {
                         name = cand;
                 }
                 catch { /* ignore */ }
+                // 如果前一行抽不到合法函数名，但 arg_key 明显是 toon/command，
+                // 视为 CLI 通路下的 exec_command 工具，避免把半截 <tool_call> 当成纯文本丢弃。
+                const rawKey = (pm[1] || '').trim();
+                const normalizedKey = normalizeKey(rawKey).toLowerCase();
+                if (!name && (normalizedKey === 'toon' || normalizedKey === 'command')) {
+                    name = 'exec_command';
+                }
                 if (!name)
                     continue;
-                const k = normalizeKey((pm[1] || '').trim());
+                const k = normalizeKey(rawKey);
                 let vRaw = (pm[2] || '').trim();
                 const argsObj = {};
                 if (k) {

package/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -1,4 +1,4 @@
-import { ToolFilterHints } from '../../filters/index.js';
+import type { ToolFilterHints } from '../../filters/index.js';
 interface RequestFilterOptions {
     entryEndpoint?: string;
     requestId?: string;

package/dist/filters/index.d.ts

@@ -1,3 +1,4 @@
+export type { ToolFilterHints, ToolFilterDecision, ToolFilterAction } from './types.js';
 export * from './types.js';
 export * from './engine.js';
 export * from './builtin/whitelist-filter.js';

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

@@ -133,10 +133,11 @@ export class VirtualRouterEngine {
         // 自动 sticky：对需要上下文 save/restore 的 Responses 会话，强制同一个 provider.key.model。
         // 其它协议不启用粘滞，仅显式 routing 指令才会写入 stickyTarget。
         const providerProtocol = metadata?.providerProtocol;
+        const serverToolRequired = metadata?.serverToolRequired === true;
         const disableSticky = metadata &&
             typeof metadata === 'object' &&
             metadata.disableStickyRoutes === true;
-        const shouldAutoStickyForResponses = providerProtocol === 'openai-responses' && !disableSticky;
+        const shouldAutoStickyForResponses = providerProtocol === 'openai-responses' && serverToolRequired && !disableSticky;
         if (shouldAutoStickyForResponses) {
             const stickyKeyForState = this.resolveStickyKey(metadata);
             if (stickyKeyForState) {
@@ -293,14 +294,24 @@ export class VirtualRouterEngine {
         return this.healthManager.getConfig();
     }
     resolveStickyKey(metadata) {
+        const providerProtocol = metadata.providerProtocol;
+        // 对 Responses 协议的自动粘滞，仅在“单次会话链路”内生效：
+        // - Resume/submit 调用：stickyKey = previousRequestId（指向首轮请求）；
+        // - 普通 /v1/responses 调用：stickyKey = 本次 requestId；
+        // 这样不会把 Responses 的自动粘滞扩散到整个 session，仅在需要 save/restore
+        // 的请求链路中复用 provider.key.model。
+        if (providerProtocol === 'openai-responses') {
+            const resume = metadata.responsesResume;
+            if (resume && typeof resume.previousRequestId === 'string' && resume.previousRequestId.trim()) {
+                return resume.previousRequestId.trim();
+            }
+            return metadata.requestId;
+        }
+        // 其它协议沿用会话级 sticky 语义：sessionId / conversationId → requestId。
         const sessionScope = this.resolveSessionScope(metadata);
         if (sessionScope) {
             return sessionScope;
         }
-        const resume = metadata.responsesResume;
-        if (resume && typeof resume.previousRequestId === 'string' && resume.previousRequestId.trim()) {
-            return resume.previousRequestId.trim();
-        }
         return metadata.requestId;
     }
     resolveSessionScope(metadata) {

package/dist/servertool/handlers/gemini-empty-reply-continue.js

@@ -49,9 +49,7 @@ const handler = async (ctx) => {
         return null;
     }
     const contentRaw = message.content;
-    const contentText = typeof contentRaw === 'string'
-        ? contentRaw.trim()
-        : '';
+    const contentText = typeof contentRaw === 'string' ? contentRaw.trim() : '';
     if (contentText.length > 0) {
         return null;
     }
@@ -59,10 +57,35 @@ const handler = async (ctx) => {
     if (toolCalls.length > 0) {
         return null;
     }
+    // 统计连续空回复次数，超过上限后不再自动续写，而是返回一个可重试错误。
+    const previousCountRaw = adapterRecord.geminiEmptyReplyCount;
+    const previousCount = typeof previousCountRaw === 'number' && Number.isFinite(previousCountRaw) && previousCountRaw >= 0
+        ? previousCountRaw
+        : 0;
+    const nextCount = previousCount + 1;
     const captured = getCapturedRequest(ctx.adapterContext);
     if (!captured) {
         return null;
     }
+    // 超过最多 3 次空回复：返回一个 HTTP_HANDLER_ERROR 形状的错误，交由上层错误中心处理。
+    if (nextCount > 3) {
+        const errorChat = {
+            id: base.id,
+            object: base.object,
+            model: base.model,
+            error: {
+                message: 'fetch failed: gemini_empty_reply_continue exceeded max empty replies',
+                code: 'HTTP_HANDLER_ERROR',
+                type: 'servertool_empty_reply'
+            }
+        };
+        return {
+            chatResponse: errorChat,
+            execution: {
+                flowId: FLOW_ID
+            }
+        };
+    }
     const followupPayload = buildContinueFollowupPayload(captured);
     if (!followupPayload) {
         return null;
@@ -76,7 +99,8 @@ const handler = async (ctx) => {
                 payload: followupPayload,
                 metadata: {
                     serverToolFollowup: true,
-                    stream: false
+                    stream: false,
+                    geminiEmptyReplyCount: nextCount
                 }
             }
         }

package/package.json

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