llm-tool-parser 0.0.1

package/README.md

@@ -0,0 +1,187 @@
+# llm-tool-parser
+
+A TypeScript utility for extracting and normalizing tool calls from large language model outputs.
+
+It supports both native tool calling formats (OpenAI `tool_calls`, Claude `tool_use`, etc.) and “text-based tool calls” commonly produced by open-source or fine-tuned models.
+
+The library converts inconsistent, streaming, or partially corrupted LLM outputs into a clean and unified `ToolCall` structure, making it easier to build reliable agent runtimes.
+
+### Key features
+
+* Supports multiple LLM ecosystems (OpenAI, Claude, DeepSeek, Qwen, etc.)
+* Extracts tool calls from raw text, JSON, XML, and hybrid formats
+* Handles streaming, trailing text, and malformed outputs
+* Normalizes all inputs into a unified `ToolCall` schema
+* Works with both structured tool calling and prompt-based agents
+
+## Simple usage
+
+Examples below are based on `src/parser.test.ts`.
+
+```ts
+import { parseLlmToolCalls } from 'llm-tool-parser'
+
+const text =
+  '{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/tmp/a.ts"}}]}'
+
+const { content, toolCalls } = parseLlmToolCalls(text)
+
+console.log(content)
+console.log(toolCalls[0]?.name)
+console.log(toolCalls[0]?.arguments)
+```
+
+You can also parse model outputs that contain extra text:
+
+```ts
+const text =
+  '让我来查看一下\n{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/a.ts"}}]}'
+
+const { content, toolCalls } = parseLlmToolCalls(text)
+
+console.log(content) // 让我来查看一下
+console.log(toolCalls)
+/**
+[
+  {
+    id: 'call_1780567643675_6a8b',
+    name: 'fileRead',
+    arguments: { filePath: '/a.ts' }
+  }
+]
+ */
+```
+
+And code-fenced JSON is supported too:
+
+```ts
+const text =
+  '我来读取文件\n```json\n{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/a.ts"}}]}\n```'
+
+const { content, toolCalls } = parseLlmToolCalls(text)
+```
+
+## Supported parsable formats
+
+Based on all test cases in `src/parser.test.ts`, the parser currently supports these input patterns:
+
+### 1. OpenAI-style `tool_calls`
+
+```json
+{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/tmp/a.ts"}}]}
+```
+
+- single or multiple calls in one `tool_calls` array
+- multiple consecutive JSON blocks
+- JSON at the start with trailing text
+- plain text before the JSON block
+- JSON inside fenced code blocks
+
+### 2. Single `tool_name` object
+
+```json
+{"tool_name":"bash","arguments":{"command":"ls"}}
+```
+
+### 3. `[tool_calls]` marker + JSON objects
+
+```txt
+[tool_calls]{"tool":"grep","args":{"pattern":"hello"}}{"tool":"glob","args":{"pattern":"*.ts"}}
+```
+
+### 4. `Action` / `Arguments` text format
+
+```txt
+Action: fileRead
+Arguments: {"filePath":"/tmp/test.ts"}
+```
+
+Also supports non-JSON arguments:
+
+```txt
+Action: grep
+Arguments: foo
+```
+
+### 5. XML-style tool tags
+
+```xml
+<fileRead>{"filePath":"/tmp/a.ts"}</fileRead>
+```
+
+- ignores non-tool tags like `<thinking>`
+- supports XML inside fenced code blocks
+
+### 6. CLI log style `[Called tools: ...]`
+
+```txt
+● [Called tools: fileRead({"filePath":"/tmp/a.ts"})]
+```
+
+Also supports multiple calls:
+
+```txt
+● [Called tools: grep({"pattern":"foo"}), glob({"pattern":"*.ts"})]
+```
+
+### 7. OpenAI legacy `function_call`
+
+```json
+{
+  "function_call": {
+    "name": "fileRead",
+    "arguments": "{\"filePath\":\"/tmp/a.ts\"}"
+  }
+}
+```
+
+### 8. Claude `tool_use`
+
+Content array form:
+
+```json
+{
+  "content": [
+    {
+      "type": "tool_use",
+      "name": "fileRead",
+      "input": {"filePath": "/tmp/a.ts"}
+    }
+  ]
+}
+```
+
+Standalone form:
+
+```json
+{
+  "type": "tool_use",
+  "name": "fileRead",
+  "input": {"filePath": "/tmp/a.ts"}
+}
+```
+
+### 9. OpenAI Responses API `function_call`
+
+```json
+{
+  "type": "function_call",
+  "name": "fileRead",
+  "arguments": "{\"filePath\":\"/tmp/a.ts\"}"
+}
+```
+
+### 10. Simple `tool` + `args` object
+
+```json
+{"tool":"fileRead","args":{"filePath":"/tmp/a.ts"}}
+```
+
+### 11. Root array of tool calls
+
+```json
+[
+  {"tool":"grep","args":{"pattern":"foo"}},
+  {"tool":"glob","args":{"pattern":"*.ts"}}
+]
+```

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './parser';

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parser"), exports);

package/lib/parser.d.ts

@@ -0,0 +1,26 @@
+export interface LlmToolCall {
+    id?: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface LlmToolCallParseResult {
+    content: string;
+    toolCalls: LlmToolCall[];
+}
+/**
+ * Parse tool calls from LLM response text.
+ * Supports:
+ * 1. [tool_calls] marker format: [tool_calls]{"tool":"name","args":{...}}...
+ * 2. Standard JSON tool_calls embedded in text
+ * 3. Action/Arguments text format
+ * 4. XML tag format: <tool_name>{...}</tool_name>
+ *
+ * Returns the cleaned content (with tool call syntax removed) and parsed calls.
+ */
+export declare function parseLlmToolCalls(text: string): LlmToolCallParseResult;
+/**
+ * Quick heuristic to detect if text is likely a tool call response.
+ * Used to suppress intermediate streaming of raw JSON that will be parsed
+ * as tool calls.
+ */
+export declare function looksLikeToolCall(text: string): boolean;

package/lib/parser.js

@@ -0,0 +1,565 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLlmToolCalls = parseLlmToolCalls;
+exports.looksLikeToolCall = looksLikeToolCall;
+const IGNORED_XML_TAGS = new Set([
+    "think", "thinking", "reflection", "output", "result", "answer", "response",
+]);
+/**
+ * Parse tool calls from LLM response text.
+ * Supports:
+ * 1. [tool_calls] marker format: [tool_calls]{"tool":"name","args":{...}}...
+ * 2. Standard JSON tool_calls embedded in text
+ * 3. Action/Arguments text format
+ * 4. XML tag format: <tool_name>{...}</tool_name>
+ *
+ * Returns the cleaned content (with tool call syntax removed) and parsed calls.
+ */
+function parseLlmToolCalls(text) {
+    if (!text)
+        return { content: "", toolCalls: [] };
+    const trimmedText = text.trim();
+    if (trimmedText.startsWith("[")) {
+        const parsed = tryParseLooseJson(trimmedText);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+            const toolCalls = extractToolCallsFromArray(parsed);
+            if (toolCalls.length > 0) {
+                return { content: "", toolCalls };
+            }
+        }
+    }
+    if (trimmedText.startsWith("{")) {
+        try {
+            const parsed = tryParseLooseJson(trimmedText);
+            if (!parsed || typeof parsed !== "object") {
+                throw new Error("Invalid JSON object");
+            }
+            const result = tryParseJsonToolCalls(parsed);
+            if (result)
+                return result;
+            if (typeof parsed.tool_calls === "string") {
+                const nested = parseLlmToolCalls(parsed.tool_calls);
+                if (nested.toolCalls.length > 0)
+                    return nested;
+            }
+        }
+        catch {
+            const looseRoot = tryExtractToolCallsFromToolCallsArrayText(trimmedText);
+            if (looseRoot) {
+                const remainderResult = looseRoot.remainder
+                    ? parseLlmToolCalls(looseRoot.remainder)
+                    : { content: "", toolCalls: [] };
+                return {
+                    content: remainderResult.content,
+                    toolCalls: [...looseRoot.toolCalls, ...remainderResult.toolCalls],
+                };
+            }
+            const allToolCalls = [];
+            let pos = 0;
+            let lastJsonEnd = 0;
+            while (pos < trimmedText.length) {
+                while (pos < trimmedText.length && trimmedText[pos] !== "{")
+                    pos++;
+                if (pos >= trimmedText.length)
+                    break;
+                const jsonStr = extractBalancedJson(trimmedText, pos);
+                if (!jsonStr)
+                    break;
+                try {
+                    const parsed = tryParseLooseJson(jsonStr);
+                    if (!parsed || typeof parsed !== "object") {
+                        throw new Error("Invalid JSON object");
+                    }
+                    const result = tryParseJsonToolCalls(parsed);
+                    if (result && result.toolCalls.length > 0) {
+                        allToolCalls.push(...result.toolCalls);
+                        pos += jsonStr.length;
+                        lastJsonEnd = pos;
+                        continue;
+                    }
+                }
+                catch {
+                    // Not valid JSON.
+                }
+                break;
+            }
+            if (allToolCalls.length > 0) {
+                const content = trimmedText.substring(lastJsonEnd).trim();
+                return { content, toolCalls: allToolCalls };
+            }
+        }
+    }
+    const toolCallsJsonIdx = trimmedText.lastIndexOf('{"tool_calls"');
+    if (toolCallsJsonIdx >= 0) {
+        const jsonStr = extractBalancedJson(trimmedText, toolCallsJsonIdx);
+        if (jsonStr) {
+            const parsed = tryParseLooseJson(jsonStr);
+            if (parsed && typeof parsed === "object" && Array.isArray(parsed.tool_calls)) {
+                const toolCalls = parsed.tool_calls.map((tc) => ({
+                    id: tc.id || generateId(),
+                    name: tc.tool_name || tc.tool || tc.name || tc.function?.name,
+                    arguments: parseToolArgs(tc.arguments || tc.args || tc.input || tc.function?.arguments),
+                }));
+                if (toolCalls.length > 0) {
+                    const content = trimmedText.substring(0, toolCallsJsonIdx).trim();
+                    return { content, toolCalls };
+                }
+            }
+        }
+    }
+    const toolCallsMarkerIdx = text.indexOf("[tool_calls]");
+    if (toolCallsMarkerIdx !== -1) {
+        const content = text.substring(0, toolCallsMarkerIdx).trim();
+        const toolCallsStr = text.substring(toolCallsMarkerIdx + "[tool_calls]".length).trim();
+        const toolCalls = parseConsecutiveJsonObjects(toolCallsStr);
+        if (toolCalls.length > 0) {
+            return { content, toolCalls };
+        }
+    }
+    const jsonToolCallsMatch = text.match(/```json\s*\n?\s*\{[\s\S]*?"tool_calls"\s*:\s*\[[\s\S]*?\]\s*\}?\s*\n?\s*```/);
+    if (jsonToolCallsMatch) {
+        const jsonStr = jsonToolCallsMatch[0]
+            .replace(/```json\s*\n?/, "")
+            .replace(/\n?\s*```$/, "")
+            .trim();
+        const parsed = tryParseLooseJson(jsonStr);
+        if (parsed && typeof parsed === "object" && Array.isArray(parsed.tool_calls)) {
+            const toolCalls = parsed.tool_calls.map((tc) => ({
+                id: tc.id,
+                name: tc.function?.name || tc.name || tc.tool,
+                arguments: parseToolArgs(tc.function?.arguments || tc.arguments || tc.args),
+            }));
+            const content = text.replace(jsonToolCallsMatch[0], "").trim();
+            return { content, toolCalls };
+        }
+    }
+    const actionMatch = text.match(/Action:\s*(\w+)/);
+    if (actionMatch) {
+        let args = {};
+        const argsMatch = text.match(/Arguments:\s*([\s\S]*)/);
+        if (argsMatch) {
+            const argsBody = argsMatch[1].trim();
+            if (argsBody.startsWith("{")) {
+                const jsonStr = extractBalancedJson(argsBody, 0);
+                if (jsonStr) {
+                    const parsedArgs = tryParseLooseJson(jsonStr);
+                    if (parsedArgs && typeof parsedArgs === "object") {
+                        args = parsedArgs;
+                    }
+                    else {
+                        args = { value: argsBody };
+                    }
+                }
+                else {
+                    args = { value: argsBody };
+                }
+            }
+            else if (argsBody) {
+                args = { value: argsBody };
+            }
+        }
+        const content = text
+            .replace(/Action:\s*\w+/, "")
+            .replace(/Arguments:\s*[\s\S]*/, "")
+            .trim();
+        return {
+            content,
+            toolCalls: [
+                {
+                    id: generateId(),
+                    name: actionMatch[1],
+                    arguments: args,
+                },
+            ],
+        };
+    }
+    const xmlCodeBlockMatch = text.match(/```(?:xml|)\s*\n([\s\S]*?)\n\s*```/);
+    if (xmlCodeBlockMatch) {
+        const innerXml = xmlCodeBlockMatch[1];
+        const xmlInBlockPattern = /<(\w+)>\s*([\s\S]*?)\s*<\/\1>/g;
+        const xmlInBlockResults = [];
+        let xmlInBlockMatch;
+        while ((xmlInBlockMatch = xmlInBlockPattern.exec(innerXml)) !== null) {
+            const tagName = xmlInBlockMatch[1];
+            if (IGNORED_XML_TAGS.has(tagName.toLowerCase()))
+                continue;
+            const innerContent = xmlInBlockMatch[2].trim();
+            const args = tryParseLooseJson(innerContent);
+            if (args && typeof args === "object") {
+                xmlInBlockResults.push({
+                    id: generateId(),
+                    name: tagName,
+                    arguments: args,
+                });
+            }
+        }
+        if (xmlInBlockResults.length > 0) {
+            const content = text.replace(xmlCodeBlockMatch[0], "").trim();
+            return { content, toolCalls: xmlInBlockResults };
+        }
+    }
+    const xmlPattern = /<(\w+)>\s*(\{[\s\S]*?\})\s*<\/\1>/g;
+    const xmlResults = [];
+    let xmlMatch;
+    let cleanText = text;
+    while ((xmlMatch = xmlPattern.exec(text)) !== null) {
+        const tagName = xmlMatch[1];
+        if (IGNORED_XML_TAGS.has(tagName.toLowerCase())) {
+            continue;
+        }
+        const innerContent = xmlMatch[2].trim();
+        const args = tryParseLooseJson(innerContent);
+        if (args && typeof args === "object") {
+            xmlResults.push({
+                id: generateId(),
+                name: tagName,
+                arguments: args,
+            });
+            cleanText = cleanText.replace(xmlMatch[0], "");
+        }
+    }
+    if (xmlResults.length > 0) {
+        return { content: cleanText.trim(), toolCalls: xmlResults };
+    }
+    const calledToolsIdx = text.search(/\[Called tools?:\s*/);
+    if (calledToolsIdx !== -1) {
+        const markerMatch = text.substring(calledToolsIdx).match(/^\[Called tools?:\s*/);
+        if (markerMatch) {
+            const innerStart = calledToolsIdx + markerMatch[0].length;
+            const calledToolCalls = parseCalledToolsFormat(text.substring(innerStart));
+            if (calledToolCalls.length > 0) {
+                const content = text.substring(0, calledToolsIdx).replace(/●\s*$/, "").trim();
+                return { content, toolCalls: calledToolCalls };
+            }
+        }
+    }
+    return { content: text, toolCalls: [] };
+}
+/**
+ * Quick heuristic to detect if text is likely a tool call response.
+ * Used to suppress intermediate streaming of raw JSON that will be parsed
+ * as tool calls.
+ */
+function looksLikeToolCall(text) {
+    const t = text.trimStart();
+    if (t.startsWith("{") || t.startsWith("[tool_calls]") || t.startsWith("[{"))
+        return true;
+    if (/^Action:\s*\w+/.test(t))
+        return true;
+    if (t.includes('{"tool_calls"'))
+        return true;
+    if (t.includes('"function_call"'))
+        return true;
+    if (t.includes('"tool_use"'))
+        return true;
+    if (/\[Called tools?:/.test(t))
+        return true;
+    return false;
+}
+function generateId() {
+    return `call_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+}
+function tryParseJsonToolCalls(parsed) {
+    if (Array.isArray(parsed.tool_calls) && parsed.tool_calls.length > 0) {
+        const toolCalls = parsed.tool_calls.map((tc) => ({
+            id: tc.id || generateId(),
+            name: tc.tool_name || tc.tool || tc.name || tc.function?.name,
+            arguments: parseToolArgs(tc.arguments || tc.args || tc.input || tc.function?.arguments),
+        }));
+        return { content: "", toolCalls };
+    }
+    if (parsed.function_call?.name) {
+        return {
+            content: "",
+            toolCalls: [{
+                    id: generateId(),
+                    name: parsed.function_call.name,
+                    arguments: parseToolArgs(parsed.function_call.arguments),
+                }],
+        };
+    }
+    if (Array.isArray(parsed.content)) {
+        const toolUseBlocks = parsed.content.filter((b) => b.type === "tool_use" && b.name);
+        if (toolUseBlocks.length > 0) {
+            const toolCalls = toolUseBlocks.map((b) => ({
+                id: b.id || generateId(),
+                name: b.name,
+                arguments: parseToolArgs(b.input || b.arguments || b.args),
+            }));
+            return { content: "", toolCalls };
+        }
+    }
+    if (parsed.type === "tool_use" && parsed.name) {
+        return {
+            content: "",
+            toolCalls: [{
+                    id: parsed.id || generateId(),
+                    name: parsed.name,
+                    arguments: parseToolArgs(parsed.input || parsed.arguments || parsed.args),
+                }],
+        };
+    }
+    if (parsed.type === "function_call" && parsed.name) {
+        return {
+            content: "",
+            toolCalls: [{
+                    id: parsed.call_id || generateId(),
+                    name: parsed.name,
+                    arguments: parseToolArgs(parsed.arguments || parsed.args),
+                }],
+        };
+    }
+    const name = parsed.tool_name || parsed.tool || parsed.function?.name || parsed.name;
+    if (name && typeof name === "string") {
+        const args = parseToolArgs(parsed.arguments || parsed.args || parsed.input || parsed.function?.arguments);
+        return {
+            content: "",
+            toolCalls: [{ id: generateId(), name, arguments: args }],
+        };
+    }
+    return null;
+}
+function extractToolCallsFromArray(arr) {
+    const results = [];
+    for (const item of arr) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const name = item.tool_name || item.tool || item.name || item.function?.name;
+        if (!name || typeof name !== "string")
+            continue;
+        results.push({
+            id: item.id || item.call_id || generateId(),
+            name,
+            arguments: parseToolArgs(item.arguments || item.args || item.input || item.function?.arguments),
+        });
+    }
+    return results;
+}
+function parseConsecutiveJsonObjects(text) {
+    const results = [];
+    let pos = 0;
+    while (pos < text.length) {
+        while (pos < text.length && /\s/.test(text[pos]))
+            pos++;
+        if (pos >= text.length)
+            break;
+        if (text[pos] !== "{")
+            break;
+        const jsonStr = extractBalancedJson(text, pos);
+        if (!jsonStr)
+            break;
+        const obj = tryParseLooseJson(jsonStr);
+        if (!obj || typeof obj !== "object") {
+            break;
+        }
+        const toolName = obj.tool || obj.name || obj.function?.name;
+        const toolArgs = obj.args || obj.arguments || obj.function?.arguments || {};
+        if (toolName) {
+            results.push({
+                id: generateId(),
+                name: toolName,
+                arguments: parseToolArgs(toolArgs),
+            });
+        }
+        pos += jsonStr.length;
+    }
+    return results;
+}
+function parseCalledToolsFormat(inner) {
+    const results = [];
+    let pos = 0;
+    while (pos < inner.length) {
+        while (pos < inner.length && /[\s,\]]/.test(inner[pos]))
+            pos++;
+        if (pos >= inner.length)
+            break;
+        if (!/[a-zA-Z_]/.test(inner[pos]))
+            break;
+        const nameStart = pos;
+        while (pos < inner.length && /\w/.test(inner[pos]))
+            pos++;
+        const toolName = inner.substring(nameStart, pos);
+        while (pos < inner.length && inner[pos] === " ")
+            pos++;
+        if (pos >= inner.length || inner[pos] !== "(")
+            break;
+        pos++;
+        const argsStart = pos;
+        let args = {};
+        let parsed = false;
+        if (pos < inner.length && inner[pos] === "{") {
+            const jsonStr = extractBalancedJson(inner, pos);
+            if (jsonStr) {
+                pos += jsonStr.length;
+                const parsedArgs = tryParseLooseJson(jsonStr);
+                if (parsedArgs && typeof parsedArgs === "object") {
+                    args = parsedArgs;
+                    parsed = true;
+                }
+            }
+        }
+        if (!parsed) {
+            while (pos < inner.length && inner[pos] !== ")")
+                pos++;
+            const rawArgs = inner.substring(argsStart, pos).trim();
+            if (rawArgs) {
+                const parsedArgs = tryParseLooseJson(rawArgs);
+                if (parsedArgs && typeof parsedArgs === "object") {
+                    args = parsedArgs;
+                }
+                else {
+                    args = {};
+                }
+            }
+        }
+        while (pos < inner.length && inner[pos] !== ")")
+            pos++;
+        if (pos < inner.length)
+            pos++;
+        results.push({
+            id: generateId(),
+            name: toolName,
+            arguments: args,
+        });
+    }
+    return results;
+}
+function parseToolArgs(args) {
+    if (!args)
+        return {};
+    if (typeof args === "string") {
+        return tryParseLooseJson(args) ?? {};
+    }
+    if (typeof args === "object")
+        return args;
+    return {};
+}
+function tryExtractToolCallsFromToolCallsArrayText(text) {
+    const markerMatch = /"tool_calls"\s*:\s*\[/.exec(text);
+    if (!markerMatch)
+        return null;
+    const toolCalls = [];
+    let pos = markerMatch.index + markerMatch[0].length;
+    while (pos < text.length) {
+        while (pos < text.length && /\s/.test(text[pos]))
+            pos++;
+        if (pos >= text.length)
+            break;
+        const ch = text[pos];
+        if (ch === "]") {
+            pos++;
+            while (pos < text.length && /[\s}]/.test(text[pos]))
+                pos++;
+            return {
+                toolCalls,
+                remainder: text.slice(pos).trim(),
+            };
+        }
+        if (ch === "," || ch === "}") {
+            pos++;
+            continue;
+        }
+        if (ch !== "{") {
+            break;
+        }
+        const jsonStr = extractBalancedJson(text, pos);
+        if (!jsonStr)
+            return null;
+        const parsed = tryParseLooseJson(jsonStr);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const result = tryParseJsonToolCalls(parsed);
+        if (!result || result.toolCalls.length === 0)
+            return null;
+        toolCalls.push(...result.toolCalls);
+        pos += jsonStr.length;
+    }
+    return null;
+}
+function tryParseLooseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const sanitized = escapeLiteralControlCharsInJsonStrings(text);
+        if (sanitized === text) {
+            return null;
+        }
+        try {
+            return JSON.parse(sanitized);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function escapeLiteralControlCharsInJsonStrings(text) {
+    let result = "";
+    let inString = false;
+    let escape = false;
+    for (const ch of text) {
+        if (escape) {
+            result += ch;
+            escape = false;
+            continue;
+        }
+        if (ch === "\\" && inString) {
+            result += ch;
+            escape = true;
+            continue;
+        }
+        if (ch === "\"") {
+            result += ch;
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            if (ch === "\n") {
+                result += "\\n";
+                continue;
+            }
+            if (ch === "\r") {
+                result += "\\r";
+                continue;
+            }
+            if (ch === "\t") {
+                result += "\\t";
+                continue;
+            }
+        }
+        result += ch;
+    }
+    return result;
+}
+function extractBalancedJson(text, start) {
+    if (start < 0 || start >= text.length || text[start] !== "{")
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === "\\" && inString) {
+            escape = true;
+            continue;
+        }
+        if (ch === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return text.substring(start, i + 1);
+        }
+    }
+    return null;
+}

