@jsonstudio/llms 0.6.203 → 0.6.230

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

@@ -0,0 +1,326 @@
+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) {
+    const choices = getArray(payload.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;
+    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);
+            }
+        }
+    }
+    return texts.join('\n').trim();
+}
+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' || raw === 'websearch')
+        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

@@ -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 [];
@@ -93,13 +173,20 @@ function collectParameters(payload) {
 }
 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: []
@@ -131,24 +218,36 @@ 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',
@@ -235,6 +334,14 @@ function safeParseJson(value) {
         return value;
     }
 }
+function ensureFunctionResponsePayload(value) {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    return {
+        result: value === undefined ? null : value
+    };
+}
 function cloneAsJsonValue(value) {
     try {
         return JSON.parse(JSON.stringify(value ?? null));

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 {

package/dist/conversion/responses/responses-openai-bridge.js

@@ -146,17 +146,63 @@ 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 = {};
     // 基本字段
     out.model = chat.model;
     // tools: 反向映射为 ResponsesToolDefinition 形状
-    const responsesTools = mapChatToolsToBridge(chat.tools, {
+    const responsesToolsFromChat = mapChatToolsToBridge(chat.tools, {
         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;
+    const mergedTools = mergeResponsesTools(originalTools, responsesToolsFromChat);
+    if (mergedTools?.length) {
+        out.tools = mergedTools;
     }
     const passthroughKeys = [
         'tool_choice',

package/dist/conversion/shared/snapshot-utils.js

@@ -1,35 +1,25 @@
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
 import { writeSnapshotViaHooks } from './snapshot-hooks.js';
-const SNAPSHOT_BASE = path.join(os.homedir(), '.routecodex', 'golden_samples');
-function mapEndpointToFolder(endpoint, hint) {
-    if (hint)
-        return hint;
-    const ep = String(endpoint || '').toLowerCase();
-    if (ep.includes('/responses'))
-        return 'openai-responses';
-    if (ep.includes('/messages'))
-        return 'anthropic-messages';
-    if (ep.includes('/gemini'))
-        return 'gemini-chat';
-    return 'openai-chat';
-}
-async function ensureDir(dir) {
-    try {
-        await fs.mkdir(dir, { recursive: true });
+function resolveBoolFromEnv(value, fallback) {
+    if (!value) {
+        return fallback;
     }
-    catch {
-        // ignore fs errors
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+        return true;
     }
-}
-function sanitize(value) {
-    return value.replace(/[^\w.-]/g, '_');
+    if (['0', 'false', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    return fallback;
 }
 export function shouldRecordSnapshots() {
-    const flag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
-    if (flag && flag.trim() === '0') {
-        return false;
+    const hubFlag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
+    if (hubFlag && hubFlag.trim().length) {
+        return resolveBoolFromEnv(hubFlag, true);
+    }
+    const sharedFlag = process.env.ROUTECODEX_SNAPSHOT ?? process.env.ROUTECODEX_SNAPSHOTS;
+    if (sharedFlag && sharedFlag.trim().length) {
+        return resolveBoolFromEnv(sharedFlag, true);
     }
     return true;
 }
@@ -37,26 +27,6 @@ export async function recordSnapshot(options) {
     if (!shouldRecordSnapshots())
         return;
     const endpoint = options.endpoint || '/v1/chat/completions';
-    const folder = mapEndpointToFolder(endpoint, options.folderHint);
-    const dir = path.join(SNAPSHOT_BASE, folder);
-    try {
-        await ensureDir(dir);
-        const safeStage = sanitize(options.stage);
-        const safeRequestId = sanitize(options.requestId);
-        const file = path.join(dir, `${safeRequestId}_${safeStage}.json`);
-        const payload = {
-            meta: {
-                stage: options.stage,
-                timestamp: Date.now(),
-                endpoint
-            },
-            body: options.data
-        };
-        await fs.writeFile(file, JSON.stringify(payload, null, 2), 'utf-8');
-    }
-    catch (error) {
-        console.warn('[snapshot-utils] failed to write snapshot', error);
-    }
     void writeSnapshotViaHooks({
         endpoint,
         stage: options.stage,