@jsonstudio/rcc 0.89.333 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -10,6 +10,10 @@ import { validateResponsePayload } from '../../../compat/actions/response-valida
 import { writeCompatSnapshot } from '../../../compat/actions/snapshot.js';
 import { applyQwenRequestTransform, applyQwenResponseTransform } from '../../../compat/actions/qwen-transform.js';
 import { extractGlmToolMarkup } from '../../../compat/actions/glm-tool-extraction.js';
+import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-web-search.js';
+import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-search.js';
+import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
+import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -157,6 +161,26 @@ function applyMapping(root, mapping, state) {
         case 'qwen_response_transform':
             replaceRoot(root, applyQwenResponseTransform(root));
             break;
+        case 'glm_web_search_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmWebSearchRequestTransform(root));
+            }
+            break;
+        case 'gemini_web_search_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGeminiWebSearchCompat(root, state.adapterContext));
+            }
+            break;
+        case 'glm_image_content':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmImageContentTransform(root));
+            }
+            break;
+        case 'glm_vision_prompt':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmVisionPromptTransform(root));
+            }
+            break;
         default:
             break;
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -98,6 +98,14 @@ export type MappingInstruction = {
     action: 'qwen_request_transform';
 } | {
     action: 'qwen_response_transform';
+} | {
+    action: 'glm_web_search_request';
+} | {
+    action: 'glm_image_content';
+} | {
+    action: 'glm_vision_prompt';
+} | {
+    action: 'gemini_web_search_request';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

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

@@ -11,6 +11,7 @@ import { GeminiSemanticMapper } from '../semantic-mappers/gemini-mapper.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ChatSemanticMapper } from '../semantic-mappers/chat-mapper.js';
 import { createSnapshotRecorder } from '../snapshot-recorder.js';
+import { shouldRecordSnapshots } from '../../shared/snapshot-utils.js';
 import { runReqInboundStage1FormatParse } from './stages/req_inbound/req_inbound_stage1_format_parse/index.js';
 import { runReqInboundStage2SemanticMap } from './stages/req_inbound/req_inbound_stage2_semantic_map/index.js';
 import { runChatContextCapture, captureResponsesContextSnapshot } from './stages/req_inbound/req_inbound_stage3_context_capture/index.js';
@@ -93,10 +94,18 @@ export class HubPipeline {
         });
         let processedRequest;
         if (normalized.processMode !== 'passthrough') {
+            const processMetadata = {
+                ...(normalized.metadata ?? {})
+            };
+            const webSearchConfig = this.config.virtualRouter?.webSearch;
+            if (webSearchConfig) {
+                processMetadata.webSearch = webSearchConfig;
+            }
+            normalized.metadata = processMetadata;
             const processResult = await runReqProcessStage1ToolGovernance({
                 request: standardizedRequest,
                 rawPayload: rawRequest,
-                metadata: normalized.metadata,
+                metadata: processMetadata,
                 entryEndpoint: normalized.entryEndpoint,
                 requestId: normalized.id,
                 stageRecorder: inboundRecorder
@@ -111,6 +120,9 @@ export class HubPipeline {
         const responsesResume = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
             ? normalizedMeta.responsesResume
             : undefined;
+        const stdMetadata = workingRequest?.metadata;
+        const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
+            stdMetadata?.serverToolRequired === true;
         const metadataInput = {
             requestId: normalized.id,
             entryEndpoint: normalized.entryEndpoint,
@@ -120,7 +132,8 @@ export class HubPipeline {
             providerProtocol: normalized.providerProtocol,
             routeHint: normalized.routeHint,
             stage: normalized.stage,
-            responsesResume: responsesResume
+            responsesResume: responsesResume,
+            ...(serverToolRequired ? { serverToolRequired: true } : {})
         };
         const routing = runReqProcessStage2RouteSelect({
             routerEngine: this.routerEngine,
@@ -221,8 +234,25 @@ export class HubPipeline {
                 }
             });
         }
+        // 为响应侧 servertool/web_search 提供一次性 Chat 请求快照，便于在 Hub 内部实现
+        // 第三跳（将工具结果注入消息历史后重新调用主模型）。
+        let capturedChatRequest;
+        if (normalized.processMode !== 'passthrough') {
+            try {
+                capturedChatRequest = JSON.parse(JSON.stringify({
+                    model: workingRequest.model,
+                    messages: workingRequest.messages,
+                    tools: workingRequest.tools,
+                    parameters: workingRequest.parameters
+                }));
+            }
+            catch {
+                capturedChatRequest = undefined;
+            }
+        }
         const metadata = {
             ...normalized.metadata,
+            ...(capturedChatRequest ? { capturedChatRequest } : {}),
             entryEndpoint: normalized.entryEndpoint,
             providerProtocol: outboundProtocol,
             stream: normalized.stream,
@@ -342,14 +372,19 @@ export class HubPipeline {
         if (typeof metadata.assignedModelId === 'string') {
             adapterContext.modelId = metadata.assignedModelId;
         }
+        // 将 serverToolFollowup 等 ServerTool 相关标记从 normalized.metadata 透传到 AdapterContext，
+        // 便于响应侧的 convertProviderResponse 正确识别“二跳/内部跳转”并跳过 servertool 编排。
+        if (Object.prototype.hasOwnProperty.call(metadata, 'serverToolFollowup')) {
+            adapterContext.serverToolFollowup = metadata
+                .serverToolFollowup;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }
         return adapterContext;
     }
     maybeCreateStageRecorder(context, endpoint) {
-        const flag = (process.env.ROUTECODEX_HUB_SNAPSHOTS || '').trim();
-        if (flag === '0') {
+        if (!shouldRecordSnapshots()) {
             return undefined;
         }
         const effectiveEndpoint = endpoint || context.entryEndpoint || '/v1/chat/completions';

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/target-utils.js

@@ -9,6 +9,12 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     metadata.providerType = target.providerType;
     metadata.modelId = target.modelId;
     metadata.processMode = target.processMode || 'chat';
+    if (target.forceWebSearch === true) {
+        metadata.forceWebSearch = true;
+    }
+    if (target.forceVision === true) {
+        metadata.forceVision = true;
+    }
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process.js

@@ -1,5 +1,6 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
+import { detectLastAssistantToolCategory } from '../../../router/virtual-router/tool-signals.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -51,7 +52,7 @@ async function applyRequestToolGovernance(request, context) {
     });
     const governed = normalizeRecord(governedPayload);
     const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;
-    const merged = {
+    let merged = {
         ...request,
         messages: Array.isArray(governed.messages)
             ? governed.messages
@@ -71,6 +72,14 @@ async function applyRequestToolGovernance(request, context) {
             governanceTimestamp: Date.now()
         }
     };
+    if (containsImageAttachment(merged.messages)) {
+        if (!merged.metadata) {
+            merged.metadata = {
+                originalEndpoint: request.metadata?.originalEndpoint ?? '/v1/chat/completions'
+            };
+        }
+        merged.metadata.hasImageAttachment = true;
+    }
     if (typeof inboundStreamIntent === 'boolean') {
         merged.metadata = {
             ...merged.metadata,
@@ -92,6 +101,8 @@ async function applyRequestToolGovernance(request, context) {
     if (typeof governed.model === 'string' && governed.model.trim()) {
         merged.model = governed.model.trim();
     }
+    // Server-side web_search tool injection (config-driven, best-effort).
+    merged = maybeInjectWebSearchTool(merged, metadata);
     const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
     if (summary.applied) {
         sanitized.metadata = {
@@ -194,6 +205,34 @@ function castSingleTool(tool) {
         }
     };
 }
+function containsImageAttachment(messages) {
+    if (!Array.isArray(messages)) {
+        return false;
+    }
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const content = message.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        for (const part of content) {
+            if (!part || typeof part !== 'object') {
+                continue;
+            }
+            const typeValue = part.type;
+            if (typeof typeValue !== 'string') {
+                continue;
+            }
+            const normalized = typeValue.toLowerCase();
+            if (normalized.includes('image')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function castCustomTool(tool) {
     if (!isRecord(tool)) {
         return null;
@@ -274,3 +313,176 @@ function readToolChoice(value) {
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function maybeInjectWebSearchTool(request, metadata) {
+    // ServerTool 二/三跳（serverToolFollowup=true）不再注入 web_search 工具，
+    // 以避免在 web_search 流程内部形成循环命中。
+    if (metadata.serverToolFollowup === true) {
+        return request;
+    }
+    const rawConfig = metadata.webSearch;
+    if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
+        return request;
+    }
+    const injectPolicy = rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
+        ? rawConfig.injectPolicy
+        : 'selective';
+    if (injectPolicy === 'selective') {
+        const hasExplicitIntent = detectWebSearchIntent(request);
+        if (!hasExplicitIntent) {
+            // 当最近一条用户消息没有明显的“联网搜索”关键词时，
+            // 如果上一轮 assistant 的工具调用已经属于搜索类（如 web_search），
+            // 则仍然视为 web_search 续写场景，强制注入 web_search 工具，
+            // 以便在后续路由中按 servertool 逻辑跳过不适配的 Provider（例如 serverToolsDisabled 的 crs）。
+            const assistantMessages = Array.isArray(request.messages)
+                ? request.messages.filter((msg) => msg && msg.role === 'assistant')
+                : [];
+            const lastTool = detectLastAssistantToolCategory(assistantMessages);
+            const hasSearchToolContext = lastTool?.category === 'search';
+            if (!hasSearchToolContext) {
+                return request;
+            }
+        }
+    }
+    const existingTools = Array.isArray(request.tools) ? request.tools : [];
+    const hasWebSearch = existingTools.some((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return false;
+        const fn = tool.function;
+        return typeof fn?.name === 'string' && fn.name.trim() === 'web_search';
+    });
+    if (hasWebSearch) {
+        return request;
+    }
+    const engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim() && !engine.serverToolsDisabled);
+    if (!engines.length) {
+        return request;
+    }
+    const engineIds = engines.map((engine) => engine.id.trim());
+    const engineDescriptions = engines
+        .map((engine) => {
+        const id = engine.id.trim();
+        const desc = typeof engine.description === 'string' && engine.description.trim()
+            ? engine.description.trim()
+            : '';
+        return desc ? `${id}: ${desc}` : id;
+    })
+        .join('; ');
+    const parameters = {
+        type: 'object',
+        properties: {
+            engine: {
+                type: 'string',
+                enum: engineIds,
+                description: engineDescriptions
+            },
+            query: {
+                type: 'string',
+                description: 'Search query or user question.'
+            },
+            recency: {
+                type: 'string',
+                enum: ['oneDay', 'oneWeek', 'oneMonth', 'oneYear', 'noLimit'],
+                description: 'Optional recency filter for web search results.'
+            },
+            count: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 50,
+                description: 'Number of results to retrieve.'
+            }
+        },
+        // 对于 Responses 内建 web_search，required 需要覆盖 properties 中的所有字段，
+        // 否则上游会报 "required is required to be supplied and to be an array including every key in properties"。
+        required: ['engine', 'query', 'recency', 'count'],
+        additionalProperties: false
+    };
+    const webSearchTool = {
+        type: 'function',
+        function: {
+            name: 'web_search',
+            description: 'Perform web search using configured search engines. Use this when the user asks for up-to-date information or news.',
+            parameters,
+            strict: true
+        }
+    };
+    const nextMetadata = {
+        ...(request.metadata ?? {}),
+        webSearchEnabled: true
+    };
+    return {
+        ...request,
+        metadata: nextMetadata,
+        tools: [...existingTools, webSearchTool]
+    };
+}
+function detectWebSearchIntent(request) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (!messages.length) {
+        return false;
+    }
+    // 从末尾向前找到最近一条 user 消息，忽略 tool / assistant 的工具调用轮次，
+    // 以便在 Responses / 多轮工具调用场景下仍然根据“最近一条用户输入”判断意图。
+    let lastUser;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && candidate.role === 'user') {
+            lastUser = candidate;
+            break;
+        }
+    }
+    if (!lastUser) {
+        return false;
+    }
+    // 支持多模态 content：既可能是纯文本字符串，也可能是带 image_url 的分段数组。
+    let content = '';
+    if (typeof lastUser.content === 'string') {
+        content = lastUser.content;
+    }
+    else if (Array.isArray(lastUser.content)) {
+        const parts = lastUser.content;
+        const texts = [];
+        for (const part of parts) {
+            if (typeof part === 'string') {
+                texts.push(part);
+            }
+            else if (part && typeof part === 'object') {
+                const maybeText = part.text;
+                if (typeof maybeText === 'string' && maybeText.trim()) {
+                    texts.push(maybeText);
+                }
+            }
+        }
+        content = texts.join('\n');
+    }
+    if (!content) {
+        return false;
+    }
+    const text = content.toLowerCase();
+    const keywords = [
+        // English
+        'web search',
+        'web_search',
+        'websearch',
+        'internet search',
+        'search the web',
+        'online search',
+        'search online',
+        'search on the internet',
+        'search the internet',
+        'web-search',
+        'online-search',
+        'internet-search',
+        // Chinese
+        '联网搜索',
+        '网络搜索',
+        '上网搜索',
+        '网上搜索',
+        '网上查',
+        '网上查找',
+        '上网查',
+        '上网搜',
+        // Command-style
+        '/search'
+    ];
+    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/provider-response.d.ts

@@ -0,0 +1,34 @@
+import { Readable } from 'node:stream';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+import type { StageRecorder } from '../format-adapters/index.js';
+import type { ProviderInvoker } from '../../../servertool/types.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface ProviderResponseConversionOptions {
+    providerProtocol: ProviderProtocol;
+    providerResponse: JsonObject;
+    context: AdapterContext;
+    entryEndpoint: string;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+    providerInvoker?: ProviderInvoker;
+    /**
+     * 可选：由 Host 注入的二次请求入口。Server-side 工具在需要发起
+     * followup 请求（例如 web_search 二跳）时，可以通过该回调将构造
+     * 好的请求体交给 Host，由 Host 走完整 HubPipeline + VirtualRouter
+     * 再返回最终客户端响应形状。
+     */
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<ProviderResponseConversionResult>;
+}
+export interface ProviderResponseConversionResult {
+    body?: JsonObject;
+    __sse_responses?: Readable;
+    format?: string;
+}
+export declare function convertProviderResponse(options: ProviderResponseConversionOptions): Promise<ProviderResponseConversionResult>;
+export {};

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/provider-response.js

@@ -1,3 +1,4 @@
+import { recordStage } from '../pipeline/stages/utils.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
@@ -12,44 +13,36 @@ import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/re
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
-function resolveChatReasoningMode(entryEndpoint) {
-    const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
-    const map = {
-        keep: 'keep',
-        drop: 'drop',
-        discard: 'drop',
-        text: 'append_to_content',
-        append: 'append_to_content',
-        append_text: 'append_to_content',
-        append_to_content: 'append_to_content'
-    };
-    if (envRaw && map[envRaw]) {
-        return map[envRaw];
-    }
-    return 'keep';
-}
+import { runServerToolOrchestration } from '../../../servertool/engine.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
-        protocol: 'openai-chat',
         createFormatAdapter: () => new ChatFormatAdapter(),
         createMapper: () => new OpenAIChatResponseMapper()
     },
     'openai-responses': {
-        protocol: 'openai-responses',
         createFormatAdapter: () => new ResponsesFormatAdapter(),
         createMapper: () => new ResponsesResponseMapper()
     },
     'anthropic-messages': {
-        protocol: 'anthropic-messages',
         createFormatAdapter: () => new AnthropicFormatAdapter(),
         createMapper: () => new AnthropicResponseMapper()
     },
     'gemini-chat': {
-        protocol: 'gemini-chat',
         createFormatAdapter: () => new GeminiFormatAdapter(),
         createMapper: () => new GeminiResponseMapper()
     }
 };
+function isServerToolFollowup(context) {
+    const raw = context.serverToolFollowup;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string') {
+        const v = raw.trim().toLowerCase();
+        return v === '1' || v === 'true';
+    }
+    return false;
+}
 function resolveClientProtocol(entryEndpoint) {
     const lowered = (entryEndpoint || '').toLowerCase();
     if (lowered.includes('/v1/responses'))
@@ -85,8 +78,28 @@ function applyModelOverride(payload, model) {
         /* ignore */
     }
 }
+function resolveChatReasoningMode(_entryEndpoint) {
+    // 当前保持默认策略：保留 reasoning_content 字段，不做额外拼接或删除。
+    return 'keep';
+}
 export async function convertProviderResponse(options) {
     const clientProtocol = resolveClientProtocol(options.entryEndpoint);
+    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
+    const skipServerTools = isServerToolFollowup(options.context) || !hasServerToolSupport;
+    // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
+    // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
+    // __sse_responses 可读流。
+    const wantsStream = isServerToolFollowup(options.context) ? false : options.wantsStream;
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`\x1b[38;5;33m[servertool][orchestrator][debug] requestId=${options.context.requestId} ` +
+            `protocol=${options.providerProtocol} endpoint=${options.entryEndpoint} ` +
+            `skipServerTools=${skipServerTools} hasInvoker=${Boolean(options.providerInvoker)} ` +
+            `hasReenter=${Boolean(options.reenterPipeline)}\x1b[0m`);
+    }
+    catch {
+        /* logging best-effort */
+    }
     const displayModel = extractDisplayModel(options.context);
     const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
     if (!plan) {
@@ -96,7 +109,7 @@ export async function convertProviderResponse(options) {
         providerProtocol: options.providerProtocol,
         payload: options.providerResponse,
         adapterContext: options.context,
-        wantsStream: options.wantsStream,
+        wantsStream,
         stageRecorder: options.stageRecorder
     });
     const formatAdapter = plan.createFormatAdapter();
@@ -137,8 +150,55 @@ export async function convertProviderResponse(options) {
         mapper,
         stageRecorder: options.stageRecorder
     });
+    // 记录语义映射后的 ChatCompletion，便于回放 server-side 工具流程。
+    recordStage(options.stageRecorder, 'resp_inbound_stage3_semantic_map.chat', chatResponse);
+    // 检查是否需要进行 ServerTool 编排
+    // 使用新的 ChatEnvelope 级别的 servertool 实现
+    let effectiveChatResponse = chatResponse;
+    if (!skipServerTools && options.reenterPipeline) {
+        try {
+            // eslint-disable-next-line no-console
+            console.log(`\x1b[38;5;33m[servertool][orchestrator] start requestId=${options.context.requestId} ` +
+                `protocol=${options.providerProtocol} endpoint=${options.entryEndpoint}\x1b[0m`);
+        }
+        catch {
+            /* logging best-effort */
+        }
+        const orchestration = await runServerToolOrchestration({
+            chat: chatResponse,
+            adapterContext: options.context,
+            requestId: options.context.requestId,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol,
+            providerInvoker: options.providerInvoker,
+            reenterPipeline: options.reenterPipeline
+        });
+        if (orchestration.executed) {
+            const flowLabel = orchestration.flowId ?? 'servertool_flow';
+            try {
+                // eslint-disable-next-line no-console
+                console.log(`\x1b[38;5;33m[servertool][orchestrator] completed requestId=${options.context.requestId} ` +
+                    `mode=${flowLabel}\x1b[0m`);
+            }
+            catch {
+                /* logging best-effort */
+            }
+            effectiveChatResponse = orchestration.chat;
+        }
+        else {
+            try {
+                // eslint-disable-next-line no-console
+                console.log(`\x1b[38;5;33m[servertool][orchestrator] skipped requestId=${options.context.requestId} ` +
+                    'reason=no_servertool_match\x1b[0m');
+            }
+            catch {
+                /* logging best-effort */
+            }
+        }
+    }
+    // 如果没有执行 servertool，继续原来的处理流程
     const governanceResult = await runRespProcessStage1ToolGovernance({
-        payload: chatResponse,
+        payload: effectiveChatResponse,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         clientProtocol,
@@ -148,7 +208,7 @@ export async function convertProviderResponse(options) {
         payload: governanceResult.governedPayload,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
-        wantsStream: options.wantsStream,
+        wantsStream,
         reasoningMode: resolveChatReasoningMode(options.entryEndpoint),
         stageRecorder: options.stageRecorder
     });
@@ -165,7 +225,7 @@ export async function convertProviderResponse(options) {
         clientPayload,
         clientProtocol,
         requestId: options.context.requestId,
-        wantsStream: options.wantsStream,
+        wantsStream,
         stageRecorder: options.stageRecorder
     });
     if (outbound.stream) {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/server-side-tools.d.ts

@@ -0,0 +1,26 @@
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export type ProviderInvoker = (options: {
+    providerKey: string;
+    providerType?: string;
+    modelId?: string;
+    providerProtocol: string;
+    payload: JsonObject;
+    entryEndpoint: string;
+    requestId: string;
+}) => Promise<{
+    providerResponse: JsonObject;
+}>;
+export interface ServerSideToolEngineOptions {
+    chatResponse: JsonObject;
+    adapterContext: AdapterContext;
+    entryEndpoint: string;
+    requestId: string;
+    providerProtocol: string;
+    providerInvoker?: ProviderInvoker;
+}
+export interface ServerSideToolEngineResult {
+    mode: 'passthrough' | 'web_search_flow';
+    finalChatResponse: JsonObject;
+}
+export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;