@jsonstudio/rcc 0.89.611 → 0.89.683

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/iflow-web-search.js

@@ -1,87 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const DEBUG_IFLOW_WEB_SEARCH = (process.env.ROUTECODEX_DEBUG_IFLOW_WEB_SEARCH || '').trim() === '1';
-/**
- * IFlow web_search 请求适配（作用于 openai-chat 兼容 payload）：
- *
- * - 仅在 routeId 以 `web_search` 开头时生效（来自 AdapterContext.routeId）；
- * - 读取顶层的 `web_search` helper 对象 `{ query, recency, count, engine }`；
- * - 当 query 为空或无效时：删除 helper，原样透传；
- * - 当 query 有效时：构造一个标准的 OpenAI function tool：
- *   - name 固定为 `web_search`；
- *   - parameters 包含 query/recency/count 三个字段；
- * - 将生成的 function tool 写入 `tools` 数组，并删除顶层 `web_search`。
- *
- * 注意：
- * - 顶层 `web_search` 只在 servertool 的二跳请求中出现，用于驱动后端搜索；
- * - 用户侧的工具调用仍然使用统一的 `web_search` function tool schema。
- */
-export function applyIflowWebSearchRequestTransform(payload, adapterContext) {
-    const routeId = typeof adapterContext?.routeId === 'string' ? adapterContext.routeId : '';
-    if (!routeId || !routeId.toLowerCase().startsWith('web_search')) {
-        return payload;
-    }
-    const root = structuredClone(payload);
-    const webSearchRaw = root.web_search;
-    if (!isRecord(webSearchRaw)) {
-        return root;
-    }
-    const webSearch = webSearchRaw;
-    const queryValue = webSearch.query;
-    const recencyValue = webSearch.recency;
-    const countValue = webSearch.count;
-    const query = typeof queryValue === 'string' ? queryValue.trim() : '';
-    const recency = typeof recencyValue === 'string' ? recencyValue.trim() : undefined;
-    let count;
-    if (typeof countValue === 'number' && Number.isFinite(countValue)) {
-        const normalized = Math.floor(countValue);
-        if (normalized >= 1 && normalized <= 50) {
-            count = normalized;
-        }
-    }
-    if (!query) {
-        // No meaningful search query, drop the helper object and passthrough.
-        delete root.web_search;
-        return root;
-    }
-    const tool = {
-        type: 'function',
-        function: {
-            name: 'web_search',
-            description: 'Perform web search over the public internet and return up-to-date results.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: {
-                        type: 'string',
-                        description: 'Search query string.'
-                    },
-                    recency: {
-                        type: 'string',
-                        description: 'Optional recency filter such as "day", "week", or "month".'
-                    },
-                    count: {
-                        type: 'integer',
-                        minimum: 1,
-                        maximum: 50,
-                        description: 'Maximum number of search results to retrieve (1-50).'
-                    }
-                },
-                required: ['query']
-            }
-        }
-    };
-    root.tools = [tool];
-    delete root.web_search;
-    if (DEBUG_IFLOW_WEB_SEARCH) {
-        try {
-            // eslint-disable-next-line no-console
-            console.log('\x1b[38;5;27m[compat][iflow_web_search_request] applied web_search transform ' +
-                `query=${JSON.stringify(query).slice(0, 200)} ` +
-                `recency=${String(recency ?? '')}\x1b[0m`);
-        }
-        catch {
-            // logging best-effort
-        }
-    }
-    return root;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/qwen-transform.d.ts

@@ -1,3 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-export declare function applyQwenRequestTransform(payload: JsonObject): JsonObject;
-export declare function applyQwenResponseTransform(payload: JsonObject): JsonObject;

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/qwen-transform.js

