@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/glm-tool-extraction.js

@@ -0,0 +1,264 @@
+function flattenContent(content, depth = 0) {
+    if (depth > 4 || content == null) {
+        return '';
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content.map((entry) => flattenContent(entry, depth + 1)).join('');
+    }
+    if (typeof content === 'object') {
+        const record = content;
+        if (typeof record.text === 'string') {
+            return record.text;
+        }
+        if (record.content !== undefined) {
+            return flattenContent(record.content, depth + 1);
+        }
+    }
+    return '';
+}
+const GLM_CUSTOM_TAG = /<tool_call(?:\s+name="([^"]+)")?>([\s\S]*?)<\/tool_call>/gi;
+const GLM_TAGGED_SEQUENCE = /<tool_call(?:\s+name="([^"]+)")?\s*>([\s\S]*?)(?:<\/tool_call>|(?=<tool_call)|$)/gi;
+const GLM_TAGGED_BLOCK = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/gi;
+const GLM_INLINE_NAME = /^[\s\r\n]*([A-Za-z0-9_.:-]+)/;
+const GENERIC_PATTERNS = [
+    [
+        /```(?:tool|function|tool_call|function_call)?\s*([\s\S]*?)\s*```/gi,
+        (match) => ({ body: match[1] ?? '' })
+    ],
+    [
+        /\[(tool_call|function_call)(?:\s+name="([^"]+)")?\]([\s\S]*?)\[\/\1\]/gi,
+        (match) => ({ body: match[3] ?? '', nameHint: match[2] })
+    ],
+    [
+        /(tool_call|function_call)\s*[:=]\s*({[\s\S]+?})/gi,
+        (match) => ({ body: match[2] ?? '' })
+    ]
+];
+export function extractGlmToolMarkup(root) {
+    const choicesRaw = root?.choices;
+    const choices = Array.isArray(choicesRaw) ? choicesRaw : [];
+    choices.forEach((choice, index) => {
+        if (!choice || typeof choice !== 'object') {
+            return;
+        }
+        const message = choice.message;
+        if (!message || typeof message !== 'object') {
+            return;
+        }
+        const msgRecord = message;
+        const contentField = msgRecord.content;
+        const reasoningField = msgRecord.reasoning_content;
+        const text = contentField !== undefined
+            ? flattenContent(contentField)
+            : typeof reasoningField === 'string'
+                ? reasoningField
+                : '';
+        if (!text) {
+            return;
+        }
+        const extraction = extractToolCallsFromText(text, index + 1);
+        if (!extraction) {
+            return;
+        }
+        if (extraction.toolCalls.length) {
+            msgRecord.tool_calls = extraction.toolCalls;
+            if (contentField !== undefined) {
+                msgRecord.content = null;
+            }
+        }
+        if (extraction.reasoningText) {
+            msgRecord.reasoning_content = extraction.reasoningText;
+        }
+        else if ('reasoning_content' in msgRecord) {
+            delete msgRecord.reasoning_content;
+        }
+    });
+}
+function extractToolCallsFromText(text, choiceIndex) {
+    const matches = [];
+    const applyPattern = (pattern, factory) => {
+        pattern.lastIndex = 0;
+        let exec;
+        while ((exec = pattern.exec(text))) {
+            const payload = factory(exec);
+            if (!payload)
+                continue;
+            const parsed = parseToolCall(payload.body, payload.nameHint);
+            if (!parsed)
+                continue;
+            matches.push({
+                start: exec.index,
+                end: exec.index + exec[0].length,
+                call: parsed
+            });
+        }
+    };
+    applyPattern(GLM_CUSTOM_TAG, (match) => ({ body: match[2] ?? '', nameHint: match[1] }));
+    for (const [pattern, factory] of GENERIC_PATTERNS) {
+        applyPattern(pattern, factory);
+    }
+    applyTaggedArgPatterns(text, matches);
+    if (!matches.length && typeof text === 'string' && text.includes('<arg_key>')) {
+        GLM_INLINE_NAME.lastIndex = 0;
+        const inline = GLM_INLINE_NAME.exec(text);
+        GLM_INLINE_NAME.lastIndex = 0;
+        if (inline && inline[1]) {
+            const name = inline[1].trim();
+            const block = text.slice(inline[0].length);
+            const argsRecord = parseTaggedArgBlock(block);
+            if (name && argsRecord) {
+                matches.push({
+                    start: 0,
+                    end: text.length,
+                    call: {
+                        name,
+                        args: safeStringify(argsRecord)
+                    }
+                });
+            }
+        }
+    }
+    matches.sort((a, b) => a.start - b.start);
+    const toolCalls = matches.map((entry, idx) => ({
+        id: `glm_tool_${choiceIndex}_${idx + 1}`,
+        type: 'function',
+        function: {
+            name: entry.call.name,
+            arguments: entry.call.args
+        }
+    }));
+    matches.sort((a, b) => b.start - a.start);
+    let cleaned = text;
+    for (const entry of matches) {
+        cleaned = cleaned.slice(0, entry.start) + cleaned.slice(entry.end);
+    }
+    const reasoningText = cleaned.trim();
+    return {
+        toolCalls,
+        reasoningText: reasoningText.length ? reasoningText : undefined
+    };
+}
+function parseToolCall(body, nameHint) {
+    if (!body || typeof body !== 'string') {
+        return null;
+    }
+    const trimmed = body.trim();
+    if (!trimmed.length) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const record = parsed;
+        const candidateName = (typeof record.name === 'string' && record.name.trim().length
+            ? record.name.trim()
+            : undefined) ??
+            (typeof record.tool_name === 'string' && record.tool_name.trim().length
+                ? record.tool_name.trim()
+                : undefined) ??
+            (typeof record.tool === 'string' && record.tool.trim().length
+                ? record.tool.trim()
+                : undefined) ??
+            (nameHint && nameHint.trim().length ? nameHint.trim() : undefined);
+        if (!candidateName) {
+            return null;
+        }
+        const argsSource = record.arguments ??
+            record.input ??
+            record.params ??
+            record.parameters ??
+            record.payload ??
+            {};
+        let args = '{}';
+        if (typeof argsSource === 'string' && argsSource.trim().length) {
+            args = argsSource.trim();
+        }
+        else {
+            try {
+                args = JSON.stringify(argsSource ?? {});
+            }
+            catch {
+                args = '{}';
+            }
+        }
+        return { name: candidateName, args };
+    }
+    catch {
+        return null;
+    }
+}
+function applyTaggedArgPatterns(text, matches) {
+    if (!text || typeof text !== 'string') {
+        return;
+    }
+    GLM_TAGGED_SEQUENCE.lastIndex = 0;
+    let exec;
+    while ((exec = GLM_TAGGED_SEQUENCE.exec(text))) {
+        let name = typeof exec[1] === 'string' ? exec[1].trim() : '';
+        let block = exec[2] ?? '';
+        if (!name) {
+            const inline = GLM_INLINE_NAME.exec(block);
+            if (inline && inline[1]) {
+                name = inline[1].trim();
+                block = block.slice(inline[0].length);
+            }
+        }
+        if (!name) {
+            continue;
+        }
+        const argsRecord = parseTaggedArgBlock(block);
+        if (!argsRecord) {
+            continue;
+        }
+        matches.push({
+            start: exec.index,
+            end: exec.index + exec[0].length,
+            call: {
+                name,
+                args: safeStringify(argsRecord)
+            }
+        });
+    }
+}
+function parseTaggedArgBlock(block) {
+    if (!block || typeof block !== 'string') {
+        return null;
+    }
+    const record = {};
+    GLM_TAGGED_BLOCK.lastIndex = 0;
+    let exec;
+    while ((exec = GLM_TAGGED_BLOCK.exec(block))) {
+        const key = typeof exec[1] === 'string' ? exec[1].trim() : '';
+        if (!key) {
+            continue;
+        }
+        const rawValue = typeof exec[2] === 'string' ? exec[2].trim() : '';
+        record[key] = coerceTaggedValue(rawValue);
+    }
+    return Object.keys(record).length ? record : null;
+}
+function coerceTaggedValue(raw) {
+    if (!raw) {
+        return '';
+    }
+    const trimmed = raw.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/glm-vision-prompt.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject } from '../../hub/types/json.js';
+/**
+ * GLM 4.6V 专用视觉提示裁剪：
+ * - 仅在 model 为 glm-4.6v 且存在携带图片的 user 消息时生效；
+ * - 丢弃原有 system 与历史对话，只保留一条新的 system + 一条 user；
+ * - system：要求模型以结构化 JSON 描述截图内容、标记（圈/箭头等）及其大致 bbox；
+ * - user：保留原始用户文字（如果有）+ 单一 image_url 块。
+ *
+ * 其他模型（包括 glm-4.7、Gemini 等）不受影响。
+ */
+export declare function applyGlmVisionPromptTransform(payload: JsonObject): JsonObject;

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/glm-vision-prompt.js

