@jsonstudio/llms 0.6.568 → 0.6.626

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);
@@ -337,7 +449,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
             else {
                 argsStruct = fn.arguments ?? {};
             }
-            const functionCall = { name, args: cloneAsJsonValue(argsStruct) };
+            let argsJson = cloneAsJsonValue(argsStruct);
+            // Gemini / Antigravity 期望 functionCall.args 为对象（Struct），
+            // 若顶层为数组或原始类型，则包装到 value 字段下，避免产生非法的 list 形状。
+            if (!argsJson || typeof argsJson !== 'object' || Array.isArray(argsJson)) {
+                argsJson = { value: argsJson };
+            }
+            const functionCall = { name, args: argsJson };
             const part = { functionCall };
             if (typeof tc.id === 'string') {
                 part.functionCall.id = tc.id;
@@ -378,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) {
@@ -397,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';
     }
@@ -421,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;
 }
@@ -508,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;
         }
@@ -553,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 {