package/lib/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/parser.test.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const parser_1 = require("./parser");
+(0, vitest_1.describe)('parseLlmToolCalls', () => {
+    (0, vitest_1.describe)('Format A: pure JSON with tool_calls array', () => {
+        (0, vitest_1.it)('parses a single tool call', () => {
+            const text = '{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/tmp/a.ts"}}]}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(content).toBe('');
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+        (0, vitest_1.it)('parses multiple tool calls', () => {
+            const text = JSON.stringify({
+                tool_calls: [
+                    { tool_name: 'grep', arguments: { pattern: 'foo', path: '/src' } },
+                    { tool_name: 'glob', arguments: { pattern: '**/*.ts' } },
+                    { tool_name: 'listFiles', arguments: { path: '/src' } },
+                ],
+            });
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(content).toBe('');
+            (0, vitest_1.expect)(toolCalls).toHaveLength(3);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[2].name).toBe('listFiles');
+        });
+    });
+    (0, vitest_1.describe)('Format B: single tool call without array wrapper', () => {
+        (0, vitest_1.it)('parses single tool_name object', () => {
+            const text = '{"tool_name":"bash","arguments":{"command":"ls"}}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(content).toBe('');
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('bash');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ command: 'ls' });
+        });
+    });
+    (0, vitest_1.describe)('Multiple consecutive tool_calls JSON blocks', () => {
+        (0, vitest_1.it)('parses two consecutive tool_calls blocks', () => {
+            const text = '{"tool_calls":[{"tool_name":"glob","arguments":{"pattern":"README*"}}]}{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/tmp/a.ts"}}]}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('fileRead');
+            (0, vitest_1.expect)(content).toBe('');
+        });
+        (0, vitest_1.it)('parses three consecutive tool_calls blocks (real log scenario)', () => {
+            const text = '{"tool_calls":[{"tool_name":"glob","arguments":{"pattern":"README*","path":"/Users/someone/gitlab/mini-kode"}},{"tool_name":"fileRead","arguments":{"filePath":"/Users/someone/gitlab/mini-kode/package.json"}}]}{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/Users/someone/gitlab/mini-kode/README.md"}}]}{"tool_calls":[{"tool_name":"fileEdit","arguments":{"filePath":"/Users/someone/gitlab/mini-kode/README.md","old_string":"# mini-kode\\n","new_string":"# mini-kode\\n\\n## Install\\n"}}]}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(4);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[2].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[3].name).toBe('fileEdit');
+            (0, vitest_1.expect)(content).toBe('');
+        });
+        (0, vitest_1.it)('parses consecutive tool_calls blocks with trailing text', () => {
+            const text = '{"tool_calls":[{"tool_name":"glob","arguments":{"pattern":"*.ts"}}]}{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/a.ts"}}]}以上是文件内容';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('fileRead');
+            (0, vitest_1.expect)(content).toBe('以上是文件内容');
+        });
+    });
+    (0, vitest_1.describe)('JSON at start with trailing text (the s.log bug)', () => {
+        (0, vitest_1.it)('parses tool_calls JSON followed by trailing text without separator', () => {
+            const text = '{"tool_calls":[{"tool_name":"grep","arguments":{"pattern":"\\\\.xxxx/skills","path":"/Users/someone/gitlab/xxx-xxxx-agent-cli"}},{"tool_name":"glob","arguments":{"pattern":"**/.xxxx/skills/**"}},{"tool_name":"listFiles","arguments":{"path":"/Users/someone/gitlab/xxx-xxxx-agent-cli/.xxxx"}}]}`.xxxx/skills` 没发现。\n当前仓库里 skill 相关主要是：`.agents/skills/`。';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(3);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[2].name).toBe('listFiles');
+            (0, vitest_1.expect)(content).toContain('.xxxx/skills');
+        });
+        (0, vitest_1.it)('parses tool_calls JSON followed by newline and text', () => {
+            const text = '{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/tmp/x.ts"}}]}\n文件内容如下...';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(content).toBe('文件内容如下...');
+        });
+        (0, vitest_1.it)('parses tool_calls JSON string with newline', () => {
+            const text = `{"tool_calls":[{"tool_name":"fileEdit","arguments":{"filePath":"/Users/someone/gitlab/tyyf6hyazx6l0sgrbr/src/components/bottom-bar/index.tsx","old_string":"      <View\n        className={styles.btns}\n        style={{\n          paddingBottom: isIphoneX ? '40rpx' : '0rpx',\n        }}\n      >\n        {showButtons.map(item => {\n","new_string":"      <View\n        className={styles.btns}\n        style={{\n          paddingBottom: isIphoneX\n            ? 'calc(40rpx + env(safe-area-inset-bottom))'\n            : 'env(safe-area-inset-bottom)',\n        }}\n      >\n        {showButtons.map(item => {\n"}}},{"tool_name":"glob","arguments":{"pattern":"package.json","path":"/Users/someone/gitlab/tyyf6hyazx6l0sgrbr"}},{"tool_name":"glob","arguments":{"pattern":"pnpm-lock.yaml","path":"/Users/someone/gitlab/tyyf6hyazx6l0sgrbr"}}]}`;
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(content).toBe('');
+            (0, vitest_1.expect)(toolCalls).toHaveLength(3);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileEdit');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[2].name).toBe('glob');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toMatchObject({
+                filePath: '/Users/someone/gitlab/tyyf6hyazx6l0sgrbr/src/components/bottom-bar/index.tsx',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Format 0.5: text followed by tool_calls JSON', () => {
+        (0, vitest_1.it)('parses text before JSON block', () => {
+            const text = '让我来查看一下\n{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/a.ts"}}]}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(content).toBe('让我来查看一下');
+        });
+    });
+    (0, vitest_1.describe)('[tool_calls] marker format', () => {
+        (0, vitest_1.it)('parses [tool_calls] with consecutive JSON objects', () => {
+            const text = '我来搜索一下\n[tool_calls]{"tool":"grep","args":{"pattern":"hello"}}{"tool":"glob","args":{"pattern":"*.ts"}}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+            (0, vitest_1.expect)(content).toBe('我来搜索一下');
+        });
+    });
+    (0, vitest_1.describe)('Action/Arguments format', () => {
+        (0, vitest_1.it)('parses Action and Arguments text format', () => {
+            const text = 'Action: fileRead\nArguments: {"filePath":"/tmp/test.ts"}';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/test.ts' });
+        });
+    });
+    (0, vitest_1.describe)('XML tag format', () => {
+        (0, vitest_1.it)('parses XML-style tool calls', () => {
+            const text = '<fileRead>{"filePath":"/tmp/a.ts"}</fileRead>';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+        (0, vitest_1.it)('ignores thinking/reflection tags', () => {
+            const text = '<thinking>{"internal":"reasoning"}</thinking>\n<fileRead>{"filePath":"/a.ts"}</fileRead>';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+        });
+    });
+    (0, vitest_1.describe)('[Called tools: ...] format', () => {
+        (0, vitest_1.it)('parses single called tool', () => {
+            const text = '● [Called tools: fileRead({"filePath":"/tmp/a.ts"})]';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+        (0, vitest_1.it)('parses multiple called tools', () => {
+            const text = '● [Called tools: grep({"pattern":"foo"}), glob({"pattern":"*.ts"})]';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+        });
+    });
+    (0, vitest_1.describe)('function_call format (GPT3.5/4 legacy)', () => {
+        (0, vitest_1.it)('parses function_call format', () => {
+            const text = JSON.stringify({
+                function_call: {
+                    name: 'fileRead',
+                    arguments: JSON.stringify({ filePath: '/tmp/a.ts' }),
+                },
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+    });
+    (0, vitest_1.describe)('Claude tool_use content block', () => {
+        (0, vitest_1.it)('parses claude tool_use block', () => {
+            const text = JSON.stringify({
+                content: [
+                    {
+                        type: 'tool_use',
+                        id: 'toolu_123',
+                        name: 'fileRead',
+                        input: { filePath: '/tmp/a.ts' },
+                    },
+                ],
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+        (0, vitest_1.it)('parses multiple tool_use blocks in content array', () => {
+            const text = JSON.stringify({
+                content: [
+                    {
+                        type: 'tool_use',
+                        id: 'toolu_1',
+                        name: 'grep',
+                        input: { pattern: 'foo' },
+                    },
+                    {
+                        type: 'tool_use',
+                        id: 'toolu_2',
+                        name: 'glob',
+                        input: { pattern: '*.ts' },
+                    },
+                ],
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+        });
+    });
+    (0, vitest_1.describe)('Claude standalone tool_use', () => {
+        (0, vitest_1.it)('parses standalone tool_use object', () => {
+            const text = JSON.stringify({
+                type: 'tool_use',
+                name: 'fileRead',
+                input: { filePath: '/tmp/a.ts' },
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+    });
+    (0, vitest_1.describe)('OpenAI Responses API format', () => {
+        (0, vitest_1.it)('parses responses api function_call', () => {
+            const text = JSON.stringify({
+                type: 'function_call',
+                call_id: 'call_123',
+                name: 'fileRead',
+                arguments: JSON.stringify({ filePath: '/tmp/a.ts' }),
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+    });
+    (0, vitest_1.describe)('tool + args single object format', () => {
+        (0, vitest_1.it)('parses tool + args format', () => {
+            const text = JSON.stringify({
+                tool: 'fileRead',
+                args: { filePath: '/tmp/a.ts' },
+            });
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+    });
+    (0, vitest_1.describe)('root array format', () => {
+        (0, vitest_1.it)('parses root array tool calls', () => {
+            const text = JSON.stringify([
+                { tool: 'grep', args: { pattern: 'foo' } },
+                { tool: 'glob', args: { pattern: '*.ts' } },
+            ]);
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(2);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[1].name).toBe('glob');
+        });
+    });
+    (0, vitest_1.describe)('XML inside code block', () => {
+        (0, vitest_1.it)('parses xml inside code block', () => {
+            const text = `
+\`\`\`xml
+<fileRead>{"filePath":"/tmp/a.ts"}</fileRead>
+\`\`\`
+`;
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ filePath: '/tmp/a.ts' });
+        });
+    });
+    (0, vitest_1.describe)('non-JSON arguments', () => {
+        (0, vitest_1.it)('handles non-json arguments as value string', () => {
+            const text = `
+Action: grep
+Arguments: foo
+`;
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ value: 'foo' });
+        });
+        (0, vitest_1.it)('handles multiline non-json arguments', () => {
+            const text = `Action: grep
+Arguments:
+foo`;
+            const { toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('grep');
+            (0, vitest_1.expect)(toolCalls[0].arguments).toEqual({ value: 'foo' });
+        });
+    });
+    (0, vitest_1.describe)('plain text (no tool calls)', () => {
+        (0, vitest_1.it)('returns text as content with empty toolCalls', () => {
+            const text = '这是一段普通的回复文本，没有任何工具调用。';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(content).toBe(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(0);
+        });
+        (0, vitest_1.it)('handles empty string', () => {
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)('');
+            (0, vitest_1.expect)(content).toBe('');
+            (0, vitest_1.expect)(toolCalls).toHaveLength(0);
+        });
+    });
+    (0, vitest_1.describe)('code block with tool_calls JSON', () => {
+        (0, vitest_1.it)('parses tool_calls inside ```json code fence', () => {
+            const text = '我来读取文件\n```json\n{"tool_calls":[{"tool_name":"fileRead","arguments":{"filePath":"/a.ts"}}]}\n```';
+            const { content, toolCalls } = (0, parser_1.parseLlmToolCalls)(text);
+            (0, vitest_1.expect)(toolCalls).toHaveLength(1);
+            (0, vitest_1.expect)(toolCalls[0].name).toBe('fileRead');
+            (0, vitest_1.expect)(content).toContain('我来读取文件');
+        });
+    });
+});
+(0, vitest_1.describe)('looksLikeToolCall', () => {
+    (0, vitest_1.it)('detects JSON starting with {', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('{"tool_calls":[...]}')).toBe(true);
+    });
+    (0, vitest_1.it)('detects [tool_calls] marker', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('[tool_calls]{...}')).toBe(true);
+    });
+    (0, vitest_1.it)('detects Action: format', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('Action: fileRead\nArguments: {...}')).toBe(true);
+    });
+    (0, vitest_1.it)('detects embedded tool_calls JSON', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('一些文本 {"tool_calls":[...]}')).toBe(true);
+    });
+    (0, vitest_1.it)('detects [Called tools:] format', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('● [Called tools: grep(...)]')).toBe(true);
+    });
+    (0, vitest_1.it)('detects root array format', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('[{"tool":"grep","args":{}}]')).toBe(true);
+    });
+    (0, vitest_1.it)('detects function_call keyword', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('{"function_call":{"name":"fileRead"}}')).toBe(true);
+    });
+    (0, vitest_1.it)('detects tool_use keyword', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('{"type":"tool_use","name":"fileRead"}')).toBe(true);
+    });
+    (0, vitest_1.it)('returns false for plain text', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('这是一段普通回复')).toBe(false);
+    });
+    (0, vitest_1.it)('returns false for markdown content', () => {
+        (0, vitest_1.expect)((0, parser_1.looksLikeToolCall)('## Heading\n\nSome content here')).toBe(false);
+    });
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "llm-tool-parser",
+  "version": "0.0.1",
+  "description": "Universal LLM tool call extractor that normalizes messy outputs into a unified ToolCall format.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Saber2pr/llm-tool-parser"
+  },
+  "author": "saber2pr",
+  "license": "MIT",
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "llm",
+    "tool-calling",
+    "tool-calls",
+    "ai-tools",
+    "agent",
+    "ai-agent",
+    "llm-agent",
+    "tool-parser",
+    "tool-extraction",
+    "llm-output-parser"
+  ],
+  "main": "./lib/index.js",
+  "scripts": {
+    "start": "tsc --watch",
+    "build": "tsc",
+    "prepublishOnly": "yarn build",
+    "test": "vitest run src/*.test.ts",
+    "lint": "prettier --write ./src",
+    "prepare": "husky install"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "husky": "^7.0.2",
+    "lint-staged": "^11.1.2",
+    "prettier": "^2.4.1",
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.8"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "yarn lint",
+      "git add ."
+    ]
+  }
+}