@@ -0,0 +1,177 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function extractImageUrlFromPart(part) {
+    const imageUrlBlock = isRecord(part.image_url)
+        ? part.image_url
+        : undefined;
+    let url;
+    if (imageUrlBlock && typeof imageUrlBlock.url === 'string') {
+        url = imageUrlBlock.url;
+    }
+    else if (typeof part.image_url === 'string') {
+        url = part.image_url;
+    }
+    else if (typeof part.url === 'string') {
+        url = part.url;
+    }
+    else if (typeof part.uri === 'string') {
+        url = part.uri;
+    }
+    else if (typeof part.data === 'string') {
+        url = part.data;
+    }
+    const trimmed = (url ?? '').trim();
+    return trimmed.length ? trimmed : null;
+}
+function collectUserTextFromMessage(msg) {
+    const content = msg.content;
+    if (!Array.isArray(content)) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return '';
+    }
+    const parts = [];
+    for (const entry of content) {
+        if (!isRecord(entry))
+            continue;
+        const text = entry.text;
+        if (typeof text === 'string' && text.trim().length) {
+            parts.push(text.trim());
+        }
+    }
+    return parts.join('\n');
+}
+/**
+ * GLM 4.6V 专用视觉提示裁剪：
+ * - 仅在 model 为 glm-4.6v 且存在携带图片的 user 消息时生效；
+ * - 丢弃原有 system 与历史对话，只保留一条新的 system + 一条 user；
+ * - system：要求模型以结构化 JSON 描述截图内容、标记（圈/箭头等）及其大致 bbox；
+ * - user：保留原始用户文字（如果有）+ 单一 image_url 块。
+ *
+ * 其他模型（包括 glm-4.7、Gemini 等）不受影响。
+ */
+export function applyGlmVisionPromptTransform(payload) {
+    const root = structuredClone(payload);
+    const modelRaw = root.model;
+    const model = typeof modelRaw === 'string' ? modelRaw.trim() : '';
+    if (!model.startsWith('glm-4.6v')) {
+        return root;
+    }
+    const messagesValue = root.messages;
+    if (!Array.isArray(messagesValue)) {
+        return root;
+    }
+    const messages = messagesValue.filter((msg) => isRecord(msg));
+    if (!messages.length) {
+        return root;
+    }
+    // 从末尾开始查找最近一条带图片的 user 消息。
+    let latestUserWithImage = null;
+    let imageUrl = null;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        const role = typeof msg.role === 'string' ? msg.role.toLowerCase() : '';
+        if (role !== 'user') {
+            continue;
+        }
+        const content = msg.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        for (const part of content) {
+            if (!isRecord(part))
+                continue;
+            const typeValue = typeof part.type === 'string' ? part.type.toLowerCase() : '';
+            if (typeValue === 'image' || typeValue === 'image_url' || typeValue === 'input_image') {
+                const candidateUrl = extractImageUrlFromPart(part);
+                if (candidateUrl) {
+                    latestUserWithImage = msg;
+                    imageUrl = candidateUrl;
+                    break;
+                }
+            }
+        }
+        if (latestUserWithImage && imageUrl) {
+            break;
+        }
+    }
+    if (!latestUserWithImage || !imageUrl) {
+        return root;
+    }
+    const systemContent = '你是 Codex 的截图理解子系统，专门用于分析 UI 截图和网页图片。请仅根据用户提供的图片，输出一个结构化的 JSON，用于后续自动化处理，不要输出额外解释性文字或自然语言说明。\n' +
+        '\n' +
+        '输出必须是**单个合法 JSON 对象**，不要包含 Markdown、代码块标记或多余文本。请严格遵循下面的结构（字段可以为空数组，但必须存在）：\n' +
+        '{\n' +
+        '  "summary": "用 1-3 句整体描述这张图片（例如页面类型、主要区域、核心信息）",\n' +
+        '  "marks": [\n' +
+        '    {\n' +
+        '      "type": "circle | arrow | underline | box | other",\n' +
+        '      "color": "red | green | blue | yellow | other",\n' +
+        '      "bbox": [x, y, width, height],\n' +
+        '      "description": "该标记所圈出/指向/强调的内容，包含相关文字或 UI 元素描述"\n' +
+        '    }\n' +
+        '  ],\n' +
+        '  "regions": [\n' +
+        '    {\n' +
+        '      "bbox": [x, y, width, height],\n' +
+        '      "description": "该区域的可见内容（控件/图标/布局，以及其中出现的所有清晰可辨的文字）",\n' +
+        '      "is_marked": true | false\n' +
+        '    }\n' +
+        '  ],\n' +
+        '  "metadata": {\n' +
+        '    "image_size_hint": "如果能推断出大致分辨率，请给出类似 1920x1080 的字符串；无法判断时用 null",\n' +
+        '    "screenshot": true\n' +
+        '  }\n' +
+        '}\n' +
+        '\n' +
+        '细则：\n' +
+        '1. 文字提取要求：\n' +
+        '   - 如果图片中存在清晰可辨的文字（包括标题、菜单、按钮、标签、提示信息、弹窗、错误信息等），必须在对应的 regions.description 中**完整抄写**这些文字，按自然阅读顺序组织，避免遗漏。\n' +
+        '   - 如果有多行文字，可以用换行符分隔，但仍放在同一个 description 字段中。\n' +
+        '   - 对确实无法看清的文字，用类似 "（模糊，无法辨认）" 标注即可；没有任何文字也视为正常情况，此时只需描述界面结构。\n' +
+        '2. 标记识别（marks）：\n' +
+        '   - 对所有明显的圈选、箭头、下划线、高亮框等标记，必须在 marks 中列出，每一项提供大致 bbox、颜色和简短说明，说明其强调或指向的内容。\n' +
+        '3. 区域划分（regions）：\n' +
+        '   - 将截图拆分为若干有意义的区域：如导航栏、侧边栏、主内容区、弹窗、对话框、表格、代码块、表单等。\n' +
+        '   - 每个区域的 description 中，既要描述布局/控件类型，也要包含该区域内的全部清晰文字内容。\n' +
+        '   - is_marked 为 true 表示该区域与某个标记（marks）相关或被标记强调。\n' +
+        '4. 坐标规范：所有 bbox 使用相对于当前图片的像素坐标，左上角为 (0,0)，width/height 为正数近似值。\n' +
+        '5. 无论图片内容如何，最终回答必须是合法 JSON，不能在 JSON 前后添加任何额外文本。';
+    const systemMessage = {
+        role: 'system',
+        content: systemContent
+    };
+    const originalUserText = collectUserTextFromMessage(latestUserWithImage);
+    const userBlocks = [];
+    if (originalUserText && originalUserText.trim().length) {
+        userBlocks.push({
+            type: 'text',
+            text: originalUserText.trim()
+        });
+    }
+    else {
+        userBlocks.push({
+            type: 'text',
+            text: '请按照上面的 JSON 结构，详细描述这张图片的内容和标记。'
+        });
+    }
+    userBlocks.push({
+        type: 'image_url',
+        image_url: {
+            url: imageUrl
+        }
+    });
+    const userMessage = {
+        role: 'user',
+        content: userBlocks
+    };
+    // 丢弃原有 messages，仅保留新的 system + user。
+    root.messages = [systemMessage, userMessage];
+    // 对于专用视觉模型，限制 max_tokens，避免过大的 completion 预算进一步触发上下文相关错误。
+    const maxTokensValue = root.max_tokens;
+    if (typeof maxTokensValue === 'number' && Number.isFinite(maxTokensValue)) {
+        // 将超大值收敛到一个相对安全的上限；真实上限由上游再校验。
+        root.max_tokens = Math.min(maxTokensValue, 4096);
+    }
+    return root;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/glm-web-search.d.ts

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

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

