@jsonstudio/llms 0.4.2

package/dist/conversion/shared/media.js

@@ -0,0 +1,9 @@
+export function isImagePath(p) {
+    try {
+        const s = String(p || '').toLowerCase();
+        return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/.test(s);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/conversion/shared/openai-finalizer.d.ts

@@ -0,0 +1,9 @@
+type ProcessingMode = 'streaming' | 'non-streaming' | 'auto';
+export interface FinalizeOptions {
+    requestId?: string;
+    endpoint?: string;
+    processingMode?: ProcessingMode;
+    stream?: boolean;
+}
+export declare function finalizeOpenAIChatResponse(chatLike: unknown, opts?: FinalizeOptions): Promise<unknown>;
+export {};

package/dist/conversion/shared/openai-finalizer.js

@@ -0,0 +1,104 @@
+// OpenAI Chat finalizer: enforce canonical shapes without the legacy hook system.
+// - Ensures tool_calls use stringified JSON arguments and sets finish_reason='tool_calls' when applicable
+// - Normalizes potential tool messages (role:'tool') content to strict strings (JSON-stringify for objects)
+function asObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+}
+function stringifyArgs(argVal) {
+    if (typeof argVal === 'string')
+        return argVal;
+    try {
+        return JSON.stringify(argVal ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function toStringContent(val, emptyFallback = 'Command succeeded (no output).') {
+    if (val == null)
+        return emptyFallback;
+    if (typeof val === 'string') {
+        const s = val.trim();
+        return s.length ? s : emptyFallback;
+    }
+    if (Array.isArray(val) || typeof val === 'object') {
+        try {
+            const s = JSON.stringify(val);
+            return s && s.trim().length ? s : emptyFallback;
+        }
+        catch {
+            return emptyFallback;
+        }
+    }
+    try {
+        const s = String(val);
+        return s.trim().length ? s : emptyFallback;
+    }
+    catch {
+        return emptyFallback;
+    }
+}
+export async function finalizeOpenAIChatResponse(chatLike, opts) {
+    const streamingIntent = opts?.stream === true;
+    const obj = asObject(chatLike);
+    if (!obj)
+        return chatLike;
+    try {
+        // Case A: OpenAI Chat completion response ({ id, object, choices[0].message })
+        if ('choices' in obj && Array.isArray(obj.choices)) {
+            const first = obj.choices[0];
+            if (first && typeof first === 'object' && first.message && typeof first.message === 'object') {
+                const msg = first.message;
+                if (Array.isArray(msg.tool_calls)) {
+                    for (const tc of msg.tool_calls) {
+                        try {
+                            const fn = tc?.function || {};
+                            if (fn && typeof fn === 'object') {
+                                fn.arguments = stringifyArgs(fn.arguments);
+                            }
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (first.finish_reason == null)
+                        first.finish_reason = 'tool_calls';
+                }
+            }
+            // nothing more to do for Chat completion response
+        }
+        // Case B: Chat-style messages array ({ messages: [...] })
+        if (Array.isArray(obj.messages)) {
+            const msgs = obj.messages;
+            // Build latest assistant tool_call id->name map
+            const idToName = new Map();
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                const m = msgs[i];
+                if (m && m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+                    for (const tc of m.tool_calls) {
+                        const id = typeof tc?.id === 'string' ? tc.id : undefined;
+                        const nm = typeof tc?.function?.name === 'string' ? tc.function.name : undefined;
+                        if (id && nm)
+                            idToName.set(id, nm);
+                        if (tc?.function)
+                            tc.function.arguments = stringifyArgs(tc.function.arguments);
+                    }
+                    break;
+                }
+            }
+            // Normalize tool role messages: ensure string content + name (if known)
+            for (const m of msgs) {
+                if (!m || typeof m !== 'object')
+                    continue;
+                if (String(m.role || '').toLowerCase() !== 'tool')
+                    continue;
+                const cid = typeof m.tool_call_id === 'string' ? m.tool_call_id : undefined;
+                // add name when available
+                const nm = cid ? idToName.get(cid) : undefined;
+                if (nm && typeof m.name !== 'string')
+                    m.name = nm;
+                m.content = toStringContent(m.content);
+            }
+        }
+    }
+    catch { /* ignore normalization errors */ }
+    return obj;
+}

package/dist/conversion/shared/openai-message-normalize.d.ts

@@ -0,0 +1 @@
+export declare function normalizeChatRequest(request: any): any;

package/dist/conversion/shared/openai-message-normalize.js

@@ -0,0 +1,442 @@
+// Message normalization utilities for OpenAI chat payloads (renamed to avoid confusion
+// with the deprecated "openai-normalizer" module entry). This file contains the
+// previously-implemented logic from openai-normalize.ts.
+// Legacy tooling stage removed for Chat; tool canonicalization lives in codecs
+export function normalizeChatRequest(request) {
+    if (!request || typeof request !== 'object')
+        return request;
+    const normalized = { ...request };
+    if (Array.isArray(normalized.messages)) {
+        normalized.messages = normalized.messages.map((msg) => normalizeMessage(msg));
+    }
+    if (Array.isArray(normalized.tools)) {
+        normalized.tools = normalized.tools.map((tool) => normalizeTool(tool));
+    }
+    // Limit handling: keep structure without truncating tool outputs or adding markers.
+    // - Do not remove messages; avoid truncating tool output content.
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        if (msgs.length) {
+            const asstLimitRaw = process?.env?.RCC_ASSISTANT_TEXT_LIMIT;
+            const ASST_LIMIT = (asstLimitRaw === '0') ? 0 : Math.max(0, Number(asstLimitRaw ?? 8192));
+            const clamp = (s, n) => {
+                try {
+                    const t = String(s);
+                    return (n > 0 && t.length > n) ? (t.slice(0, n) + '...(truncated)') : t;
+                }
+                catch {
+                    return s;
+                }
+            };
+            for (let i = 0; i < msgs.length; i++) {
+                const m = msgs[i];
+                if (!m || typeof m !== 'object')
+                    continue;
+                const role = String(m.role || '').toLowerCase();
+                if (role === 'assistant') {
+                    if (ASST_LIMIT > 0) {
+                        if (typeof m.content === 'string')
+                            m.content = clamp(m.content, ASST_LIMIT);
+                        else if (Array.isArray(m.content)) {
+                            m.content = m.content.map((p) => (p && typeof p.text === 'string') ? { ...p, text: clamp(p.text, ASST_LIMIT) } : p);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch { /* ignore limit errors */ }
+    // MCP 注入（两步法）统一走共享实现，避免路径分叉
+    try {
+        const enableMcp = String(process?.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
+        if (enableMcp) {
+            const known = new Set();
+            try {
+                const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+                for (const m of msgs) {
+                    if (!m || typeof m !== 'object')
+                        continue;
+                    if (m.role === 'tool' && typeof m.content === 'string') {
+                        try {
+                            const obj = JSON.parse(m.content);
+                            const sv = obj?.arguments?.server;
+                            if (typeof sv === 'string' && sv.trim())
+                                known.add(sv.trim());
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+                        for (const tc of m.tool_calls) {
+                            try {
+                                const argStr = String(tc?.function?.arguments ?? '');
+                                const parsed = JSON.parse(argStr);
+                                const sv = parsed?.server;
+                                if (typeof sv === 'string' && sv.trim())
+                                    known.add(sv.trim());
+                            }
+                            catch { /* ignore */ }
+                        }
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            const discovered = Array.from(known);
+            // Dynamic import replaced with require-style to keep function non-async
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const inj = require('./mcp-injection.js');
+            const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
+            normalized.tools = inj.injectMcpToolsForChat(currentTools, discovered);
+        }
+    }
+    catch { /* ignore MCP injection */ }
+    // Normalize assistant.tool_calls arguments (stringify only; do NOT reshape)
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        for (const m of msgs) {
+            if (!m || m.role !== 'assistant' || !Array.isArray(m.tool_calls))
+                continue;
+            m.tool_calls = m.tool_calls.map((tc) => {
+                if (!tc || typeof tc !== 'object')
+                    return tc;
+                const fn = tc.function || {};
+                // Only ensure arguments is a JSON string; do NOT reshape user-provided content
+                if (fn && typeof fn === 'object' && fn.arguments !== undefined && typeof fn.arguments !== 'string') {
+                    try {
+                        fn.arguments = JSON.stringify(fn.arguments);
+                    }
+                    catch {
+                        fn.arguments = '""';
+                    }
+                }
+                return { ...tc, function: fn };
+            });
+        }
+        normalized.messages = msgs;
+    }
+    catch { /* ignore shell fixups */ }
+    // 删除“工具结果嵌回 assistant 文本”的逻辑，避免污染 assistant.content（统一在 role:'tool' 保留结构化结果）
+    // 始终对所有 role:'tool' 的消息做最小文本化（不截断/不添加提示），避免影响模型判断
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        if (msgs.length) {
+            const withTruncationNotice = (text) => {
+                // Do not truncate or annotate; return as-is
+                try {
+                    return String(text ?? '');
+                }
+                catch {
+                    return String(text ?? '');
+                }
+            };
+            const extractPlain = (raw) => {
+                try {
+                    const s = String(raw ?? '');
+                    if (s.trim().length === 0) {
+                        return '执行成功（无输出）';
+                    }
+                    let obj = null;
+                    try {
+                        obj = JSON.parse(s);
+                    }
+                    catch {
+                        obj = null;
+                    }
+                    return withTruncationNotice(s);
+                }
+                catch {
+                    return String(raw ?? '');
+                }
+            };
+            for (const m of msgs) {
+                if (!m || typeof m !== 'object')
+                    continue;
+                if (String(m.role || '').toLowerCase() !== 'tool')
+                    continue;
+                const c = m.content;
+                if (typeof c === 'string') {
+                    m.content = extractPlain(c);
+                }
+                else if (c && typeof c === 'object') {
+                    try {
+                        m.content = String(JSON.stringify(c));
+                    }
+                    catch {
+                        m.content = String(c);
+                    }
+                }
+                else if (c != null) {
+                    m.content = withTruncationNotice(String(c));
+                }
+                else {
+                    m.content = '执行成功（无输出）';
+                }
+            }
+            normalized.messages = msgs;
+        }
+    }
+    catch { /* ignore tool message sanitization errors */ }
+    // 对所有工具结果做最小文本化（不裁剪）；同时对“最后一轮”做一致化处理。
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        const withTruncationNotice = (text) => {
+            // No truncation / annotation; pass-through
+            try {
+                return typeof text === 'string' ? text : String(text ?? '');
+            }
+            catch {
+                return String(text ?? '');
+            }
+        };
+        const extractPlain = (raw) => {
+            try {
+                const s = String(raw ?? '');
+                if (s.trim().length === 0) {
+                    return '执行成功（无输出）';
+                }
+                let obj = null;
+                try {
+                    obj = JSON.parse(s);
+                }
+                catch {
+                    obj = null;
+                }
+                return withTruncationNotice(s);
+            }
+            catch {
+                return String(raw ?? '');
+            }
+        };
+        // 先对所有历史 tool 消息统一最小化+截断
+        for (const m of msgs) {
+            if (!m || typeof m !== 'object')
+                continue;
+            if (String(m.role || '').toLowerCase() !== 'tool')
+                continue;
+            const c = m.content;
+            if (typeof c === 'string') {
+                m.content = extractPlain(c);
+            }
+            else if (c && typeof c === 'object') {
+                try {
+                    m.content = String(JSON.stringify(c));
+                }
+                catch {
+                    m.content = String(c);
+                }
+            }
+            else if (c != null) {
+                m.content = withTruncationNotice(String(c));
+            }
+            else {
+                m.content = '执行成功（无输出）';
+            }
+        }
+        const lastAssistantIdx = (() => {
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                const m = msgs[i];
+                if (m && m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length)
+                    return i;
+            }
+            return -1;
+        })();
+        if (lastAssistantIdx >= 0) {
+            const callIds = new Set();
+            try {
+                for (const tc of msgs[lastAssistantIdx].tool_calls) {
+                    const id = typeof tc?.id === 'string' ? tc.id : undefined;
+                    if (id)
+                        callIds.add(id);
+                }
+            }
+            catch { /* ignore */ }
+            for (let i = lastAssistantIdx + 1; i < msgs.length; i++) {
+                const m = msgs[i];
+                if (!m || m.role !== 'tool')
+                    continue;
+                const cid = typeof m.tool_call_id === 'string' ? m.tool_call_id : undefined;
+                if (!cid || !callIds.has(cid))
+                    continue;
+                const plain = extractPlain(m.content);
+                m.content = withTruncationNotice(plain);
+            }
+        }
+    }
+    catch { /* ignore sanitize errors */ }
+    // 删除“无 tool_calls 且内容为空/仅空白”的 assistant 回合（降噪，避免部分上游对空 turn 敏感）
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        const isEmptyContent = (c) => {
+            if (c === null || c === undefined)
+                return true;
+            if (typeof c === 'string')
+                return c.trim().length === 0;
+            if (Array.isArray(c)) {
+                const txt = c.map((p) => (p && typeof p.text === 'string') ? p.text : '').filter(Boolean).join('').trim();
+                return txt.length === 0;
+            }
+            return false;
+        };
+        const filtered = msgs.filter((m) => {
+            if (!m || m.role !== 'assistant')
+                return true;
+            const hasTools = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+            if (hasTools)
+                return true;
+            return !isEmptyContent(m.content);
+        });
+        normalized.messages = filtered;
+    }
+    catch { /* ignore */ }
+    // 注意：不合并/删除多条 system（与 统一标准，避免高风险修改）。
+    // 基于“载荷预算”（配置驱动）进行分层裁剪，避免整体载荷超限导致上游 500。
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        if (msgs.length) {
+            const modelId = String(normalized?.model || '').trim();
+            const budget = resolveBudgetForModelSync(modelId);
+            const allowed = Math.max(32 * 1024, Math.floor(budget.allowedBytes)); // 最低 32KB
+            const sizeBytes = (obj) => { try {
+                return Buffer.byteLength(JSON.stringify(obj), 'utf8');
+            }
+            catch {
+                return 0;
+            } };
+            let total = sizeBytes(normalized.messages);
+            if (total > allowed) {
+                // 分层裁剪：最近 3 条工具消息额度更大，其余更严格；若仍超限，再统一降到最小额度。
+                const toolIdx = [];
+                for (let i = 0; i < msgs.length; i++) {
+                    const m = msgs[i];
+                    if (m && m.role === 'tool' && typeof m.content === 'string')
+                        toolIdx.push(i);
+                }
+                if (toolIdx.length) {
+                    // Disable shrinking/truncation of tool outputs to avoid altering content
+                    const shrinkTo = (_idx, _limit) => { };
+                    const recentLimitChars = Number(process?.env?.RCC_TOOL_TEXT_RECENT || 1024);
+                    const olderLimitChars = Number(process?.env?.RCC_TOOL_TEXT_OLDER || 256);
+                    const minimalLimitChars = Number(process?.env?.RCC_TOOL_TEXT_MIN || 128);
+                    const recent = toolIdx.slice(-3);
+                    const older = toolIdx.slice(0, Math.max(0, toolIdx.length - recent.length));
+                    // No-op shrink to keep content intact
+                    for (const i of older)
+                        shrinkTo(i, olderLimitChars);
+                    for (const i of recent)
+                        shrinkTo(i, recentLimitChars);
+                    total = sizeBytes(normalized.messages);
+                    if (total > allowed) {
+                        for (const i of toolIdx)
+                            shrinkTo(i, minimalLimitChars);
+                    }
+                }
+            }
+        }
+    }
+    catch { /* ignore budget enforcement */ }
+    // Do not invoke legacy tooling stage here; codecs perform canonicalization
+    return normalized;
+}
+function normalizeChatResponse(res) {
+    // Deprecated: pass-through. Tool canonicalization and reasoning handling are done in codecs/compat layers.
+    return res;
+    if (false) {
+        // legacy kept for reference
+    }
+}
+function normalizeMessage(message) {
+    if (!message || typeof message !== 'object')
+        return message;
+    const normalizedMessage = { ...message };
+    // 保持 null/undefined 为原样，避免将其强制为 ''。
+    // 多数 OpenAI 兼容实现允许 assistant 在包含 tool_calls 时使用 content=null。
+    if (normalizedMessage.content === undefined || normalizedMessage.content === null) {
+        // do not coerce to empty string
+    }
+    else if (typeof normalizedMessage.content === 'string') {
+        // keep as-is
+    }
+    else if (Array.isArray(normalizedMessage.content)) {
+        // keep structured array
+    }
+    else if (typeof normalizedMessage.content === 'object') {
+        // keep structured object
+    }
+    else {
+        normalizedMessage.content = String(normalizedMessage.content);
+    }
+    if (normalizedMessage.role === 'assistant' && Array.isArray(normalizedMessage.tool_calls)) {
+        normalizedMessage.tool_calls = normalizedMessage.tool_calls.map((toolCall) => normalizeToolCall(toolCall));
+    }
+    return normalizedMessage;
+}
+function normalizeTool(tool) {
+    if (!tool || typeof tool !== 'object')
+        return tool;
+    const normalizedTool = { ...tool };
+    if (normalizedTool.type === 'function' && normalizedTool.function) {
+        const fn = { ...normalizedTool.function };
+        if (fn.parameters && typeof fn.parameters !== 'object') {
+            try {
+                fn.parameters = JSON.parse(String(fn.parameters));
+            }
+            catch {
+                fn.parameters = {};
+            }
+        }
+        normalizedTool.function = fn;
+    }
+    return normalizedTool;
+}
+function normalizeToolCall(tc) {
+    if (!tc || typeof tc !== 'object')
+        return tc;
+    const t = { ...tc };
+    if (t.function && typeof t.function === 'object') {
+        const fn = { ...t.function };
+        const argStrIn = typeof fn.arguments === 'string' ? fn.arguments : (fn.arguments != null ? JSON.stringify(fn.arguments) : '{}');
+        let argsObj = {};
+        try {
+            argsObj = JSON.parse(argStrIn);
+        }
+        catch {
+            argsObj = {};
+        }
+        // Drop dotted-name prefix unconditionally; keep only base function name
+        if (typeof fn.name === 'string' && fn.name.includes('.')) {
+            const dot = fn.name.indexOf('.');
+            fn.name = fn.name.slice(dot + 1).trim();
+        }
+        // Shell command coercion (can be disabled via env)
+        const disableShellCoerce = String(process?.env?.RCC_DISABLE_SHELL_COERCE ?? process?.env?.ROUTECODEX_DISABLE_SHELL_COERCE ?? '').toLowerCase();
+        const isDisabled = disableShellCoerce === '1' || disableShellCoerce === 'true';
+        if (!isDisabled && String(fn.name || '').toLowerCase() === 'shell') {
+            const cmdVal = argsObj?.command;
+            if (typeof cmdVal === 'string' && cmdVal.trim().length > 0) {
+                const s = cmdVal.trim();
+                const hasMeta = /[<>|;&]/.test(s) || s.includes('&&') || s.includes('||') || s.includes('<<');
+                if (hasMeta) {
+                    argsObj.command = ['bash', '-lc', s];
+                }
+                else {
+                    argsObj.command = splitCommandString(s);
+                }
+            }
+            else if (Array.isArray(cmdVal)) {
+                const toks = cmdVal.map((x) => String(x));
+                if (toks.length > 3 && toks[0] === 'bash' && toks[1] === '-lc') {
+                    argsObj.command = ['bash', '-lc', toks.slice(2).join(' ')];
+                }
+            }
+        }
+        try {
+            fn.arguments = JSON.stringify(argsObj);
+        }
+        catch {
+            fn.arguments = argStrIn;
+        }
+        t.function = fn;
+    }
+    return t;
+}
+import { splitCommandString } from './tooling.js';
+import { resolveBudgetForModelSync } from './payload-budget.js';

package/dist/conversion/shared/payload-budget.d.ts

@@ -0,0 +1,13 @@
+export declare function resolveBudgetForModelSync(modelId: string): {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+};
+export declare const resolveBudgetForModel: (modelId: string) => Promise<{
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}>;
+export declare function enforceChatBudget(chat: any, modelId: string): any;