@jsonstudio/rcc 0.89.168 → 0.89.524

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

@@ -0,0 +1,209 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,121 @@
+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

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

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

@@ -0,0 +1,76 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export function validateResponsePayload(payload, _config) {
+    const errors = [];
+    if (!payload.id || typeof payload.id !== 'string') {
+        errors.push('响应缺少有效的id字段');
+    }
+    if (!payload.created || typeof payload.created !== 'number') {
+        errors.push('响应缺少有效的created字段');
+    }
+    if (!payload.model || typeof payload.model !== 'string') {
+        errors.push('响应缺少有效的model字段');
+    }
+    if (!Array.isArray(payload.choices) || payload.choices.length === 0) {
+        errors.push('choices数组不能为空');
+    }
+    else {
+        payload.choices.forEach((choice, idx) => {
+            if (!isRecord(choice)) {
+                errors.push(`choices[${idx}]必须是对象`);
+                return;
+            }
+            if (!choice.message || typeof choice.message !== 'object') {
+                errors.push(`choices[${idx}].message字段必须是对象`);
+            }
+            else if (Array.isArray(choice.message.tool_calls)) {
+                choice.message.tool_calls.forEach((toolCall, tIdx) => {
+                    if (!isRecord(toolCall)) {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}]必须是对象`);
+                        return;
+                    }
+                    if (!toolCall.function || typeof toolCall.function !== 'object') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function字段必须是对象`);
+                        return;
+                    }
+                    const fn = toolCall.function;
+                    if (typeof fn.name !== 'string') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.name字段必须是字符串`);
+                    }
+                    if (typeof fn.arguments !== 'string') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments字段必须是字符串`);
+                    }
+                    else {
+                        try {
+                            JSON.parse(fn.arguments);
+                        }
+                        catch {
+                            errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments必须是有效JSON`);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    if (payload.usage && typeof payload.usage === 'object') {
+        const usage = payload.usage;
+        const promptTokens = usage.prompt_tokens;
+        const completionTokens = usage.completion_tokens;
+        const totalTokens = usage.total_tokens;
+        if (!isNonNegativeNumber(promptTokens) ||
+            !isNonNegativeNumber(completionTokens) ||
+            !isNonNegativeNumber(totalTokens)) {
+            errors.push('usage字段的token必须是非负数');
+        }
+        else if (promptTokens + completionTokens !== totalTokens) {
+            errors.push('usage.total_tokens 应等于 prompt_tokens 与 completion_tokens 之和');
+        }
+    }
+    if (errors.length) {
+        const error = new Error(`GLM响应校验失败:\n${errors.join('\n')}`);
+        error.code = 'compat_response_validation_failed';
+        throw error;
+    }
+}
+function isNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}

package/{dist/providers/compat/utils/snapshot-writer.d.ts → node_modules/@jsonstudio/llms/dist/conversion/compat/actions/snapshot.d.ts}

@@ -1,8 +1,8 @@
 type Phase = 'compat-pre' | 'compat-post';
 export declare function writeCompatSnapshot(options: {
     phase: Phase;
-    requestId: string;
-    data: unknown;
+    requestId?: string;
     entryEndpoint?: string;
+    data: unknown;
 }): Promise<void>;
 export {};

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/snapshot.js

@@ -0,0 +1,21 @@
+import { writeSnapshotViaHooks } from '../../shared/snapshot-hooks.js';
+const SNAPSHOT_FLAG = String(process.env.ROUTECODEX_SNAPSHOT ?? '').toLowerCase();
+const SNAPSHOT_ENABLED = SNAPSHOT_FLAG === '1' || SNAPSHOT_FLAG === 'true';
+export async function writeCompatSnapshot(options) {
+    if (!SNAPSHOT_ENABLED) {
+        return;
+    }
+    try {
+        const endpoint = options.entryEndpoint || '/v1/chat/completions';
+        await writeSnapshotViaHooks({
+            endpoint,
+            stage: options.phase,
+            requestId: options.requestId || 'unknown',
+            data: options.data,
+            verbosity: 'verbose'
+        });
+    }
+    catch {
+        // snapshots are best-effort
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/tool-schema.d.ts

@@ -0,0 +1,6 @@
+import type { JsonObject } from '../../hub/types/json.js';
+type UnknownRecord = Record<string, unknown>;
+export declare const sanitizeGLMToolsSchema: (data: UnknownRecord) => UnknownRecord;
+export declare const sanitizeGLMToolsSchemaInPlace: (data: UnknownRecord) => void;
+export declare function sanitizeToolSchema(payload: JsonObject, mode?: 'glm_shell'): JsonObject;
+export {};

package/{dist/providers/compat/glm/utils/tool-schema-helpers.js → node_modules/@jsonstudio/llms/dist/conversion/compat/actions/tool-schema.js}

@@ -83,4 +83,9 @@ export const sanitizeGLMToolsSchemaInPlace = (data) => {
     const sanitized = sanitizeGLMToolsSchema(data);
     data.tools = sanitized.tools;
 };
-//# sourceMappingURL=tool-schema-helpers.js.map
+export function sanitizeToolSchema(payload, mode = 'glm_shell') {
+    if (mode === 'glm_shell') {
+        return sanitizeGLMToolsSchema(payload);
+    }
+    return payload;
+}