@jsonstudio/llms 0.6.215 → 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/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/tool-mapping.js

@@ -56,6 +56,19 @@ function enforceBuiltinToolSchema(name, candidate) {
         const base = asSchema(candidate);
         return ensureApplyPatchSchema(base);
     }
+    if (normalizedName === 'web_search') {
+        // For web_search we currently accept any incoming schema and fall back to a
+        // minimal object definition. Server-side web_search execution only relies
+        // on the function name + JSON arguments, so tool schema is best-effort.
+        const base = asSchema(candidate) ?? {};
+        if (!base.type) {
+            base.type = 'object';
+        }
+        if (!Object.prototype.hasOwnProperty.call(base, 'properties')) {
+            base.properties = {};
+        }
+        return base;
+    }
     return asSchema(candidate);
 }
 const DEFAULT_SANITIZER = (value) => {
@@ -111,10 +124,20 @@ export function bridgeToolToChatDefinition(rawTool, options) {
     }
     const tool = rawTool;
     const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
-    const name = pickToolName([fnNode?.name, tool.name], options);
+    let name = pickToolName([fnNode?.name, tool.name], options);
+    // Special case for Responses builtin web_search tools:
+    // Codex / Claude‑code may send tools shaped as `{ type: "web_search", ... }`
+    // without a nested `function` node. Treat these as a canonical `web_search`
+    // function tool so downstream Chat / Standardized layers can reason over a
+    // single function-style web_search surface.
     if (!name) {
-        return null;
+        const rawType = typeof tool.type === 'string' ? tool.type.trim().toLowerCase() : '';
+        if (rawType === 'web_search' || rawType.startsWith('web_search')) {
+            name = 'web_search';
+        }
     }
+    if (!name)
+        return null;
     const description = resolveToolDescription(fnNode?.description ?? tool.description);
     const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, tool));
     const strict = resolveToolStrict(fnNode, tool);