@@ -0,0 +1,63 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const DEBUG_GLM_WEB_SEARCH = (process.env.ROUTECODEX_DEBUG_GLM_WEB_SEARCH || '').trim() === '1';
+export function applyGlmWebSearchRequestTransform(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 webSearchConfig = {
+        // 按 GLM 文档要求：search_engine 为必填，默认使用 search_std。
+        search_engine: 'search_std',
+        enable: true,
+        search_query: query,
+        // 返回搜索结果详情，便于我们在响应中提取摘要或调试。
+        search_result: true
+    };
+    if (recency) {
+        webSearchConfig.search_recency_filter = recency;
+    }
+    if (typeof count === 'number') {
+        webSearchConfig.count = count;
+    }
+    // 根据 OpenAPI：tools.anyOf[*] = WebSearchToolSchema[]，即一次只能选择一种工具类型。
+    // 在 web_search 路由下，我们只保留 WebSearchToolSchema，丢弃其它 function/retrieval/MCP 工具，
+    // 避免混用导致后端忽略 web_search 配置。
+    const baseTool = {
+        type: 'web_search',
+        web_search: webSearchConfig
+    };
+    root.tools = [baseTool];
+    delete root.web_search;
+    if (DEBUG_GLM_WEB_SEARCH) {
+        try {
+            // eslint-disable-next-line no-console
+            console.log('\x1b[38;5;27m[compat][glm_web_search_request] applied web_search transform ' +
+                `search_engine=${String(baseTool?.web_search?.search_engine ?? 'search_std')} ` +
+                `query=${JSON.stringify(query).slice(0, 200)} ` +
+                `count=${String(count ?? '')}\x1b[0m`);
+        }
+        catch {
+            // logging best-effort
+        }
+    }
+    return root;
+}

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

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