@jsonstudio/rcc 0.89.168 → 0.89.524

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

@@ -1,4 +1,11 @@
 import type { JsonObject, JsonValue } from '../../types/json.js';
+import type { FilterConfig as ShapeFilterConfig } from '../../../compat/actions/universal-shape-filter.js';
+import type { ResponseBlacklistConfig } from '../../../compat/actions/response-blacklist.js';
+import type { FieldMapping } from '../../../compat/actions/field-mapping.js';
+import type { RequestRulesConfig } from '../../../compat/actions/request-rules.js';
+import type { AutoThinkingConfig } from '../../../compat/actions/auto-thinking.js';
+import type { ResponseNormalizeConfig } from '../../../compat/actions/response-normalize.js';
+import type { ResponseValidateConfig } from '../../../compat/actions/response-validate.js';
 export type CompatDirection = 'request' | 'response';
 export interface CompatProfileConfig {
     id: string;
@@ -51,6 +58,54 @@ export type MappingInstruction = {
     fallback?: JsonValue;
 } | {
     action: 'convert_responses_output_to_choices';
+} | {
+    action: 'extract_glm_tool_markup';
+} | {
+    action: 'dto_unwrap';
+} | {
+    action: 'dto_rewrap';
+} | {
+    action: 'shape_filter';
+    config: ShapeFilterConfig;
+    target?: CompatDirection;
+} | {
+    action: 'field_map';
+    direction?: 'incoming' | 'outgoing';
+    config: FieldMapping[];
+} | {
+    action: 'tool_schema_sanitize';
+    mode?: 'glm_shell';
+} | {
+    action: 'apply_rules';
+    config: RequestRulesConfig;
+} | {
+    action: 'auto_thinking';
+    config: AutoThinkingConfig;
+} | {
+    action: 'snapshot';
+    phase: 'compat-pre' | 'compat-post';
+    channel?: string;
+} | {
+    action: 'resp_blacklist';
+    config: ResponseBlacklistConfig;
+} | {
+    action: 'response_normalize';
+    config?: ResponseNormalizeConfig;
+} | {
+    action: 'response_validate';
+    config?: ResponseValidateConfig;
+} | {
+    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.d.ts

@@ -64,5 +64,7 @@ export declare class HubPipeline {
     private convertSsePayload;
     private resolveSseProtocol;
     private extractModelHint;
+    private resolveOutboundStreamIntent;
+    private applyOutboundStreamPreference;
 }
 export {};

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,
@@ -142,6 +155,8 @@ export class HubPipeline {
         catch {
             // logging must not break routing
         }
+        const outboundStream = this.resolveOutboundStreamIntent(routing.target?.streaming);
+        this.applyOutboundStreamPreference(workingRequest, outboundStream);
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
         if (routing.target?.compatibilityProfile) {
             outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
@@ -219,14 +234,32 @@ 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,
             processMode: normalized.processMode,
             routeHint: normalized.routeHint,
-            target: routing.target
+            target: routing.target,
+            ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {})
         };
         return {
             requestId: normalized.id,
@@ -339,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';
@@ -508,6 +546,37 @@ export class HubPipeline {
         }
         return undefined;
     }
+    resolveOutboundStreamIntent(providerPreference) {
+        if (providerPreference === 'always') {
+            return true;
+        }
+        if (providerPreference === 'never') {
+            return false;
+        }
+        return undefined;
+    }
+    applyOutboundStreamPreference(request, stream) {
+        if (!request || typeof request !== 'object') {
+            return;
+        }
+        const parameters = request.parameters || {};
+        const nextParameters = { ...parameters };
+        if (typeof stream === 'boolean') {
+            nextParameters.stream = stream;
+        }
+        else if ('stream' in nextParameters) {
+            delete nextParameters.stream;
+        }
+        request.parameters = nextParameters;
+        if (request.metadata && typeof request.metadata === 'object') {
+            if (typeof stream === 'boolean') {
+                request.metadata.outboundStream = stream;
+            }
+            else if ('outboundStream' in request.metadata) {
+                delete request.metadata.outboundStream;
+            }
+        }
+    }
 }
 function normalizeToolCallIdStyleCandidate(value) {
     if (typeof value !== 'string') {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -5,7 +5,7 @@ function pickCompatProfile(adapterContext) {
 }
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyRequestCompat(profile, options.payload);
+    const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('req_outbound_stage3_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
@@ -14,7 +14,7 @@ export async function runReqOutboundStage3Compat(options) {
 }
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyResponseCompat(profile, options.payload);
+    const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('resp_inbound_stage_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'

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

@@ -9,9 +9,18 @@ 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;
     }
+    if (target.streaming) {
+        metadata.targetStreaming = target.streaming;
+    }
     if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
         const trimmed = originalModel.trim();
         if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {

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 {};