@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/conversion/hub/semantic-mappers/gemini-mapper.js

@@ -17,6 +17,31 @@ const GENERATION_CONFIG_KEYS = [
 ];
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+const DUMMY_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+function coerceThoughtSignature(value) {
+    if (typeof value === 'string' && value.trim().length) {
+        return value.trim();
+    }
+    return undefined;
+}
+function extractThoughtSignatureFromToolCall(tc) {
+    if (!tc || typeof tc !== 'object') {
+        return undefined;
+    }
+    const node = tc;
+    const direct = coerceThoughtSignature(node.thought_signature ?? node.thoughtSignature);
+    if (direct) {
+        return direct;
+    }
+    const extra = node.extra_content ?? node.extraContent;
+    if (extra && typeof extra === 'object') {
+        const googleNode = extra.google ?? extra.Google;
+        if (googleNode && typeof googleNode === 'object') {
+            return coerceThoughtSignature(googleNode.thought_signature ?? googleNode.thoughtSignature);
+        }
+    }
+    return undefined;
+}
 function normalizeToolOutputs(messages, missing) {
     const outputs = [];
     messages.forEach((msg, index) => {
@@ -35,6 +60,37 @@ function normalizeToolOutputs(messages, missing) {
     });
     return outputs.length ? outputs : undefined;
 }
+function synthesizeToolOutputsFromMessages(messages) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    const outputs = [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        if (message.role !== 'assistant')
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls)
+            ? message.tool_calls
+            : [];
+        for (const call of toolCalls) {
+            const callId = typeof call.id === 'string' ? call.id : undefined;
+            if (!callId) {
+                continue;
+            }
+            const existing = outputs.find((entry) => entry.tool_call_id === callId);
+            if (existing) {
+                continue;
+            }
+            outputs.push({
+                tool_call_id: callId,
+                content: '',
+                name: (call.function && call.function.name) || undefined
+            });
+        }
+    }
+    return outputs;
+}
 function normalizeToolContent(value) {
     if (typeof value === 'string')
         return value;
@@ -47,6 +103,30 @@ function normalizeToolContent(value) {
         return String(value ?? '');
     }
 }
