@jsonstudio/llms 0.6.215 → 0.6.375

package/dist/conversion/hub/response/server-side-tools.js

@@ -0,0 +1,383 @@
+import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function getArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function extractToolCalls(chatResponse) {
+    const choices = getArray(chatResponse.choices);
+    const calls = [];
+    for (const choice of choices) {
+        const choiceObj = asObject(choice);
+        if (!choiceObj)
+            continue;
+        const message = asObject(choiceObj.message);
+        if (!message)
+            continue;
+        const toolCalls = getArray(message.tool_calls);
+        for (const raw of toolCalls) {
+            const tc = asObject(raw);
+            if (!tc)
+                continue;
+            const id = typeof tc.id === 'string' && tc.id.trim() ? tc.id.trim() : '';
+            const fn = asObject(tc.function);
+            const name = fn && typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : '';
+            const args = fn && typeof fn.arguments === 'string' ? fn.arguments : '';
+            if (!id || !name)
+                continue;
+            calls.push({ id, name, arguments: args });
+        }
+    }
+    return calls;
+}
+function extractTextFromChatLike(payload) {
+    // 1) 解包常见包装层：data / response 节点
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !visited.has(current)) {
+        visited.add(current);
+        if (Array.isArray(current.choices) || Array.isArray(current.output)) {
+            break;
+        }
+        const data = current.data;
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            current = data;
+            continue;
+        }
+        const response = current.response;
+        if (response && typeof response === 'object' && !Array.isArray(response)) {
+            current = response;
+            continue;
+        }
+        break;
+    }
+    // 2) 优先从 choices[].message.content 提取（OpenAI/GLM 兼容）
+    const choices = getArray(current.choices);
+    if (!choices.length)
+        return '';
+    const first = asObject(choices[0]);
+    if (!first)
+        return '';
+    const message = asObject(first.message);
+    if (!message)
+        return '';
+    const content = message.content;
+    if (typeof content === 'string')
+        return content.trim();
+    const parts = getArray(content);
+    const texts = [];
+    for (const part of parts) {
+        if (typeof part === 'string') {
+            texts.push(part);
+        }
+        else if (part && typeof part === 'object') {
+            const record = part;
+            if (typeof record.text === 'string') {
+                texts.push(record.text);
+            }
+            else if (typeof record.content === 'string') {
+                texts.push(record.content);
+            }
+        }
+    }
+    const joinedFromChoices = texts.join('\n').trim();
+    if (joinedFromChoices) {
+        return joinedFromChoices;
+    }
+    // 3) 回退：从 output[].content[] 中提取（部分 Responses/自定义后端）
+    const output = current.output;
+    if (Array.isArray(output)) {
+        const altTexts = [];
+        for (const entry of output) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const blocks = entry.content;
+            const blockArray = Array.isArray(blocks) ? blocks : [];
+            for (const block of blockArray) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const record = block;
+                if (typeof record.text === 'string') {
+                    altTexts.push(record.text);
+                }
+                else if (typeof record.output_text === 'string') {
+                    altTexts.push(record.output_text);
+                }
+                else if (typeof record.content === 'string') {
+                    altTexts.push(record.content);
+                }
+            }
+        }
+        const joined = altTexts.join('\n').trim();
+        if (joined) {
+            return joined;
+        }
+    }
+    return '';
+}
+function getWebSearchConfig(ctx) {
+    const raw = ctx.webSearch;
+    const record = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : null;
+    if (!record)
+        return undefined;
+    const enginesRaw = Array.isArray(record.engines) ? record.engines : [];
+    const engines = [];
+    for (const entry of enginesRaw) {
+        const obj = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+        if (!obj)
+            continue;
+        const id = typeof obj.id === 'string' && obj.id.trim() ? obj.id.trim() : undefined;
+        const providerKey = typeof obj.providerKey === 'string' && obj.providerKey.trim()
+            ? obj.providerKey.trim()
+            : undefined;
+        if (!id || !providerKey)
+            continue;
+        engines.push({
+            id,
+            providerKey,
+            description: typeof obj.description === 'string' && obj.description.trim() ? obj.description.trim() : undefined,
+            default: obj.default === true
+        });
+    }
+    if (!engines.length) {
+        return undefined;
+    }
+    const config = { engines };
+    if (typeof record.injectPolicy === 'string') {
+        const val = String(record.injectPolicy).trim().toLowerCase();
+        if (val === 'always' || val === 'selective') {
+            config.injectPolicy = val;
+        }
+    }
+    return config;
+}
+function resolveWebSearchEngine(config, engineId) {
+    const trimmedId = engineId && typeof engineId === 'string' && engineId.trim() ? engineId.trim() : undefined;
+    if (trimmedId) {
+        const byId = config.engines.find((e) => e.id === trimmedId);
+        if (byId) {
+            return byId;
+        }
+    }
+    const byDefault = config.engines.find((e) => e.default);
+    if (byDefault) {
+        return byDefault;
+    }
+    if (config.engines.length === 1) {
+        return config.engines[0];
+    }
+    return undefined;
+}
+function isGeminiWebSearchEngine(engine) {
+    const key = engine.providerKey.toLowerCase();
+    return key.startsWith('gemini-cli.') || key.startsWith('antigravity.');
+}
+function logServerToolWebSearch(engine, requestId, query) {
+    const providerAlias = engine.providerKey.split('.')[0] || engine.providerKey;
+    const backendLabel = `${providerAlias}:${engine.id}`;
+    const prefix = `[server-tool][web_search][${backendLabel}]`;
+    const line = `${prefix} requestId=${requestId} query=${JSON.stringify(query)}`;
+    // 深蓝色输出
+    // eslint-disable-next-line no-console
+    console.log(`\x1b[38;5;27m${line}\x1b[0m`);
+}
+function resolveEnvServerSideToolsEnabled() {
+    const raw = (process.env.ROUTECODEX_SERVER_SIDE_TOOLS || process.env.RCC_SERVER_SIDE_TOOLS || '').trim().toLowerCase();
+    if (!raw)
+        return false;
+    if (raw === '1' || raw === 'true' || raw === 'yes')
+        return true;
+    if (raw === 'web_search')
+        return true;
+    return false;
+}
+export async function runServerSideToolEngine(options) {
+    const base = asObject(options.chatResponse);
+    if (!base) {
+        return { mode: 'passthrough', finalChatResponse: options.chatResponse };
+    }
+    // 内建 OpenAI Responses `/v1/responses` 已经支持 server-side web_search。
+    // 仅当“入口端点为 /v1/responses 且 providerProtocol 也是 openai-responses”时保持透传，
+    // 避免对 Responses→Responses 的链路重复执行搜索回环；
+    // 其它场景（例如 /v1/responses → gemini/glm 后端）仍允许 server-side web_search 生效。
+    const entry = (options.entryEndpoint || '').toLowerCase();
+    if (options.providerProtocol === 'openai-responses' && entry.includes('/v1/responses')) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    // Feature flag: keep behaviour fully backwards-compatible unless explicitly enabled.
+    const toolsEnabled = resolveEnvServerSideToolsEnabled();
+    const toolCalls = extractToolCalls(base);
+    const webSearchCall = toolCalls.find((tc) => tc.name === 'web_search');
+    if (!toolsEnabled || !webSearchCall || !options.providerInvoker) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    const webSearchConfig = getWebSearchConfig(options.adapterContext);
+    if (!webSearchConfig) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    let parsedArgs = {};
+    if (webSearchCall.arguments && typeof webSearchCall.arguments === 'string') {
+        try {
+            parsedArgs = JSON.parse(webSearchCall.arguments);
+        }
+        catch {
+            parsedArgs = {};
+        }
+    }
+    const query = typeof parsedArgs?.query === 'string' && parsedArgs.query.trim()
+        ? parsedArgs.query.trim()
+        : undefined;
+    const engineId = typeof parsedArgs?.engine === 'string' && parsedArgs.engine.trim()
+        ? parsedArgs.engine.trim()
+        : undefined;
+    const recency = typeof parsedArgs?.recency === 'string' && parsedArgs.recency.trim()
+        ? parsedArgs.recency.trim()
+        : undefined;
+    const count = typeof parsedArgs?.count === 'number' && Number.isFinite(parsedArgs.count)
+        ? Math.floor(parsedArgs.count)
+        : undefined;
+    if (!query) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    const engine = resolveWebSearchEngine(webSearchConfig, engineId);
+    if (!engine) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    const providerInvoker = options.providerInvoker;
+    // 1) Call search backend (secondary request)
+    let searchSummary = '';
+    try {
+        logServerToolWebSearch(engine, options.requestId, query);
+        if (isGeminiWebSearchEngine(engine)) {
+            const geminiPayload = {
+                model: engine.id,
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                text: query
+                            }
+                        ]
+                    }
+                ],
+                // Cloud Code search models treat googleSearch as the web search tool.
+                tools: [
+                    {
+                        googleSearch: {}
+                    }
+                ]
+            };
+            const backend = await providerInvoker({
+                providerKey: engine.providerKey,
+                providerType: undefined,
+                modelId: engine.id,
+                providerProtocol: 'gemini-chat',
+                payload: geminiPayload,
+                entryEndpoint: '/v1/models/gemini:generateContent',
+                requestId: `${options.requestId}:web_search:${engine.id}`
+            });
+            const backendResponse = asObject(backend.providerResponse);
+            if (backendResponse) {
+                const chatLike = asObject(buildOpenAIChatFromGeminiResponse(backendResponse));
+                if (chatLike) {
+                    searchSummary = extractTextFromChatLike(chatLike);
+                }
+            }
+        }
+        else {
+            const backendPayload = {
+                model: engine.providerKey,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a web search engine. Answer with up-to-date information based on the open internet.'
+                    },
+                    {
+                        role: 'user',
+                        content: query
+                    }
+                ],
+                stream: false,
+                web_search: {
+                    query,
+                    ...(recency ? { recency } : {}),
+                    ...(typeof count === 'number' ? { count } : {}),
+                    engine: engine.id
+                }
+            };
+            const backend = await providerInvoker({
+                providerKey: engine.providerKey,
+                providerType: undefined,
+                modelId: undefined,
+                providerProtocol: options.providerProtocol,
+                payload: backendPayload,
+                entryEndpoint: '/v1/chat/completions',
+                requestId: `${options.requestId}:web_search:${engine.id}`
+            });
+            const backendResponse = asObject(backend.providerResponse);
+            if (backendResponse) {
+                searchSummary = extractTextFromChatLike(backendResponse);
+            }
+        }
+    }
+    catch {
+        // fall back to passthrough if backend fails
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    if (!searchSummary) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    // 2) Call main provider again with synthesized prompt (third request)
+    const ctxTarget = options.adapterContext.target;
+    const target = ctxTarget && typeof ctxTarget === 'object' && !Array.isArray(ctxTarget)
+        ? ctxTarget
+        : undefined;
+    const mainProviderKey = typeof target?.providerKey === 'string' && target.providerKey.trim()
+        ? target.providerKey.trim()
+        : undefined;
+    const mainModelId = (typeof base.model === 'string' && base.model.trim()
+        ? base.model.trim()
+        : typeof target?.modelId === 'string' && target.modelId.trim()
+            ? target.modelId.trim()
+            : undefined) ?? 'gpt-4o-mini';
+    if (!mainProviderKey) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
+    let finalResponse = base;
+    try {
+        const followupPayload = {
+            model: mainModelId,
+            messages: [
+                {
+                    role: 'system',
+                    content: 'You are an assistant that answers using the provided web_search results. Use them as the primary source.'
+                },
+                {
+                    role: 'user',
+                    content: `User question: ${query}\n\nWeb search results:\n${searchSummary}`
+                }
+            ],
+            stream: false
+        };
+        const followup = await providerInvoker({
+            providerKey: mainProviderKey,
+            providerType: undefined,
+            modelId: mainModelId,
+            providerProtocol: options.providerProtocol,
+            payload: followupPayload,
+            entryEndpoint: '/v1/chat/completions',
+            requestId: `${options.requestId}:web_search_followup`
+        });
+        const followupResponse = asObject(followup.providerResponse);
+        if (followupResponse) {
+            finalResponse = followupResponse;
+        }
+    }
+    catch {
+        // If follow-up fails, keep original base response to avoid breaking clients.
+        finalResponse = base;
+    }
+    return { mode: 'web_search_flow', finalChatResponse: finalResponse };
+}

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

@@ -171,6 +171,117 @@ 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();
@@ -191,9 +302,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             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')
@@ -335,7 +444,18 @@ function safeParseJson(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 {

package/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/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/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 {