@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/conversion/shared/text-markup-normalizer/extractors-xml.js

@@ -0,0 +1,602 @@
+import { isImagePath } from '../media.js';
+import { KNOWN_TOOLS, coerceCommandValueToString, filterArgsForTool, genToolCallId, normalizeKey, readDefaultWorkdirFromEnv, tryParseJsonValue, tryParsePrimitiveValue } from './extractors-shared.js';
+function applyToolInnerField(lname, argsObj, rawKey, rawValInput) {
+    const key = normalizeKey(rawKey).toLowerCase();
+    if (!key || key === 'requires_approval') {
+        return;
+    }
+    const rawVal = String(rawValInput ?? '');
+    const value = tryParsePrimitiveValue(rawVal);
+    if (lname === 'exec_command' && (key === 'command' || key === 'cmd')) {
+        const cmd = coerceCommandValueToString(value);
+        if (cmd.trim().length) {
+            argsObj.cmd = cmd;
+            argsObj.command = cmd;
+        }
+        return;
+    }
+    if (lname === 'exec_command' && (key === 'cwd' || key === 'workdir')) {
+        const wd = String(value ?? rawVal).trim();
+        if (wd)
+            argsObj.workdir = wd;
+        return;
+    }
+    if (lname === 'write_stdin') {
+        if (key === 'input' || key === 'data' || key === 'chars' || key === 'text') {
+            argsObj.chars = rawVal;
+            return;
+        }
+        if (key === 'session_id') {
+            const n = Number.parseInt(String(value), 10);
+            argsObj.session_id = Number.isFinite(n) ? n : value;
+            return;
+        }
+    }
+    if (lname === 'apply_patch' && (key === 'patch' || key === 'input' || key === 'text' || key === 'instructions')) {
+        const patchText = typeof value === 'string' ? value : rawVal;
+        if (typeof patchText === 'string' && patchText.trim().length) {
+            argsObj.patch = patchText;
+        }
+        return;
+    }
+    argsObj[key] = value;
+}
+// Extract <tool:NAME>...</tool:NAME> blocks used by some tool-mode outputs.
+export function extractToolNamespaceXmlBlocksFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const hasOpenTag = text.includes('<tool:');
+        const hasCloseTag = /<\/\s*tool:\s*[A-Za-z0-9_]+\s*>/i.test(text);
+        const hasToolPrefix = /(?:^|\n)\s*(?:[•*+-]\s*)?tool:[A-Za-z0-9_]+/i.test(text);
+        if (!hasOpenTag && !(hasCloseTag && hasToolPrefix)) {
+            return null;
+        }
+        const out = [];
+        const blockRe = /<\s*tool:([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*tool:\s*\1\s*>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const rawName = String(bm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || !KNOWN_TOOLS.has(lname))
+                continue;
+            const inner = String(bm[2] || '');
+            const argsObj = {};
+            const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+            let km;
+            while ((km = kvRe.exec(inner)) !== null) {
+                const rawKey = String(km[1] || '').trim();
+                const rawVal = String(km[2] ?? '');
+                applyToolInnerField(lname, argsObj, rawKey, rawVal);
+            }
+            // Tolerate malformed parameter blocks like:
+            // <parameter name="command">...</command>
+            // and the normal form:
+            // <parameter name="command">...</parameter>
+            const paramRe = /<\s*parameter\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*(?:parameter|\1)\s*>/gi;
+            let pm;
+            while ((pm = paramRe.exec(inner)) !== null) {
+                const rawKey = String(pm[1] || '').trim();
+                const rawVal = String(pm[2] ?? '');
+                applyToolInnerField(lname, argsObj, rawKey, rawVal);
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (lname === 'exec_command') {
+                const cmd = typeof filtered?.cmd === 'string' ? String(filtered.cmd).trim() : '';
+                if (!cmd)
+                    continue;
+            }
+            if (lname === 'write_stdin') {
+                const sid = filtered?.session_id;
+                if (sid === undefined || sid === null || String(sid).trim().length === 0)
+                    continue;
+            }
+            if (lname === 'apply_patch') {
+                const patchText = typeof filtered?.patch === 'string' ? String(filtered.patch).trim() : '';
+                if (!patchText)
+                    continue;
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: genToolCallId(), name: lname, args: argsStr });
+        }
+        // Broken variant (seen in the wild):
+        //   tool:exec_command (tool:exec_command)
+        //     <command>...</command>
+        //   </tool:exec_command>
+        const prefixBlockRe = /(?:^|\n)\s*(?:[•*+-]\s*)?tool:([A-Za-z0-9_]+)[^\n]*\n([\s\S]*?)<\/\s*tool:\s*\1\s*>/gi;
+        let pm;
+        while ((pm = prefixBlockRe.exec(text)) !== null) {
+            const rawName = String(pm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || !KNOWN_TOOLS.has(lname))
+                continue;
+            const inner = String(pm[2] || '');
+            const argsObj = {};
+            const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+            let km;
+            while ((km = kvRe.exec(inner)) !== null) {
+                const rawKey = String(km[1] || '').trim();
+                const rawVal = String(km[2] ?? '');
+                applyToolInnerField(lname, argsObj, rawKey, rawVal);
+            }
+            const paramRe = /<\s*parameter\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*(?:parameter|\1)\s*>/gi;
+            let pm2;
+            while ((pm2 = paramRe.exec(inner)) !== null) {
+                const rawKey = String(pm2[1] || '').trim();
+                const rawVal = String(pm2[2] ?? '');
+                applyToolInnerField(lname, argsObj, rawKey, rawVal);
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (lname === 'exec_command') {
+                const cmd = typeof filtered?.cmd === 'string' ? String(filtered.cmd).trim() : '';
+                if (!cmd)
+                    continue;
+            }
+            if (lname === 'write_stdin') {
+                const sid = filtered?.session_id;
+                if (sid === undefined || sid === null || String(sid).trim().length === 0)
+                    continue;
+            }
+            if (lname === 'apply_patch') {
+                const patchText = typeof filtered?.patch === 'string' ? String(filtered.patch).trim() : '';
+                if (!patchText)
+                    continue;
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: genToolCallId(), name: lname, args: argsStr });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Extract Anthropic/GLM-style XML tool tags that use <parameter name="...">...</parameter>.
+export function extractParameterXmlToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        // Some providers/models emit mismatched closing tags like </func_call>; accept a small set of known variants.
+        const toolRe = /<\s*(exec_command)\s*>([\s\S]*?)<\/\s*(?:\1|func_call|tool_call)\s*>/gi;
+        let tm;
+        while ((tm = toolRe.exec(text)) !== null) {
+            const rawName = (tm[1] || '').trim();
+            const inner = (tm[2] || '').trim();
+            if (!rawName || !inner)
+                continue;
+            const lname = rawName.toLowerCase();
+            const argsObj = {};
+            const paramRe = /<\s*parameter\s+name\s*=\s*"([^"]+)"\s*>([\s\S]*?)<\/\s*parameter\s*>/gi;
+            let pm;
+            while ((pm = paramRe.exec(inner)) !== null) {
+                const rawKey = (pm[1] || '').trim();
+                const key = normalizeKey(rawKey);
+                if (!key)
+                    continue;
+                const rawVal = (pm[2] || '').trim();
+                if (!rawVal)
+                    continue;
+                const parsed = tryParseJsonValue(rawVal);
+                if (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd') {
+                    const cmd = coerceCommandValueToString(parsed ?? rawVal);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                if (key.toLowerCase() === 'workdir') {
+                    argsObj.workdir = rawVal;
+                    continue;
+                }
+                argsObj[key] = parsed ?? rawVal;
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (!filtered || typeof filtered !== 'object' || Array.isArray(filtered))
+                continue;
+            const cmd = typeof filtered.cmd === 'string' ? String(filtered.cmd).trim() : '';
+            if (!cmd)
+                continue;
+            // If caller didn't provide workdir, fallback to a conservative env-derived workdir.
+            try {
+                if (!filtered.workdir) {
+                    const envWorkdir = readDefaultWorkdirFromEnv();
+                    if (envWorkdir)
+                        filtered.workdir = envWorkdir;
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({
+                id: genToolCallId(),
+                name: lname,
+                args: argsStr
+            });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+function applyInvokeParameterAliases(toolName, argsObj) {
+    try {
+        const lname = String(toolName || '').toLowerCase();
+        if (lname === 'write_stdin') {
+            // Some models emit `data` / `wait` instead of our canonical `chars` / `yield_time_ms`.
+            if (Object.prototype.hasOwnProperty.call(argsObj, 'data')) {
+                const data = argsObj.data;
+                if (!Object.prototype.hasOwnProperty.call(argsObj, 'chars') && !Object.prototype.hasOwnProperty.call(argsObj, 'text')) {
+                    argsObj.chars = data == null ? '' : String(data);
+                }
+                delete argsObj.data;
+            }
+            if (Object.prototype.hasOwnProperty.call(argsObj, 'wait') && !Object.prototype.hasOwnProperty.call(argsObj, 'yield_time_ms')) {
+                const wait = argsObj.wait;
+                let ms;
+                if (typeof wait === 'number' && Number.isFinite(wait)) {
+                    // Heuristic: small values are usually seconds; large values are likely already ms.
+                    ms = wait <= 1000 ? Math.round(wait * 1000) : Math.round(wait);
+                }
+                else if (typeof wait === 'string' && wait.trim().length) {
+                    const num = Number(wait.trim());
+                    if (Number.isFinite(num)) {
+                        ms = num <= 1000 ? Math.round(num * 1000) : Math.round(num);
+                    }
+                }
+                if (typeof ms === 'number' && Number.isFinite(ms) && ms >= 0) {
+                    argsObj.yield_time_ms = ms;
+                }
+                delete argsObj.wait;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+// Extract <function_calls><invoke name="...">...</invoke> blocks.
+export function extractInvokeToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const invokeRe = /<\s*invoke\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*invoke\s*>/gi;
+        let im;
+        while ((im = invokeRe.exec(text)) !== null) {
+            const rawName = (im[1] || '').trim();
+            const inner = (im[2] || '').trim();
+            if (!rawName || !inner)
+                continue;
+            const lname = rawName.toLowerCase();
+            const argsObj = {};
+            const paramRe = /<\s*parameter\s+name\s*=\s*"([^">]+)"\s*>([\s\S]*?)<\/\s*parameter\s*>/gi;
+            let pm;
+            while ((pm = paramRe.exec(inner)) !== null) {
+                const rawKey = (pm[1] || '').trim();
+                const key = normalizeKey(rawKey);
+                if (!key)
+                    continue;
+                const rawVal = (pm[2] ?? '').toString();
+                const value = tryParsePrimitiveValue(rawVal);
+                if (lname === 'exec_command' && (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd')) {
+                    const cmd = coerceCommandValueToString(value);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                argsObj[key] = value;
+            }
+            applyInvokeParameterAliases(lname, argsObj);
+            const filtered = filterArgsForTool(lname, argsObj);
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: genToolCallId(), name: lname, args: argsStr });
+        }
+        // Some Gemini CLI / antigravity variants emit a looser XML shape.
+        if (out.length === 0) {
+            const invokeBareRe = /<\s*invoke\s*>([\s\S]*?)<\/\s*invoke\s*>/gi;
+            let bm;
+            while ((bm = invokeBareRe.exec(text)) !== null) {
+                const inner = (bm[1] || '').trim();
+                if (!inner)
+                    continue;
+                const toolNameMatch = /<\s*(?:tool_name|toolname|tool)\s*>\s*([\s\S]*?)\s*<\/\s*(?:tool_name|toolname|tool)\s*>/i.exec(inner);
+                const rawName = (toolNameMatch?.[1] || '').trim();
+                if (!rawName)
+                    continue;
+                const lname = rawName.toLowerCase();
+                if (!KNOWN_TOOLS.has(lname))
+                    continue;
+                const argsObj = {};
+                const paramsMatch = /<\s*parameters\s*>([\s\S]*?)<\/\s*parameters\s*>/i.exec(inner);
+                if (paramsMatch && paramsMatch[1]) {
+                    const paramsInner = String(paramsMatch[1] || '');
+                    const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+                    let km;
+                    while ((km = kvRe.exec(paramsInner)) !== null) {
+                        const rawKey = (km[1] || '').trim();
+                        const key = normalizeKey(rawKey);
+                        if (!key)
+                            continue;
+                        const rawVal = (km[2] ?? '').toString();
+                        const value = tryParsePrimitiveValue(rawVal);
+                        if (lname === 'exec_command' && (key.toLowerCase() === 'command' || key.toLowerCase() === 'cmd')) {
+                            const cmd = coerceCommandValueToString(value);
+                            if (cmd.trim().length) {
+                                argsObj.cmd = cmd;
+                                argsObj.command = cmd;
+                            }
+                            continue;
+                        }
+                        argsObj[key] = value;
+                    }
+                }
+                applyInvokeParameterAliases(lname, argsObj);
+                const filtered = filterArgsForTool(lname, argsObj);
+                let argsStr = '{}';
+                try {
+                    argsStr = JSON.stringify(filtered);
+                }
+                catch {
+                    argsStr = '{}';
+                }
+                out.push({ id: genToolCallId(), name: lname, args: argsStr });
+            }
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Extract XML-like <tool_call> blocks used by some agents.
+export function extractXMLToolCallsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const blockRe = /<tool_call[\s\S]*?>([\s\S]*?)<\/tool_call>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const inner = (bm[1] || '').trim();
+            if (!inner)
+                continue;
+            // 1) try function/name tags
+            let name = '';
+            const fnTag = inner.match(/<\s*(?:function|name)\s*>\s*([a-zA-Z0-9_.-]+)\s*<\/(?:function|name)\s*>/i);
+            if (fnTag && fnTag[1]) {
+                name = String(fnTag[1]).trim();
+            }
+            else {
+                // 2) else pick the first non-empty line without tags as the name
+                const lines = inner.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+                const candidate = lines.find((l) => !l.startsWith('<') && /^[a-zA-Z0-9_.-]+$/.test(l));
+                if (candidate)
+                    name = candidate;
+            }
+            if (!name)
+                continue;
+            const lname = String(name).toLowerCase();
+            // Collect arg_key/arg_value pairs
+            const argRe = /<\s*arg_key\s*>\s*([^<]+?)\s*<\/(?:arg_key)\s*>\s*<\s*arg_value\s*>\s*([\s\S]*?)\s*<\/(?:arg_value)\s*>/gi;
+            let am;
+            const argsObj = {};
+            while ((am = argRe.exec(inner)) !== null) {
+                const k = normalizeKey((am[1] || '').trim());
+                const vRaw = (am[2] || '').trim();
+                if (!k)
+                    continue;
+                // If value looks like JSON array/object, parse; else keep as string
+                let v = vRaw;
+                if ((vRaw.startsWith('[') && vRaw.endsWith(']')) || (vRaw.startsWith('{') && vRaw.endsWith('}'))) {
+                    try {
+                        v = JSON.parse(vRaw);
+                    }
+                    catch {
+                        v = vRaw;
+                    }
+                }
+                argsObj[k] = v;
+            }
+            // If no args collected but inner contains JSON object, try as whole arguments
+            const hasAnyArg = Object.keys(argsObj).length > 0;
+            if (!hasAnyArg) {
+                const jsonMatch = inner.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+                if (jsonMatch) {
+                    try {
+                        const val = JSON.parse(jsonMatch[0]);
+                        argsObj.arguments = val;
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            // Guard: view_image must have a valid image path
+            try {
+                if (lname === 'view_image') {
+                    const p = filtered && typeof filtered === 'object' ? filtered.path : undefined;
+                    if (!isImagePath(p)) {
+                        continue;
+                    }
+                }
+            }
+            catch {
+                /* ignore guard errors */
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: genToolCallId(), name, args: argsStr });
+        }
+        // Fallback: loose XML variant (missing <tool_call> start).
+        try {
+            const pairRe = /<\s*arg_key\s*>\s*([^<]+?)\s*<\/\s*arg_key\s*>\s*<\s*arg_value\s*>\s*([\s\S]*?)\s*<\/\s*arg_value\s*>/gi;
+            let pm;
+            while ((pm = pairRe.exec(text)) !== null) {
+                const start = pm.index;
+                // find a likely function name on the immediately preceding non-empty line
+                let name = '';
+                try {
+                    const before = text.slice(0, start);
+                    const lines = before.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+                    const cand = lines.length ? lines[lines.length - 1] : '';
+                    if (/^[a-zA-Z0-9_.-]{2,}$/.test(cand))
+                        name = cand;
+                }
+                catch {
+                    /* ignore */
+                }
+                // 如果前一行抽不到合法函数名，但 arg_key 明显是 toon/command，
+                // 视为 CLI 通路下的 exec_command 工具。
+                const rawKey = (pm[1] || '').trim();
+                const normalizedKey = normalizeKey(rawKey).toLowerCase();
+                if (!name && (normalizedKey === 'toon' || normalizedKey === 'command')) {
+                    name = 'exec_command';
+                }
+                if (!name)
+                    continue;
+                const k = normalizeKey(rawKey);
+                const vRaw = (pm[2] || '').trim();
+                const argsObj = {};
+                if (k) {
+                    let v = vRaw;
+                    if ((vRaw.startsWith('[') && vRaw.endsWith(']')) || (vRaw.startsWith('{') && vRaw.endsWith('}'))) {
+                        try {
+                            v = JSON.parse(vRaw);
+                        }
+                        catch {
+                            v = vRaw;
+                        }
+                    }
+                    argsObj[k] = v;
+                }
+                const lname2 = String(name || '').toLowerCase();
+                const filtered2 = filterArgsForTool(lname2, argsObj);
+                // Guard: view_image must have a valid image path
+                try {
+                    if (lname2 === 'view_image') {
+                        const p = filtered2 && typeof filtered2 === 'object' ? filtered2.path : undefined;
+                        if (!isImagePath(p)) {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    /* ignore guard errors */
+                }
+                let argsStr = '{}';
+                try {
+                    argsStr = JSON.stringify(filtered2);
+                }
+                catch {
+                    argsStr = '{}';
+                }
+                out.push({ id: genToolCallId(), name, args: argsStr });
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 提取简单 XML 形式的工具调用块，例如：
+ *   <list_directory><path>/path</path><recursive>false</recursive></list_directory>
+ */
+export function extractSimpleXmlToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const blockRe = /<\s*([A-Za-z0-9_.-]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const rawName = (bm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || lname === 'tool_call')
+                continue;
+            // 目前仅支持 list_directory，后续按需扩展
+            if (lname !== 'list_directory')
+                continue;
+            const inner = bm[2] || '';
+            const args = {};
+            const argRe = /<\s*([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+            let am;
+            while ((am = argRe.exec(inner)) !== null) {
+                const key = normalizeKey((am[1] || '').trim());
+                if (!key)
+                    continue;
+                const rawVal = (am[2] || '').trim();
+                let v = rawVal;
+                if ((rawVal.startsWith('[') && rawVal.endsWith(']')) || (rawVal.startsWith('{') && rawVal.endsWith('}'))) {
+                    try {
+                        v = JSON.parse(rawVal);
+                    }
+                    catch {
+                        v = rawVal;
+                    }
+                }
+                else if (rawVal === 'true' || rawVal === 'false') {
+                    v = rawVal === 'true';
+                }
+                args[key] = v;
+            }
+            const filtered = filterArgsForTool(lname, args);
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({
+                id: genToolCallId(),
+                name: lname,
+                args: argsStr
+            });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/conversion/shared/text-markup-normalizer/extractors.d.ts

@@ -0,0 +1,5 @@
+export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from './extractors-shared.js';
+export { extractJsonToolCallsFromText } from './extractors-json.js';
+export { extractInvokeToolsFromText, extractParameterXmlToolsFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './extractors-xml.js';
+export { extractApplyPatchCallsFromText } from './extractors-apply-patch.js';
+export { extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractQwenToolCallTokensFromText } from './extractors-transcript.js';

package/dist/conversion/shared/text-markup-normalizer/extractors.js

@@ -0,0 +1,4 @@
+export { extractJsonToolCallsFromText } from './extractors-json.js';
+export { extractInvokeToolsFromText, extractParameterXmlToolsFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './extractors-xml.js';
+export { extractApplyPatchCallsFromText } from './extractors-apply-patch.js';
+export { extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractQwenToolCallTokensFromText } from './extractors-transcript.js';

package/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { TextMarkupNormalizeOptions } from './extractors.js';
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, options?: TextMarkupNormalizeOptions): Record<string, any>;