@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/web-search.js

@@ -0,0 +1,638 @@
+import { buildOpenAIChatFromGeminiResponse } from '../../conversion/codecs/gemini-openai-codec.js';
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson, extractTextFromChatLike } from '../server-side-tools.js';
+const FLOW_ID = 'web_search_flow';
+const handler = async (ctx) => {
+    const toolCall = ctx.toolCall;
+    if (!toolCall) {
+        return null;
+    }
+    if (!ctx.options.providerInvoker && !ctx.options.reenterPipeline) {
+        return null;
+    }
+    const webSearchConfig = getWebSearchConfig(ctx.adapterContext);
+    const hasConfig = !!webSearchConfig && Array.isArray(webSearchConfig.engines) && webSearchConfig.engines.length > 0;
+    const forceMode = webSearchConfig?.force === true;
+    const envEnabled = resolveEnvServerSideToolsEnabled();
+    if (!hasConfig && !forceMode && !envEnabled) {
+        return null;
+    }
+    const parsedArgs = parseToolArguments(toolCall);
+    const query = typeof parsedArgs.query === 'string' && parsedArgs.query.trim() ? parsedArgs.query.trim() : undefined;
+    if (!query) {
+        return null;
+    }
+    const engines = webSearchConfig ? buildEnginePriorityList(webSearchConfig, parsedArgs.engine) : [];
+    if (!engines.length) {
+        return null;
+    }
+    const resultCount = normalizeResultCount(parsedArgs.count);
+    let chosenEngine;
+    let chosenResult;
+    let lastFailure;
+    for (const engine of engines) {
+        const backendResult = await executeWebSearchBackend({
+            ctx,
+            engine,
+            query,
+            recency: parsedArgs.recency,
+            resultCount
+        });
+        if (backendResult.ok) {
+            chosenEngine = engine;
+            chosenResult = backendResult;
+            break;
+        }
+        lastFailure = { engine, result: backendResult };
+    }
+    if (!chosenEngine || !chosenResult) {
+        if (!lastFailure) {
+            return null;
+        }
+        chosenEngine = lastFailure.engine;
+        chosenResult = lastFailure.result;
+    }
+    const patched = injectWebSearchToolResult(ctx.base, toolCall, chosenEngine, query, chosenResult);
+    const followupPayload = buildWebSearchFollowupPayload(ctx.adapterContext, patched);
+    const execution = {
+        flowId: FLOW_ID,
+        followup: followupPayload
+            ? {
+                requestIdSuffix: ':web_search_followup',
+                payload: followupPayload,
+                metadata: buildFollowupMetadata(ctx.adapterContext, 'web_search')
+            }
+            : undefined
+    };
+    return {
+        chatResponse: patched,
+        execution
+    };
+};
+registerServerToolHandler('web_search', handler);
+function parseToolArguments(toolCall) {
+    if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
+        return {};
+    }
+    try {
+        return JSON.parse(toolCall.arguments);
+    }
+    catch {
+        return {};
+    }
+}
+function getWebSearchConfig(ctx) {
+    const raw = ctx && typeof ctx === 'object' ? ctx.webSearch : undefined;
+    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;
+        const serverToolsDisabled = obj.serverToolsDisabled === true ||
+            (typeof obj.serverToolsDisabled === 'string' &&
+                obj.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+            (obj.serverTools &&
+                typeof obj.serverTools === 'object' &&
+                obj.serverTools.enabled === false);
+        engines.push({
+            id,
+            providerKey,
+            description: typeof obj.description === 'string' && obj.description.trim() ? obj.description.trim() : undefined,
+            default: obj.default === true,
+            ...(serverToolsDisabled ? { serverToolsDisabled: 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;
+        }
+    }
+    if (record.force === true ||
+        (typeof record.force === 'string' && String(record.force).trim().toLowerCase() === 'true')) {
+        config.force = true;
+    }
+    return config;
+}
+function resolveWebSearchEngine(config, engineId) {
+    const trimmedId = typeof engineId === 'string' && engineId.trim() ? engineId.trim() : undefined;
+    if (trimmedId) {
+        const byId = config.engines.find((e) => e.id === trimmedId);
+        if (byId && !byId.serverToolsDisabled) {
+            return byId;
+        }
+    }
+    const byDefault = config.engines.find((e) => e.default && !e.serverToolsDisabled);
+    if (byDefault && !byDefault.serverToolsDisabled) {
+        return byDefault;
+    }
+    if (config.engines.length === 1) {
+        const single = config.engines[0];
+        return single.serverToolsDisabled ? undefined : single;
+    }
+    return undefined;
+}
+function buildEnginePriorityList(config, engineId) {
+    const engines = (Array.isArray(config.engines) ? config.engines : []).filter((engine) => !engine.serverToolsDisabled);
+    if (!engines.length) {
+        return [];
+    }
+    const primary = resolveWebSearchEngine(config, engineId);
+    if (!primary) {
+        return [...engines];
+    }
+    const ordered = [primary];
+    for (const engine of engines) {
+        if (engine !== primary) {
+            ordered.push(engine);
+        }
+    }
+    return ordered;
+}
+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;
+}
+function isGeminiWebSearchEngine(engine) {
+    const key = engine.providerKey.toLowerCase();
+    return (key.startsWith('gemini-cli.') ||
+        key.startsWith('antigravity.') ||
+        key.startsWith('gemini.'));
+}
+function normalizeResultCount(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const normalized = Math.trunc(value);
+        if (normalized >= 5 && normalized <= 15) {
+            return normalized;
+        }
+    }
+    return 10;
+}
+async function executeWebSearchBackend(args) {
+    const { ctx, engine, query } = args;
+    const recency = typeof args.recency === 'string' && args.recency.trim() ? args.recency.trim() : undefined;
+    let summary = '';
+    let hits = [];
+    let ok = true;
+    try {
+        logServerToolWebSearch(engine, ctx.options.requestId, query);
+        const requestSuffix = `:web_search:${engine.id}`;
+        if (ctx.options.reenterPipeline) {
+            const payload = buildWebSearchReenterPayload(engine, query, recency, args.resultCount);
+            const followup = await ctx.options.reenterPipeline({
+                entryEndpoint: '/v1/chat/completions',
+                requestId: `${ctx.options.requestId}${requestSuffix}`,
+                body: payload,
+                metadata: {
+                    routeHint: 'web_search',
+                    serverToolFollowup: true,
+                    stream: false
+                }
+            });
+            const body = followup.body && typeof followup.body === 'object' ? followup.body : null;
+            if (body) {
+                summary = extractTextFromChatLike(body);
+                hits = collectWebSearchHits(body);
+                if (!summary && process.env.ROUTECODEX_DEBUG_GLM_WEB_SEARCH === '1') {
+                    try {
+                        // eslint-disable-next-line no-console
+                        console.log('\x1b[38;5;27m[server-tool][web_search][backend_debug]' +
+                            ` requestId=${ctx.options.requestId}${requestSuffix} payload=${JSON.stringify(body).slice(0, 2000)}\x1b[0m`);
+                    }
+                    catch {
+                        /* logging best-effort */
+                    }
+                }
+            }
+        }
+        else if (ctx.options.providerInvoker) {
+            summary = await executeWebSearchViaProvider({
+                ctx,
+                engine,
+                query,
+                recency,
+                count: args.resultCount,
+                requestSuffix
+            });
+            hits = [];
+        }
+    }
+    catch (error) {
+        ok = false;
+        const message = error instanceof Error && typeof error.message === 'string' && error.message.trim()
+            ? sanitizeBackendError(error.message.trim())
+            : 'web_search backend failed';
+        summary =
+            `web_search failed: ${message}. ` +
+                '请调整搜索关键词（例如减少敏感描述或换一种说法）后重试，这只是当前查询被阻止。';
+    }
+    if (!summary) {
+        if (hits.length) {
+            summary = formatHitsSummary(hits);
+        }
+        else {
+            summary =
+                'web_search completed but returned no textual summary. ' +
+                    '可以尝试修改搜索词、增加时间范围或换一个更具体的描述后再次搜索。';
+        }
+    }
+    try {
+        const preview = summary.length > 120 ? `${summary.slice(0, 117)}...` : summary;
+        // eslint-disable-next-line no-console
+        console.log(`\x1b[38;5;27m[server-tool][web_search][result] requestId=${ctx.options.requestId} ` +
+            `engine=${engine.id} chars=${summary.length} preview=${JSON.stringify(preview)}\x1b[0m`);
+    }
+    catch {
+        /* logging best-effort */
+    }
+    const finalHits = limitHits(hits);
+    if (!summary) {
+        summary = formatHitsSummary(finalHits);
+    }
+    if (finalHits.length > 0 && finalHits.length < 5) {
+        summary = `${summary}\n（当前仅返回${finalHits.length}条可用结果，可尝试调整关键词或时间范围以获取更多。）`;
+    }
+    return { summary, hits: finalHits, ok };
+}
+function buildWebSearchReenterPayload(engine, query, recency, resultCount) {
+    const systemPrompt = buildWebSearchSystemPrompt(resultCount);
+    const basePayload = {
+        model: engine.id,
+        messages: [
+            {
+                role: 'system',
+                content: systemPrompt
+            },
+            {
+                role: 'user',
+                content: query
+            }
+        ],
+        stream: false
+    };
+    if (isGeminiWebSearchEngine(engine)) {
+        return basePayload;
+    }
+    return {
+        ...basePayload,
+        web_search: {
+            query,
+            ...(recency ? { recency } : {}),
+            count: resultCount,
+            engine: engine.id
+        }
+    };
+}
+async function executeWebSearchViaProvider(args) {
+    const { ctx, engine, query, recency, count, requestSuffix } = args;
+    if (!ctx.options.providerInvoker) {
+        return '';
+    }
+    if (isGeminiWebSearchEngine(engine)) {
+        const geminiPayload = {
+            model: engine.id,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            text: query
+                        }
+                    ]
+                }
+            ],
+            tools: [
+                {
+                    googleSearch: {}
+                }
+            ]
+        };
+        const backend = await ctx.options.providerInvoker({
+            providerKey: engine.providerKey,
+            providerType: undefined,
+            modelId: engine.id,
+            providerProtocol: 'gemini-chat',
+            payload: geminiPayload,
+            entryEndpoint: '/v1/models/gemini:generateContent',
+            requestId: `${ctx.options.requestId}${requestSuffix}`,
+            routeHint: 'web_search'
+        });
+        const providerResponse = backend.providerResponse && typeof backend.providerResponse === 'object'
+            ? backend.providerResponse
+            : null;
+        if (!providerResponse) {
+            return '';
+        }
+        const chatLike = buildOpenAIChatFromGeminiResponse(providerResponse);
+        return chatLike ? extractTextFromChatLike(chatLike) : '';
+    }
+    const backendPayload = {
+        model: engine.id,
+        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 } : {}),
+            count: args.count,
+            engine: engine.id
+        }
+    };
+    const backend = await ctx.options.providerInvoker({
+        providerKey: engine.providerKey,
+        providerType: undefined,
+        modelId: undefined,
+        providerProtocol: ctx.options.providerProtocol,
+        payload: backendPayload,
+        entryEndpoint: '/v1/chat/completions',
+        requestId: `${ctx.options.requestId}${requestSuffix}`,
+        routeHint: 'web_search'
+    });
+    const providerResponse = backend.providerResponse && typeof backend.providerResponse === 'object'
+        ? backend.providerResponse
+        : null;
+    if (!providerResponse) {
+        return '';
+    }
+    return extractTextFromChatLike(providerResponse);
+}
+function injectWebSearchToolResult(base, toolCall, engine, query, backendResult) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    const resultsPayload = backendResult.hits.map((hit, index) => ({
+        index: index + 1,
+        title: hit.title ?? '',
+        link: hit.link,
+        snippet: hit.content ?? '',
+        source: hit.media ?? '',
+        publish_date: hit.publish_date ?? ''
+    }));
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: 'web_search',
+            content: JSON.stringify({
+                engine: engine.id,
+                query,
+                summary: backendResult.summary,
+                results: resultsPayload
+            })
+        }
+    ];
+    return cloned;
+}
+function buildWebSearchFollowupPayload(adapterContext, chatResponse) {
+    const captured = adapterContext && typeof adapterContext === 'object'
+        ? adapterContext.capturedChatRequest
+        : undefined;
+    if (!captured || typeof captured !== 'object') {
+        return null;
+    }
+    const originalMessages = Array.isArray(captured.messages)
+        ? cloneJson(captured.messages)
+        : [];
+    const originalTools = Array.isArray(captured.tools)
+        ? cloneJson(captured.tools)
+        : [];
+    const assistantMessage = extractAssistantMessage(chatResponse);
+    if (!assistantMessage) {
+        return null;
+    }
+    const toolMessages = buildToolMessages(chatResponse);
+    if (!toolMessages.length) {
+        return null;
+    }
+    const reconstructed = [...originalMessages, assistantMessage, ...toolMessages];
+    const filteredTools = originalTools.filter((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return false;
+        const fn = tool.function;
+        const name = fn && typeof fn.name === 'string'
+            ? fn.name
+            : '';
+        if (!name)
+            return true;
+        return name !== 'web_search';
+    });
+    const payload = {
+        messages: reconstructed
+    };
+    if (typeof captured.model === 'string' && captured.model.trim()) {
+        payload.model = captured.model.trim();
+    }
+    if (filteredTools.length) {
+        payload.tools = filteredTools;
+    }
+    const parameters = captured.parameters;
+    if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
+        Object.assign(payload, cloneJson(parameters));
+    }
+    return payload;
+}
+function extractAssistantMessage(chatResponse) {
+    const choices = Array.isArray(chatResponse.choices)
+        ? chatResponse.choices
+        : [];
+    if (!choices.length)
+        return null;
+    const firstChoice = choices[0] && typeof choices[0] === 'object' && !Array.isArray(choices[0])
+        ? choices[0]
+        : null;
+    if (!firstChoice)
+        return null;
+    const assistantMessage = firstChoice.message && typeof firstChoice.message === 'object'
+        ? firstChoice.message
+        : null;
+    return assistantMessage;
+}
+function buildToolMessages(chatResponse) {
+    const toolOutputs = Array.isArray(chatResponse.tool_outputs)
+        ? chatResponse.tool_outputs
+        : [];
+    const messages = [];
+    for (const entry of toolOutputs) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const toolCallId = typeof entry.tool_call_id === 'string'
+            ? entry.tool_call_id
+            : undefined;
+        if (!toolCallId)
+            continue;
+        const name = typeof entry.name === 'string'
+            ? entry.name
+            : 'web_search';
+        const rawContent = entry.content;
+        let contentText;
+        if (typeof rawContent === 'string') {
+            contentText = rawContent;
+        }
+        else {
+            try {
+                contentText = JSON.stringify(rawContent ?? {});
+            }
+            catch {
+                contentText = String(rawContent ?? '');
+            }
+        }
+        messages.push({
+            role: 'tool',
+            tool_call_id: toolCallId,
+            name,
+            content: contentText
+        });
+    }
+    return messages;
+}
+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`);
+    const vrPrefix = `[virtual-router][servertool][web_search]`;
+    const vrBackend = `${engine.providerKey}:${engine.id}`;
+    const vrLine = `${vrPrefix} requestId=${requestId} backend=${vrBackend}`;
+    // eslint-disable-next-line no-console
+    console.log(`\x1b[31m${vrLine}\x1b[0m`);
+}
+function buildFollowupMetadata(adapterContext, toolName) {
+    const ctx = adapterContext && typeof adapterContext === 'object' ? adapterContext : null;
+    const routeId = ctx && typeof ctx.routeId === 'string' && ctx.routeId.trim() ? ctx.routeId.trim() : '';
+    if (!routeId || routeId.toLowerCase() === toolName.toLowerCase()) {
+        return undefined;
+    }
+    return { routeHint: routeId };
+}
+function findWebSearchArray(payload) {
+    let current = payload;
+    const visited = new Set();
+    while (current && !visited.has(current)) {
+        visited.add(current);
+        const hits = getArray(current.web_search);
+        if (hits.length) {
+            return hits;
+        }
+        const nextData = current.data;
+        if (nextData && typeof nextData === 'object' && !Array.isArray(nextData)) {
+            current = nextData;
+            continue;
+        }
+        const nextResponse = current.response;
+        if (nextResponse && typeof nextResponse === 'object' && !Array.isArray(nextResponse)) {
+            current = nextResponse;
+            continue;
+        }
+        break;
+    }
+    return undefined;
+}
+function collectWebSearchHits(payload) {
+    const array = findWebSearchArray(payload);
+    if (!array) {
+        return [];
+    }
+    const hits = [];
+    for (const entry of array) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const record = entry;
+        const link = typeof record.link === 'string' && record.link.trim() ? record.link.trim() : '';
+        if (!link)
+            continue;
+        hits.push({
+            title: typeof record.title === 'string' ? record.title : undefined,
+            link,
+            media: typeof record.media === 'string' ? record.media : undefined,
+            publish_date: typeof record.publish_date === 'string' ? record.publish_date : undefined,
+            content: typeof record.content === 'string' ? record.content : undefined,
+            refer: typeof record.refer === 'string' ? record.refer : undefined
+        });
+    }
+    return hits;
+}
+function limitHits(hits) {
+    if (!hits.length)
+        return [];
+    const filtered = hits.slice(0, 15);
+    if (filtered.length >= 5) {
+        return filtered;
+    }
+    return filtered;
+}
+function formatHitsSummary(hits) {
+    if (!hits.length) {
+        return '';
+    }
+    const segments = [];
+    hits.forEach((hit, index) => {
+        const idx = hit.refer && hit.refer.trim() ? hit.refer.trim() : String(index + 1);
+        const headerParts = [];
+        if (hit.title)
+            headerParts.push(hit.title);
+        if (hit.media)
+            headerParts.push(hit.media);
+        if (hit.publish_date)
+            headerParts.push(hit.publish_date);
+        const header = headerParts.length ? headerParts.join(' · ') : '搜索结果';
+        const details = [hit.content, hit.link].filter(Boolean).join('\n');
+        segments.push(`【${idx}】${header}\n${details}`);
+    });
+    return segments.join('\n\n');
+}
+function getArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function sanitizeBackendError(message) {
+    const lowered = message.toLowerCase();
+    if (lowered.includes('contentfilter')) {
+        return '搜索请求被后端暂时拒绝';
+    }
+    if (lowered.includes('instructions are not valid')) {
+        return '搜索指令格式未被后端接受';
+    }
+    return message;
+}
+function buildWebSearchSystemPrompt(targetCount) {
+    const normalizedTarget = Math.max(5, Math.min(15, targetCount));
+    const instructions = [
+        'You are an up-to-date web search engine that aggregates public internet results.',
+        `Return between 5 and 15 high-quality search results (aim for about ${normalizedTarget} when available).`,
+        'Each result must include: title, source/media, publish date if available, a concise summary (<=200 characters), and a direct URL that users can click for verification.',
+        'Prefer de-duplicated sources and include diverse outlets. If fewer than 5 results exist, return what you can find and explain the limitation.',
+        'Only mention that the query was blocked when the backend explicitly rejects it, and encourage the user to adjust their keywords before retrying.',
+        'Structure the answer so downstream systems can extract each result cleanly.'
+    ];
+    return instructions.join('\n');
+}

package/node_modules/@jsonstudio/llms/dist/servertool/orchestration-types.d.ts

@@ -0,0 +1,33 @@
+import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+import type { ProviderInvoker } from './types.js';
+export interface ServerToolOrchestrationOptions {
+    chat: JsonObject;
+    adapterContext: AdapterContext;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    /**
+     * 将带有工具结果的新 ChatEnvelope 作为普通请求再送入 HubPipeline。
+     * 支持 routeHint 来强制路由（例如 web_search）
+     */
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    }>;
+    providerInvoker?: ProviderInvoker;
+}
+export interface ServerToolOrchestrationResult {
+    chat: JsonObject;
+    executed: boolean;
+    /**
+     * 记录本次执行使用的骨架流程，便于日志输出和后续扩展。
+     */
+    flowId?: string;
+}

package/node_modules/@jsonstudio/llms/dist/servertool/orchestration-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@jsonstudio/llms/dist/servertool/registry.d.ts

@@ -0,0 +1,18 @@
+import type { ServerToolHandler } from './types.js';
+/**
+ * ServerToolRegistry：全局注册表，按 tool name 管理 ServerTool handler。
+ * - key 统一使用小写名称（如 "web_search"）；
+ * - 不关注具体协议（Chat / Responses），只负责分发到 handler。
+ */
+type TriggerMode = 'tool_call' | 'auto';
+interface ServerToolHandlerEntry {
+    name: string;
+    trigger: TriggerMode;
+    handler: ServerToolHandler;
+}
+export declare function registerServerToolHandler(name: string, handler: ServerToolHandler, options?: {
+    trigger?: TriggerMode;
+}): void;
+export declare function getServerToolHandler(name: string): ServerToolHandlerEntry | undefined;
+export declare function listAutoServerToolHandlers(): ServerToolHandlerEntry[];
+export {};