+function convertToolMessageToOutput(message) {
+    const rawId = (message.tool_call_id ?? message.id);
+    const callId = typeof rawId === 'string' && rawId.trim().length ? rawId.trim() : undefined;
+    if (!callId) {
+        return null;
+    }
+    return {
+        tool_call_id: callId,
+        content: normalizeToolContent(message.content),
+        name: typeof message.name === 'string' ? message.name : undefined
+    };
+}
+function buildFunctionResponseEntry(output) {
+    const parsedPayload = safeParseJson(output.content);
+    const normalizedPayload = ensureFunctionResponsePayload(cloneAsJsonValue(parsedPayload));
+    const part = {
+        functionResponse: {
+            name: output.name || 'tool',
+            id: output.tool_call_id,
+            response: normalizedPayload
+        }
+    };
+    return { role: 'user', parts: [part] };
+}
 function collectSystemSegments(systemInstruction) {
     if (!systemInstruction)
         return [];
@@ -91,22 +171,138 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
+function appendChatContentToGeminiParts(message, targetParts) {
+    const content = message.content;
+    if (typeof content === 'string') {
+        const text = content.trim();
+        if (text.length) {
+            targetParts.push({ text });
+        }
+        return;
+    }
+    if (!Array.isArray(content)) {
+        return;
+    }
+    const items = content;
+    for (const block of items) {
+        if (block == null)
+            continue;
+        if (typeof block === 'string') {
+            const text = block.trim();
+            if (text.length) {
+                targetParts.push({ text });
+            }
+            continue;
+        }
+        if (typeof block !== 'object') {
+            const text = String(block);
+            if (text.trim().length) {
+                targetParts.push({ text: text.trim() });
+            }
+            continue;
+        }
+        const record = block;
+        const rawType = record.type;
+        const type = typeof rawType === 'string' ? rawType.toLowerCase() : '';
+        // Text-style blocks
+        if (!type || type === 'text') {
+            const textValue = typeof record.text === 'string'
+                ? record.text
+                : typeof record.content === 'string'
+                    ? record.content
+                    : '';
+            const text = textValue.trim();
+            if (text.length) {
+                targetParts.push({ text });
+            }
+            continue;
+        }
+        // Image-style blocks -> Gemini inlineData
+        if (type === 'image' || type === 'image_url') {
+            // Prefer OpenAI-style image_url.url, but also accept uri/url/data.
+            let url;
+            const imageUrlRaw = record.image_url;
+            if (typeof imageUrlRaw === 'string') {
+                url = imageUrlRaw;
+            }
+            else if (imageUrlRaw && typeof imageUrlRaw === 'object' && typeof imageUrlRaw.url === 'string') {
+                url = imageUrlRaw.url;
+            }
+            else if (typeof record.uri === 'string') {
+                url = record.uri;
+            }
+            else if (typeof record.url === 'string') {
+                url = record.url;
+            }
+            else if (typeof record.data === 'string') {
+                url = record.data;
+            }
+            const trimmed = (url ?? '').trim();
+            if (!trimmed.length) {
+                // Fallback: at least emit a textual marker so内容不会完全丢失
+                targetParts.push({ text: '[image]' });
+                continue;
+            }
+            let mimeType;
+            let data;
+            // data:URL → inlineData { mimeType, data }
+            if (trimmed.startsWith('data:')) {
+                const match = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(trimmed);
+                if (match) {
+                    mimeType = (match[1] || '').trim() || undefined;
+                    data = match[2] || '';
+                }
+            }
+            if (data && data.trim().length) {
+                const inline = {
+                    inlineData: {
+                        data: data.trim()
+                    }
+                };
+                if (mimeType && mimeType.length) {
+                    inline.inlineData.mimeType = mimeType;
+                }
+                targetParts.push(inline);
+            }
+            else {
+                // 非 data: URL 暂时作为文本 URL 传递，保持语义可见
+                targetParts.push({ text: trimmed });
+            }
+            continue;
+        }
+        // 默认：回退为文本 JSON 表示，避免静默丢失内容
+        try {
+            const jsonText = JSON.stringify(record);
+            if (jsonText.trim().length) {
+                targetParts.push({ text: jsonText });
+            }
+        }
+        catch {
+            // ignore malformed block
+        }
+    }
+}
 function buildGeminiRequestFromChat(chat, metadata) {
     const contents = [];
+    const emittedToolOutputs = new Set();
     for (const message of chat.messages) {
         if (!message || typeof message !== 'object')
             continue;
         if (message.role === 'system')
             continue;
-        if (message.role === 'tool')
+        if (message.role === 'tool') {
+            const toolOutput = convertToolMessageToOutput(message);
+            if (toolOutput) {
+                contents.push(buildFunctionResponseEntry(toolOutput));
+                emittedToolOutputs.add(toolOutput.tool_call_id);
+            }
             continue;
+        }
         const entry = {
             role: mapChatRoleToGemini(message.role),
             parts: []
         };
-        if (typeof message.content === 'string' && message.content.trim().length) {
-            entry.parts.push({ text: message.content });
-        }
+        appendChatContentToGeminiParts(message, entry.parts);
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
         for (const tc of toolCalls) {
             if (!tc || typeof tc !== 'object')
@@ -131,25 +327,37 @@ function buildGeminiRequestFromChat(chat, metadata) {
             if (typeof tc.id === 'string') {
                 part.functionCall.id = tc.id;
             }
+            const thoughtSignature = extractThoughtSignatureFromToolCall(tc) ?? DUMMY_THOUGHT_SIGNATURE;
+            if (thoughtSignature) {
+                part.thoughtSignature = thoughtSignature;
+            }
             entry.parts.push(part);
         }
         if (entry.parts.length) {
             contents.push(entry);
         }
     }
+    const toolOutputMap = new Map();
     if (Array.isArray(chat.toolOutputs)) {
-        for (const output of chat.toolOutputs) {
-            const response = cloneAsJsonValue(safeParseJson(output.content));
-            const part = {
-                functionResponse: {
-                    name: output.name || 'tool',
-                    id: output.tool_call_id,
-                    response
-                }
-            };
-            contents.push({ role: 'user', parts: [part] });
+        for (const entry of chat.toolOutputs) {
+            if (entry && typeof entry.tool_call_id === 'string' && entry.tool_call_id.trim().length) {
+                toolOutputMap.set(entry.tool_call_id.trim(), entry);
+            }
+        }
+    }
+    if (toolOutputMap.size === 0) {
+        const syntheticOutputs = synthesizeToolOutputsFromMessages(chat.messages);
+        for (const output of syntheticOutputs) {
+            toolOutputMap.set(output.tool_call_id, output);
         }
     }
+    for (const output of toolOutputMap.values()) {
+        if (emittedToolOutputs.has(output.tool_call_id)) {
+            continue;
+        }
+        contents.push(buildFunctionResponseEntry(output));
+        emittedToolOutputs.add(output.tool_call_id);
+    }
     const request = {
         model: chat.parameters?.model || 'models/gemini-pro',
         contents
@@ -235,6 +443,25 @@ function safeParseJson(value) {
         return value;
     }
 }
+function ensureFunctionResponsePayload(value) {
+    // Gemini function_response.response 字段在 CloudCode/Gemini CLI 协议里对应的是
+    // protobuf Struct（JSON object），而不是顶层数组。
+    // 这里做一层规范化：
+    // - 对象：直接透传；
+    // - 数组：包一层 { result: [...] } 避免把数组作为 Struct 根节点；
+    // - 原始值：包一层 { result: value }，并把 undefined 映射为 null。
+    if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+            return {
+                result: value
+            };
+        }
+        return value;
+    }
+    return {
+        result: value === undefined ? null : value
+    };
+}
 function cloneAsJsonValue(value) {
     try {
         return JSON.parse(JSON.stringify(value ?? null));

package/node_modules/@jsonstudio/llms/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -148,6 +148,20 @@ function serializeSystemContent(message) {
     }
     return undefined;
 }
+function mergeMetadata(a, b) {
+    if (!a && !b) {
+        return undefined;
+    }
+    if (!a && b) {
+        return jsonClone(b);
+    }
+    if (a && !b) {
+        return jsonClone(a);
+    }
+    const left = jsonClone(a);
+    const right = jsonClone(b);
+    return { ...left, ...right };
+}
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
         const payload = format.payload || {};
@@ -209,13 +223,15 @@ export class ResponsesSemanticMapper {
             .map(message => serializeSystemContent(message))
             .filter((content) => typeof content === 'string' && content.length > 0);
         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),
                 originalSystemMessages
             }
             : {
-                metadata: (chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined),
+                metadata: envelopeMetadata,
                 originalSystemMessages
             };
         const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);

package/node_modules/@jsonstudio/llms/dist/conversion/hub/standardized-bridge.js

@@ -60,6 +60,20 @@ export function standardizedToChatEnvelope(request, options) {
     const metadata = {
         context: adapterContext
     };
+    const sourceMeta = (request.metadata && typeof request.metadata === 'object'
+        ? request.metadata
+        : undefined);
+    if (sourceMeta) {
+        if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object') {
+            metadata.webSearch = sourceMeta.webSearch;
+        }
+        if (sourceMeta.forceWebSearch === true) {
+            metadata.forceWebSearch = true;
+        }
+        if (sourceMeta.forceVision === true) {
+            metadata.forceVision = true;
+        }
+    }
     if (typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.length) {
         metadata.toolCallIdStyle = adapterContext.toolCallIdStyle;
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/types/standardized.d.ts

@@ -65,6 +65,7 @@ export interface StandardizedMetadata {
     providerType?: string;
     processMode?: 'chat' | 'passthrough';
     routeHint?: string;
+    webSearchEnabled?: boolean;
     [key: string]: unknown;
 }
 export interface StandardizedRequest {

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-host-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ResponsesRequestContext } from './responses-openai-bridge.js';
+export interface ResponsesHostPolicyResult {
+    shouldStripHostManagedFields: boolean;
+    targetProtocol: string;
+}
+export declare function evaluateResponsesHostPolicy(context?: ResponsesRequestContext, targetProtocol?: string): ResponsesHostPolicyResult;

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-host-policy.js

@@ -0,0 +1,14 @@
+export function evaluateResponsesHostPolicy(context, targetProtocol) {
+    const protocol = typeof targetProtocol === 'string' && targetProtocol.trim()
+        ? targetProtocol
+        : (typeof context?.targetProtocol === 'string' && context.targetProtocol.trim()
+            ? context.targetProtocol
+            : 'responses');
+    const normalized = protocol.toLowerCase();
+    const shouldStrip = normalized !== 'openai-responses' &&
+        normalized !== 'responses';
+    return {
+        shouldStripHostManagedFields: shouldStrip,
+        targetProtocol: normalized
+    };
+}

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.js

@@ -1,4 +1,5 @@
 import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
+import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
 import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, stripInternalToolingMetadata, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
@@ -8,6 +9,7 @@ import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normali
 import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../shared/responses-output-builder.js';
+import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -144,17 +146,96 @@ function normalizeBridgeHistory(seed) {
         originalSystemMessages: systemMessages
     };
 }
+function mergeResponsesTools(originalTools, fromChat) {
+    const result = [];
+    const byKey = new Map();
+    const norm = (value) => {
+        if (typeof value !== 'string')
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed.toLowerCase() : undefined;
+    };
+    const register = (tool) => {
+        const fn = tool.function ?? tool.function;
+        const baseName = norm(fn?.name ?? tool.name);
+        const typeName = norm(tool.type);
+        const key = baseName || typeName;
+        if (!key || byKey.has(key))
+            return;
+        byKey.set(key, tool);
+        result.push(tool);
+    };
+    if (Array.isArray(fromChat)) {
+        for (const t of fromChat) {
+            if (t && typeof t === 'object') {
+                register(t);
+            }
+        }
+    }
+    if (Array.isArray(originalTools)) {
+        for (const t of originalTools) {
+            if (!t || typeof t !== 'object')
+                continue;
+            const typeName = norm(t.type);
+            const isWebSearch = typeName === 'web_search' || (typeof typeName === 'string' && typeName.startsWith('web_search'));
+            if (!isWebSearch) {
+                // 目前仅恢复原始载荷中的 builtin web_search 工具，其它非函数工具保持忽略，避免意外改变行为。
+                continue;
+            }
+            register(t);
+        }
+    }
+    return result.length ? result : undefined;
+}
 export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const chat = unwrapData(payload);
     const out = {};
+    const forceWebSearch = !!ctx &&
+        isObject(ctx.metadata) &&
+        isObject(ctx.metadata.webSearch) &&
+        ctx.metadata.webSearch.force === true;
     // 基本字段
     out.model = chat.model;
     // tools: 反向映射为 ResponsesToolDefinition 形状
-    const responsesTools = mapChatToolsToBridge(chat.tools, {
+    const chatTools = Array.isArray(chat.tools) ? chat.tools : [];
+    // 对于 openai-responses upstream，内建 web_search 由官方服务器处理。
+    // Chat 侧注入的 server-side web_search 函数（带 engine/query/recency/count）
+    // 仅用于非 Responses provider 的 server-tool 回环；在这里构造真正的
+    // `/v1/responses` 请求时，需要：
+    //   1) 不再把函数版 web_search 透传上游；
+    //   2) 若检测到 Chat 侧启用了 web_search 且原始请求中没有 builtin web_search，
+    //      则补一个 `{ type: "web_search" }` 内建工具给 OpenAI Responses。
+    const hasServerSideWebSearch = !forceWebSearch && chatTools.some((tool) => {
+        const fn = tool && typeof tool === 'object' ? tool.function : undefined;
+        const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+        return name === 'web_search';
+    });
+    const toolsForBridge = hasServerSideWebSearch
+        ? chatTools.filter((tool) => {
+            const fn = tool && typeof tool === 'object' ? tool.function : undefined;
+            const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+            return name !== 'web_search';
+        })
+        : chatTools;
+    const responsesToolsFromChat = mapChatToolsToBridge(toolsForBridge, {
         sanitizeName: sanitizeResponsesFunctionName
     });
-    if (responsesTools?.length) {
-        out.tools = responsesTools;
+    // Prefer Chat‑normalized tools, but if the original Responses payload carried
+    // non‑function tools (such as builtin `web_search`), merge them back so that
+    // upstream `/v1/responses` providers see their original tool definitions.
+    const originalTools = Array.isArray(ctx?.toolsRaw) ? ctx.toolsRaw : undefined;
+    let mergedTools = mergeResponsesTools(originalTools, responsesToolsFromChat);
+    if (hasServerSideWebSearch) {
+        const normalizeType = (value) => typeof value === 'string' ? value.trim().toLowerCase() : '';
+        const hasBuiltinWebSearch = (mergedTools && mergedTools.some((tool) => normalizeType(tool.type) === 'web_search')) ||
+            (originalTools && originalTools.some((tool) => normalizeType(tool.type) === 'web_search'));
+        if (!hasBuiltinWebSearch) {
+            const injected = { type: 'web_search' };
+            mergedTools = mergedTools ? [...mergedTools, injected] : [injected];
+        }
+    }
+    if (mergedTools?.length) {
+        out.tools = mergedTools;
     }
     const passthroughKeys = [
         'tool_choice',
@@ -257,12 +338,20 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     else if (metadataExtraFields?.include !== undefined && out.include === undefined) {
         out.include = metadataExtraFields.include;
     }
-    if (ctx?.store !== undefined && out.store === undefined) {
+    const stripHostFields = shouldStripHostManagedFields(ctx);
+    if (stripHostFields) {
+        delete out.store;
+    }
+    else if (ctx?.store !== undefined && out.store === undefined) {
         out.store = ctx.store;
     }
     else if (metadataExtraFields?.store !== undefined && out.store === undefined) {
         out.store = metadataExtraFields.store;
     }
+    else if (out.store === undefined) {
+        // Chat 入口无 store 概念，但 Responses provider 仍要求显式声明。
+        out.store = false;
+    }
     if (ctx?.toolChoice !== undefined && out.tool_choice === undefined) {
         out.tool_choice = ctx.toolChoice;
     }
@@ -433,6 +522,17 @@ export function buildResponsesPayloadFromChat(payload, context) {
     const response = unwrapData(payload);
     if (!response || typeof response !== 'object')
         return payload;
+    const snapshotKey = resolveSnapshotLookupKey(response, context);
+    if (snapshotKey) {
+        const passthrough = consumeResponsesPassthrough(snapshotKey);
+        if (passthrough) {
+            return passthrough;
+        }
+        const snapshot = consumeResponsesPayloadSnapshot(snapshotKey);
+        if (snapshot) {
+            return snapshot;
+        }
+    }
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }
@@ -499,10 +599,22 @@ export function buildResponsesPayloadFromChat(payload, context) {
         out.required_action = outputBuild.requiredAction;
     // Do not inject captured tool results here; keep Chat back-half behavior standard.
     if (context) {
-        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include', 'store']) {
+        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include']) {
             if (context[k] !== undefined)
                 out[k] = context[k];
         }
+        if (!shouldStripHostManagedFields(context) && context.store !== undefined) {
+            out.store = context.store;
+        }
+    }
+    if (typeof response.request_id === 'string') {
+        out.request_id = response.request_id;
+    }
+    else if (typeof response.id === 'string') {
+        out.request_id = response.id;
+    }
+    else if (typeof context?.requestId === 'string') {
+        out.request_id = context.requestId;
     }
     if (out.metadata) {
         stripInternalToolingMetadata(out.metadata);
@@ -524,6 +636,22 @@ function unwrapData(value) {
     }
     return current;
 }
+function resolveSnapshotLookupKey(response, context) {
+    if (typeof response?.request_id === 'string') {
+        return response.request_id;
+    }
+    if (typeof context?.requestId === 'string') {
+        return context.requestId;
+    }
+    if (typeof response?.id === 'string') {
+        return response.id;
+    }
+    return undefined;
+}
+function shouldStripHostManagedFields(context) {
+    const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
+    return result.shouldStripHostManagedFields;
+}
 export function extractRequestIdFromResponse(response) {
     if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
         const meta = response.metadata;