@@ -1,209 +0,0 @@
-const MODEL_MAP = {
-    'gpt-3.5-turbo': 'qwen-turbo',
-    'gpt-4': 'qwen3-coder-plus',
-    'gpt-4-turbo': 'qwen3-coder-plus',
-    'gpt-4o': 'qwen3-coder-plus'
-};
-const FINISH_REASON_MAP = {
-    stop: 'stop',
-    length: 'length',
-    tool_calls: 'tool_calls',
-    content_filter: 'content_filter'
-};
-const isRecord = (value) => typeof value === 'object' && value !== null;
-export function applyQwenRequestTransform(payload) {
-    const cloned = structuredClone(payload);
-    const transformed = convertToQwenRequest(cloned);
-    return transformed;
-}
-export function applyQwenResponseTransform(payload) {
-    const cloned = structuredClone(payload);
-    const transformed = transformQwenResponseToOpenAI(cloned);
-    return transformed;
-}
-function convertToQwenRequest(request) {
-    const qwenRequest = {};
-    const mappedModel = mapModelName(typeof request.model === 'string' ? request.model : undefined);
-    if (mappedModel) {
-        qwenRequest.model = mappedModel;
-    }
-    if (Array.isArray(request.messages)) {
-        qwenRequest.messages = structuredClone(request.messages);
-        const normalizedMessages = request.messages
-            .map(message => normalizeMessage(message))
-            .filter((entry) => entry !== null);
-        if (normalizedMessages.length > 0) {
-            qwenRequest.input = normalizedMessages;
-        }
-    }
-    const parameters = extractParameters(request);
-    if (Object.keys(parameters).length > 0) {
-        qwenRequest.parameters = parameters;
-    }
-    if (typeof request.stream === 'boolean') {
-        qwenRequest.stream = request.stream;
-    }
-    if (isRecord(request.response_format)) {
-        qwenRequest.response_format = structuredClone(request.response_format);
-    }
-    if (typeof request.user === 'string') {
-        qwenRequest.user = request.user;
-    }
-    if (Array.isArray(request.tools)) {
-        qwenRequest.tools = sanitizeTools(request.tools);
-    }
-    if (isRecord(request.metadata)) {
-        qwenRequest.metadata = structuredClone(request.metadata);
-    }
-    return qwenRequest;
-}
-function sanitizeTools(tools) {
-    return tools.map(tool => {
-        if (!isRecord(tool)) {
-            return tool;
-        }
-        const normalized = {};
-        if (typeof tool.type === 'string') {
-            normalized.type = tool.type;
-        }
-        if (isRecord(tool.function)) {
-            normalized.function = structuredClone(tool.function);
-        }
-        return Object.keys(normalized).length > 0 ? normalized : tool;
-    });
-}
-function normalizeMessage(message) {
-    if (!isRecord(message)) {
-        return null;
-    }
-    const role = typeof message.role === 'string' ? message.role : 'user';
-    const content = normalizeMessageContent(message.content);
-    return { role, content };
-}
-function normalizeMessageContent(content) {
-    if (content === undefined || content === null) {
-        return [{ text: '' }];
-    }
-    if (typeof content === 'string') {
-        return [{ text: content }];
-    }
-    if (Array.isArray(content)) {
-        return content.map(chunk => normalizeContentChunk(chunk));
-    }
-    if (isRecord(content) && typeof content.text === 'string') {
-        return [{ text: content.text }];
-    }
-    return [{ text: JSON.stringify(content) }];
-}
-function normalizeContentChunk(chunk) {
-    if (typeof chunk === 'string') {
-        return { text: chunk };
-    }
-    if (isRecord(chunk)) {
-        if (typeof chunk.text === 'string') {
-            return { text: chunk.text };
-        }
-        return structuredClone(chunk);
-    }
-    return { text: String(chunk) };
-}
-function extractParameters(request) {
-    const parameters = {};
-    const numericFields = [
-        { key: 'temperature', target: 'temperature' },
-        { key: 'top_p', target: 'top_p' },
-        { key: 'frequency_penalty', target: 'frequency_penalty' },
-        { key: 'presence_penalty', target: 'presence_penalty' },
-        { key: 'max_tokens', target: 'max_output_tokens' }
-    ];
-    for (const field of numericFields) {
-        const value = request[field.key];
-        if (typeof value === 'number') {
-            parameters[field.target] = value;
-        }
-    }
-    if (request.stop !== undefined) {
-        const stops = Array.isArray(request.stop) ? request.stop : [request.stop];
-        const sequences = stops.filter(item => typeof item === 'string');
-        if (sequences.length > 0) {
-            parameters.stop_sequences = sequences;
-        }
-    }
-    if (typeof request.debug === 'boolean') {
-        parameters.debug = request.debug;
-    }
-    return parameters;
-}
-function transformQwenResponseToOpenAI(response) {
-    const data = isRecord(response.data) ? response.data : response;
-    const usage = isRecord(data.usage)
-        ? structuredClone(data.usage)
-        : {
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            total_tokens: 0
-        };
-    const transformed = {
-        id: typeof data.id === 'string' ? data.id : `chatcmpl-${Date.now()}`,
-        object: 'chat.completion',
-        created: typeof data.created === 'number' ? data.created : Math.floor(Date.now() / 1000),
-        model: typeof data.model === 'string' ? data.model : 'qwen-turbo',
-        choices: transformChoices(data.choices),
-        usage,
-        _transformed: true,
-        _originalFormat: 'qwen',
-        _targetFormat: 'openai'
-    };
-    return transformed;
-}
-function transformChoices(rawChoices) {
-    if (!Array.isArray(rawChoices)) {
-        return [];
-    }
-    return rawChoices.map((choice, index) => {
-        const choiceObj = isRecord(choice) ? choice : {};
-        const messageObj = isRecord(choiceObj.message) ? choiceObj.message : {};
-        return {
-            index: typeof choiceObj.index === 'number' ? choiceObj.index : index,
-            message: {
-                role: typeof messageObj.role === 'string' ? messageObj.role : 'assistant',
-                content: typeof messageObj.content === 'string' ? messageObj.content : '',
-                tool_calls: transformToolCalls(messageObj.tool_calls)
-            },
-            finish_reason: transformFinishReason(typeof choiceObj.finish_reason === 'string' ? choiceObj.finish_reason : undefined)
-        };
-    });
-}
-function transformToolCalls(toolCalls) {
-    if (!Array.isArray(toolCalls)) {
-        return [];
-    }
-    return toolCalls.map((toolCall, index) => {
-        const toolCallObj = isRecord(toolCall) ? toolCall : {};
-        const fnObj = isRecord(toolCallObj.function) ? toolCallObj.function : {};
-        const id = typeof toolCallObj.id === 'string'
-            ? toolCallObj.id
-            : `call_${Date.now()}_${index}`;
-        const name = typeof fnObj.name === 'string' ? fnObj.name : '';
-        const args = typeof fnObj.arguments === 'string'
-            ? fnObj.arguments
-            : JSON.stringify(fnObj.arguments ?? {});
-        return {
-            id,
-            type: 'function',
-            function: { name, arguments: args }
-        };
-    });
-}
-function transformFinishReason(reason) {
-    if (!reason) {
-        return 'stop';
-    }
-    return FINISH_REASON_MAP[reason] ?? reason;
-}
-function mapModelName(model) {
-    if (!model) {
-        return undefined;
-    }
-    return MODEL_MAP[model] ?? model;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/request-rules.d.ts

@@ -1,24 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-export interface RequestRulesConfig {
-    tools?: {
-        function?: {
-            removeKeys?: string[];
-        };
-    };
-    messages?: {
-        assistantToolCalls?: {
-            function?: {
-                removeKeys?: string[];
-            };
-        };
-    };
-    topLevel?: {
-        conditional?: Array<{
-            when?: {
-                tools?: 'empty' | 'present';
-            };
-            remove?: string[];
-        }>;
-    };
-}
-export declare function applyRequestRules(payload: JsonObject, config?: RequestRulesConfig): JsonObject;

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/request-rules.js

@@ -1,63 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-export function applyRequestRules(payload, config) {
-    if (!config) {
-        return payload;
-    }
-    const cloned = { ...payload };
-    const toolRule = config.tools?.['function'];
-    if (toolRule?.removeKeys && Array.isArray(cloned.tools)) {
-        for (const toolEntry of cloned.tools) {
-            if (!isRecord(toolEntry)) {
-                continue;
-            }
-            const fnNode = toolEntry.function;
-            if (!isRecord(fnNode)) {
-                continue;
-            }
-            for (const key of toolRule.removeKeys) {
-                delete fnNode[key];
-            }
-        }
-    }
-    const assistantRule = config.messages?.assistantToolCalls?.['function'];
-    if (Array.isArray(cloned.messages) && assistantRule?.removeKeys) {
-        for (const message of cloned.messages) {
-            if (!isRecord(message) || !Array.isArray(message.tool_calls)) {
-                continue;
-            }
-            for (const callEntry of message.tool_calls) {
-                if (!isRecord(callEntry)) {
-                    continue;
-                }
-                const fnNode = callEntry.function;
-                if (!isRecord(fnNode)) {
-                    continue;
-                }
-                for (const key of assistantRule.removeKeys) {
-                    delete fnNode[key];
-                }
-            }
-        }
-    }
-    if (Array.isArray(config.topLevel?.conditional)) {
-        for (const rule of config.topLevel.conditional) {
-            if (!rule)
-                continue;
-            if (rule.when?.tools === 'empty') {
-                if (Array.isArray(cloned.tools) && cloned.tools.length === 0) {
-                    for (const field of rule.remove || []) {
-                        delete cloned[field];
-                    }
-                }
-            }
-            if (rule.when?.tools === 'present') {
-                if (Array.isArray(cloned.tools) && cloned.tools.length > 0) {
-                    for (const field of rule.remove || []) {
-                        delete cloned[field];
-                    }
-                }
-            }
-        }
-    }
-    return cloned;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-blacklist.d.ts

@@ -1,14 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-export interface ResponseBlacklistConfig {
-    paths?: string[];
-    keepCritical?: boolean;
-}
-export declare class ResponseBlacklistSanitizer {
-    private readonly cfg;
-    private readonly criticalPaths;
-    constructor(config: ResponseBlacklistConfig);
-    private isCritical;
-    private unwrapPayload;
-    private deleteByPath;
-    apply(payload: JsonObject): JsonObject;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-blacklist.js

@@ -1,85 +0,0 @@
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isTraversable(value) {
-    return Array.isArray(value) || isRecord(value);
-}
-export class ResponseBlacklistSanitizer {
-    cfg;
-    criticalPaths = new Set([
-        'status',
-        'output',
-        'output_text',
-        'required_action',
-        'choices[].message.content',
-        'choices[].message.tool_calls',
-        'choices[].finish_reason'
-    ]);
-    constructor(config) {
-        this.cfg = config;
-    }
-    isCritical(pathStr) {
-        if (!this.cfg.keepCritical) {
-            return false;
-        }
-        return this.criticalPaths.has(pathStr);
-    }
-    unwrapPayload(payload) {
-        if (!isRecord(payload)) {
-            return {};
-        }
-        const rootCandidate = payload.data;
-        return isRecord(rootCandidate) ? rootCandidate : payload;
-    }
-    deleteByPath(obj, pathStr) {
-        const tokens = pathStr.split('.');
-        const recurse = (current, idx) => {
-            if (!isTraversable(current) || idx >= tokens.length) {
-                return;
-            }
-            const token = tokens[idx];
-            const isArrayWildcard = token.endsWith('[]');
-            const key = isArrayWildcard ? token.slice(0, -2) : token;
-            if (idx === tokens.length - 1) {
-                if (!isArrayWildcard && isRecord(current) && Object.prototype.hasOwnProperty.call(current, key)) {
-                    delete current[key];
-                }
-                return;
-            }
-            if (isArrayWildcard) {
-                if (isRecord(current)) {
-                    const arr = current[key];
-                    if (Array.isArray(arr)) {
-                        for (const item of arr) {
-                            recurse(item, idx + 1);
-                        }
-                    }
-                }
-            }
-            else if (isRecord(current)) {
-                recurse(current[key], idx + 1);
-            }
-        };
-        recurse(obj, 0);
-    }
-    apply(payload) {
-        const out = isRecord(payload) ? payload : {};
-        try {
-            const root = this.unwrapPayload(out);
-            const configPaths = Array.isArray(this.cfg?.paths) ? this.cfg.paths ?? [] : [];
-            for (const p of configPaths) {
-                if (typeof p !== 'string' || !p) {
-                    continue;
-                }
-                if (this.isCritical(p)) {
-                    continue;
-                }
-                this.deleteByPath(root, p);
-            }
-            return out;
-        }
-        catch {
-            return out;
-        }
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-normalize.d.ts

@@ -1,5 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-export interface ResponseNormalizeConfig {
-    finishReasonMap?: Record<string, string>;
-}
-export declare function normalizeResponsePayload(payload: JsonObject, config?: ResponseNormalizeConfig): JsonObject;

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-normalize.js

@@ -1,121 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-export function normalizeResponsePayload(payload, config) {
-    const normalized = { ...payload };
-    if (isRecord(normalized.usage)) {
-        normalized.usage = normalizeUsageFields(normalized.usage);
-    }
-    if (typeof normalized.created_at === 'number') {
-        normalized.created = normalized.created_at;
-        delete normalized.created_at;
-    }
-    if (Array.isArray(normalized.choices)) {
-        normalized.choices = normalizeChoices(normalized.choices, config);
-    }
-    return normalized;
-}
-function normalizeUsageFields(usage) {
-    const normalizedUsage = { ...usage };
-    const fieldMappings = {
-        input_tokens: 'prompt_tokens',
-        output_tokens: 'completion_tokens',
-        total_input_tokens: 'prompt_tokens',
-        total_output_tokens: 'completion_tokens'
-    };
-    for (const [glmField, standardField] of Object.entries(fieldMappings)) {
-        const value = normalizedUsage[glmField];
-        if (typeof value === 'number') {
-            normalizedUsage[standardField] = value;
-            delete normalizedUsage[glmField];
-        }
-    }
-    const promptTokens = typeof normalizedUsage.prompt_tokens === 'number' ? normalizedUsage.prompt_tokens : 0;
-    const completionTokens = typeof normalizedUsage.completion_tokens === 'number'
-        ? normalizedUsage.completion_tokens
-        : 0;
-    normalizedUsage.prompt_tokens = promptTokens;
-    normalizedUsage.completion_tokens = completionTokens;
-    if (typeof normalizedUsage.total_tokens !== 'number') {
-        normalizedUsage.total_tokens = promptTokens + completionTokens;
-    }
-    return normalizedUsage;
-}
-function normalizeChoices(choices, config) {
-    const map = config?.finishReasonMap || {};
-    return choices.map((choice, idx) => {
-        if (!isRecord(choice)) {
-            return choice;
-        }
-        const normalizedChoice = {
-            index: typeof choice.index === 'number' ? choice.index : idx,
-            ...choice
-        };
-        if (typeof normalizedChoice.finish_reason === 'string') {
-            normalizedChoice.finish_reason = map[normalizedChoice.finish_reason] ?? normalizedChoice.finish_reason;
-        }
-        if (isRecord(normalizedChoice.message)) {
-            normalizedChoice.message = normalizeChoiceMessage(normalizedChoice.message);
-        }
-        return normalizedChoice;
-    });
-}
-function normalizeChoiceMessage(message) {
-    const normalizedMessage = { ...message };
-    if (normalizedMessage.content !== undefined && typeof normalizedMessage.content !== 'string') {
-        normalizedMessage.content = normalizeMessageContent(normalizedMessage.content);
-    }
-    if (Array.isArray(normalizedMessage.tool_calls)) {
-        normalizedMessage.tool_calls = normalizeToolCalls(normalizedMessage.tool_calls);
-    }
-    return normalizedMessage;
-}
-function normalizeMessageContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return content.map(item => (typeof item === 'string' ? item : JSON.stringify(item))).join('');
-    }
-    if (isRecord(content)) {
-        return JSON.stringify(content);
-    }
-    return String(content ?? '');
-}
-function normalizeToolCalls(toolCalls) {
-    return toolCalls.map(toolCall => {
-        if (!isRecord(toolCall)) {
-            return toolCall;
-        }
-        const normalizedToolCall = { ...toolCall };
-        const func = normalizedToolCall.function;
-        if (isRecord(func) && func.arguments !== undefined) {
-            func.arguments = normalizeToolArguments(func.arguments);
-            normalizedToolCall.function = func;
-        }
-        return normalizedToolCall;
-    });
-}
-function normalizeToolArguments(args) {
-    let normalized = '';
-    if (typeof args === 'string') {
-        normalized = args;
-    }
-    else {
-        try {
-            normalized = JSON.stringify(args ?? {});
-        }
-        catch {
-            normalized = String(args ?? '');
-        }
-    }
-    const trimmed = normalized.trim();
-    if (!trimmed.length) {
-        return '';
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return trimmed;
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-validate.d.ts

@@ -1,5 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-export interface ResponseValidateConfig {
-    strict?: boolean;
-}
-export declare function validateResponsePayload(payload: JsonObject, _config?: ResponseValidateConfig): void;