@jsonstudio/rcc 0.89.555 → 0.89.682

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

@@ -1,488 +0,0 @@
-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();
-    try {
-        const governed = await applyRequestToolGovernance(options.request, {
-            entryEndpoint: options.entryEndpoint,
-            requestId: options.requestId,
-            metadata: options.metadata
-        });
-        const processedRequest = buildProcessedRequest(governed);
-        return {
-            processedRequest,
-            nodeResult: buildSuccessResult(startTime, processedRequest)
-        };
-    }
-    catch (error) {
-        return {
-            nodeResult: buildErrorResult(startTime, error)
-        };
-    }
-}
-async function applyRequestToolGovernance(request, context) {
-    const entryEndpoint = context.entryEndpoint && context.entryEndpoint.trim()
-        ? context.entryEndpoint
-        : '/v1/chat/completions';
-    const metadata = normalizeRecord(context.metadata);
-    const providerProtocol = readString(metadata.providerProtocol) ?? readString(metadata.provider) ?? 'openai-chat';
-    const metadataToolHints = metadata.toolFilterHints;
-    const metadataStreamFlag = metadata.stream;
-    const inboundStreamIntent = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
-    const shaped = {
-        model: request.model,
-        messages: deepClone(request.messages),
-        tools: request.tools ? deepClone(request.tools) : undefined,
-        tool_choice: request.parameters?.tool_choice,
-        stream: request.parameters?.stream === true,
-        parameters: { ...request.parameters }
-    };
-    const governedPayload = await runChatRequestToolFilters(shaped, {
-        entryEndpoint,
-        requestId: context.requestId,
-        model: request.model,
-        profile: providerProtocol,
-        stream: inboundStreamIntent,
-        toolFilterHints: metadataToolHints,
-        rawPayload: context.metadata?.__raw_request_body && typeof context.metadata.__raw_request_body === 'object'
-            ? context.metadata.__raw_request_body
-            : undefined
-    });
-    const governed = normalizeRecord(governedPayload);
-    const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;
-    let merged = {
-        ...request,
-        messages: Array.isArray(governed.messages)
-            ? governed.messages
-            : request.messages,
-        tools: governed.tools !== undefined ? castGovernedTools(governed.tools) : request.tools,
-        parameters: {
-            ...request.parameters,
-            ...(isRecord(governed.parameters) ? governed.parameters : {})
-        },
-        metadata: {
-            ...request.metadata,
-            toolChoice: readToolChoice(governed.tool_choice),
-            originalStream: inboundStreamIntent,
-            stream: inboundStreamIntent,
-            providerStream: providerStreamIntent,
-            governedTools: governed.tools !== undefined,
-            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,
-            inboundStream: inboundStreamIntent
-        };
-    }
-    if (typeof governed.stream === 'boolean') {
-        merged.parameters = {
-            ...merged.parameters,
-            stream: governed.stream
-        };
-    }
-    if (governed.tool_choice !== undefined) {
-        merged.parameters = {
-            ...merged.parameters,
-            tool_choice: governed.tool_choice
-        };
-    }
-    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 = {
-            ...sanitized.metadata,
-            toolGovernance: {
-                ...sanitized.metadata?.toolGovernance,
-                request: summary
-            }
-        };
-    }
-    return sanitized;
-}
-function buildProcessedRequest(request) {
-    const timestamp = Date.now();
-    const streamingEnabled = request.parameters?.stream === true;
-    return {
-        ...request,
-        processed: {
-            timestamp,
-            appliedRules: ['tool-governance'],
-            status: 'success'
-        },
-        processingMetadata: {
-            streaming: {
-                enabled: streamingEnabled,
-                chunkCount: 0
-            },
-            context: buildContextMetadata(request.metadata)
-        }
-    };
-}
-function buildContextMetadata(metadata) {
-    if (!metadata?.capturedContext || typeof metadata.capturedContext !== 'object') {
-        return undefined;
-    }
-    return { ...metadata.capturedContext };
-}
-function buildSuccessResult(startTime, processedRequest) {
-    const endTime = Date.now();
-    return {
-        success: true,
-        metadata: {
-            node: 'hub-chat-process',
-            executionTime: endTime - startTime,
-            startTime,
-            endTime,
-            dataProcessed: {
-                messages: processedRequest.messages.length,
-                tools: processedRequest.tools?.length ?? 0
-            }
-        }
-    };
-}
-function buildErrorResult(startTime, error) {
-    const endTime = Date.now();
-    return {
-        success: false,
-        metadata: {
-            node: 'hub-chat-process',
-            executionTime: endTime - startTime,
-            startTime,
-            endTime
-        },
-        error: {
-            message: error instanceof Error ? error.message : String(error)
-        }
-    };
-}
-function castGovernedTools(tools) {
-    if (!Array.isArray(tools)) {
-        return undefined;
-    }
-    const normalized = [];
-    for (const tool of tools) {
-        const converted = castSingleTool(tool) ?? castCustomTool(tool);
-        if (converted) {
-            normalized.push(converted);
-        }
-    }
-    return normalized.length ? normalized : [];
-}
-function castSingleTool(tool) {
-    if (!isRecord(tool)) {
-        return null;
-    }
-    const fn = tool.function;
-    if (!isRecord(fn) || typeof fn.name !== 'string') {
-        return null;
-    }
-    const parameters = castToolParameters(fn.parameters);
-    const description = typeof fn.description === 'string' ? fn.description : undefined;
-    const strictFlag = fn.strict === true || tool.strict === true;
-    return {
-        type: 'function',
-        function: {
-            name: fn.name,
-            description,
-            parameters,
-            strict: strictFlag ? true : undefined
-        }
-    };
-}
-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;
-    }
-    const type = typeof tool.type === 'string' ? tool.type.toLowerCase() : '';
-    const name = typeof tool.name === 'string' ? tool.name : '';
-    if (type !== 'custom' || !name) {
-        return null;
-    }
-    if (name.trim() !== 'apply_patch') {
-        return null;
-    }
-    const description = typeof tool.description === 'string' ? tool.description : undefined;
-    return {
-        type: 'function',
-        function: {
-            name: 'apply_patch',
-            description,
-            parameters: {
-                type: 'object',
-                properties: {
-                    patch: {
-                        type: 'string',
-                        description: 'Unified diff patch content (FREEFORM, not JSON)'
-                    }
-                },
-                required: ['patch'],
-                additionalProperties: false
-            },
-            strict: true
-        }
-    };
-}
-function castToolParameters(value) {
-    if (isRecord(value)) {
-        const cloned = deepClone(value);
-        if (cloned && typeof cloned === 'object' && !Array.isArray(cloned)) {
-            const schema = cloned;
-            if (!('type' in schema)) {
-                schema.type = 'object';
-            }
-            if (!isRecord(schema.properties)) {
-                schema.properties = {};
-            }
-            return schema;
-        }
-    }
-    return {
-        type: 'object',
-        properties: {},
-        additionalProperties: true
-    };
-}
-function normalizeRecord(value) {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
-    }
-    return {};
-}
-function deepClone(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function readString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function readToolChoice(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (typeof value === 'object') {
-        return value;
-    }
-    return undefined;
-}
-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/registry.js

@@ -1,98 +0,0 @@
-import { ChatFormatAdapter } from './format-adapters/chat-format-adapter.js';
-import { AnthropicFormatAdapter } from './format-adapters/anthropic-format-adapter.js';
-import { ResponsesFormatAdapter } from './format-adapters/responses-format-adapter.js';
-import { ChatSemanticMapper } from './semantic-mappers/chat-mapper.js';
-import { AnthropicSemanticMapper } from './semantic-mappers/anthropic-mapper.js';
-import { ResponsesSemanticMapper } from './semantic-mappers/responses-mapper.js';
-import { GeminiSemanticMapper } from './semantic-mappers/gemini-mapper.js';
-import { GeminiFormatAdapter } from './format-adapters/gemini-format-adapter.js';
-export const HUB_PROTOCOL_REGISTRY = {
-    'openai-chat': {
-        protocol: 'openai-chat',
-        inbound: {
-            protocol: 'openai-chat',
-            stages: ['format_parse', 'semantic_map_to_chat'],
-            createFormatAdapter: () => new ChatFormatAdapter(),
-            createSemanticMapper: () => new ChatSemanticMapper()
-        },
-        outbound: {
-            protocol: 'openai-chat',
-            stages: ['semantic_map_from_chat', 'format_build'],
-            createFormatAdapter: () => new ChatFormatAdapter(),
-            createSemanticMapper: () => new ChatSemanticMapper()
-        }
-    },
-    'anthropic-messages': {
-        protocol: 'anthropic-messages',
-        inbound: {
-            protocol: 'anthropic-messages',
-            stages: ['format_parse', 'semantic_map_to_chat'],
-            createFormatAdapter: () => new AnthropicFormatAdapter(),
-            createSemanticMapper: () => new AnthropicSemanticMapper()
-        },
-        outbound: {
-            protocol: 'anthropic-messages',
-            stages: ['semantic_map_from_chat', 'format_build'],
-            createFormatAdapter: () => new AnthropicFormatAdapter(),
-            createSemanticMapper: () => new AnthropicSemanticMapper()
-        }
-    },
-    'openai-responses': {
-        protocol: 'openai-responses',
-        inbound: {
-            protocol: 'openai-responses',
-            stages: ['format_parse', 'semantic_map_to_chat'],
-            createFormatAdapter: () => new ResponsesFormatAdapter(),
-            createSemanticMapper: () => new ResponsesSemanticMapper()
-        },
-        outbound: {
-            protocol: 'openai-responses',
-            stages: ['semantic_map_from_chat', 'format_build'],
-            createFormatAdapter: () => new ResponsesFormatAdapter(),
-            createSemanticMapper: () => new ResponsesSemanticMapper()
-        }
-    },
-    'gemini-chat': {
-        protocol: 'gemini-chat',
-        inbound: {
-            protocol: 'gemini-chat',
-            stages: ['format_parse', 'semantic_map_to_chat'],
-            createFormatAdapter: () => new GeminiFormatAdapter(),
-            createSemanticMapper: () => new GeminiSemanticMapper()
-        },
-        outbound: {
-            protocol: 'gemini-chat',
-            stages: ['semantic_map_from_chat', 'format_build'],
-            createFormatAdapter: () => new GeminiFormatAdapter(),
-            createSemanticMapper: () => new GeminiSemanticMapper()
-        }
-    }
-};
-function instantiateInbound(factory) {
-    return {
-        protocol: factory.protocol,
-        stages: factory.stages,
-        passthrough: factory.passthrough,
-        formatAdapter: factory.createFormatAdapter?.(),
-        semanticMapper: factory.createSemanticMapper?.()
-    };
-}
-function instantiateOutbound(factory) {
-    return {
-        protocol: factory.protocol,
-        stages: factory.stages,
-        passthrough: factory.passthrough,
-        formatAdapter: factory.createFormatAdapter?.(),
-        semanticMapper: factory.createSemanticMapper?.()
-    };
-}
-export function createProtocolPlans(protocol) {
-    const definition = HUB_PROTOCOL_REGISTRY[protocol];
-    if (!definition) {
-        throw new Error(`Unknown hub protocol: ${protocol}`);
-    }
-    return {
-        inbound: instantiateInbound(definition.inbound),
-        outbound: instantiateOutbound(definition.outbound)
-    };
-}

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

@@ -1,89 +0,0 @@
-function extractMessageContent(message) {
-    const content = (message && typeof message === 'object') ? message.content : undefined;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (!part)
-                return '';
-            if (typeof part === 'string')
-                return part;
-            if (typeof part.text === 'string')
-                return part.text;
-            if (typeof part.content === 'string')
-                return part.content;
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-    }
-    if (typeof content === 'string')
-        return content;
-    return '';
-}
-function mapToolCalls(toolCalls) {
-    if (!Array.isArray(toolCalls))
-        return undefined;
-    return toolCalls
-        .map((tc) => {
-        if (!tc || typeof tc !== 'object')
-            return null;
-        const fn = tc.function || {};
-        if (typeof fn?.name !== 'string')
-            return null;
-        const args = typeof fn?.arguments === 'string' ? fn.arguments : (() => {
-            try {
-                return JSON.stringify(fn?.arguments ?? {});
-            }
-            catch {
-                return '{}';
-            }
-        })();
-        return {
-            id: typeof tc.id === 'string' ? tc.id : `call_${Math.random().toString(36).slice(2, 10)}`,
-            type: 'function',
-            function: {
-                name: fn.name,
-                arguments: args
-            }
-        };
-    })
-        .filter(Boolean);
-}
-export function buildProcessedRequestFromChatResponse(chatResponse, options) {
-    const streamingEnabled = options?.stream === true;
-    const firstChoice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : null;
-    const msg = firstChoice?.message || {};
-    const content = extractMessageContent(msg);
-    const toolCalls = mapToolCalls(msg?.tool_calls);
-    const assistantMessage = {
-        role: 'assistant',
-        content,
-        tool_calls: toolCalls
-    };
-    const processedRequest = {
-        model: typeof chatResponse?.model === 'string' ? chatResponse.model : 'unknown',
-        messages: [assistantMessage],
-        tools: undefined,
-        parameters: {},
-        metadata: {
-            originalEndpoint: 'openai-chat',
-            ...(streamingEnabled ? { stream: true } : {})
-        },
-        processed: {
-            timestamp: Date.now(),
-            appliedRules: ['response-pipeline'],
-            status: 'success'
-        },
-        processingMetadata: {
-            streaming: {
-                enabled: streamingEnabled,
-                chunkCount: 0,
-                totalTokens: typeof chatResponse?.usage?.completion_tokens === 'number'
-                    ? chatResponse.usage.completion_tokens
-                    : 0
-            },
-            context: {}
-        }
-    };
-    return processedRequest;
-}