@vybestack/llxprt-code-core 0.5.0-nightly.251102.f115237d → 0.5.0-nightly.251104.319bfefc

package/dist/src/parsers/TextToolCallParser.js

@@ -4,29 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 export class GemmaToolCallParser {
-    // Support multiple tool call formats
-    patterns = [
-        // Format 1: [TOOL_REQUEST] toolName {args} [TOOL_REQUEST_END]
-        /\[TOOL_REQUEST\]\s*(\w+)\s+({.*?})\s*\[TOOL_REQUEST_END\]/gs,
-        // Format 2: ✦ tool_call: toolName for key value pairs (more specific to avoid false positives)
-        /✦\s*tool_call:\s*(\w+)\s+for\s+(.+?)(?=\n|✦|$)/gs,
-        // Format 3: JSON object with name/arguments followed by [END_TOOL_REQUEST]
-        /(\d+\s+)?{"name":\s*"(\w+)",\s*"arguments":\s*({.*?})}\s*(?:\n\s*\d+\s+)?\[END_TOOL_REQUEST\]/gs,
-        // Format 4: Hermes format with <tool_call> tags
-        /<tool_call>\s*({.*?"name":\s*"(\w+)".*?})\s*<\/tool_call>/gs,
-        // Format 5: XML with <invoke> tags (Claude-style)
-        /<invoke\s+name="(\w+)">(.*?)<\/invoke>/gs,
-        // Format 6: Generic XML tool format
-        /<tool>\s*<name>(\w+)<\/name>\s*<arguments>(.*?)<\/arguments>\s*<\/tool>/gs,
-        // Format 7: <use toolName with key="value" ...>
-        /<use\s+([a-zA-Z0-9_.-]+)([^>]*)>/gs,
-        // Format 8: <use_toolName with key="value" ...>
-        /<use_([a-zA-Z0-9_.-]+)([^>]*)>/gs,
-    ];
+    keyValuePattern = /✦\s*tool_call:\s*([A-Za-z0-9_.-]+)\s+for\s+([^\n✦]*)/g;
     parse(content) {
-        const toolCalls = [];
-        let cleanedContent = content;
-        const matches = [];
         // Quick check: if content doesn't contain any tool call markers, return early
         if (!content.includes('[TOOL_REQUEST') &&
             !content.includes('tool_call:') &&
@@ -38,186 +17,445 @@ export class GemmaToolCallParser {
             !content.includes('<use ')) {
             return { cleanedContent: content, toolCalls: [] };
         }
-        // Try each pattern
-        for (const pattern of this.patterns) {
-            let match;
-            while ((match = pattern.exec(content)) !== null) {
-                if (pattern === this.patterns[1]) {
-                    // Format 2: Parse key-value pairs from "for key value key2 value2" format
-                    const [fullMatch, toolName, argsStr] = match;
-                    const args = this.parseKeyValuePairs(argsStr);
-                    matches.push({ fullMatch, toolName, args });
-                }
-                else if (pattern === this.patterns[2]) {
-                    // Format 3: JSON object format {"name": "tool", "arguments": {...}}
-                    const [fullMatch, , toolName, jsonArgs] = match;
-                    matches.push({ fullMatch, toolName, args: jsonArgs });
-                }
-                else if (pattern === this.patterns[3]) {
-                    // Format 4: Hermes format <tool_call>{"arguments": {...}, "name": "tool"}</tool_call>
-                    const [fullMatch, hermesJson, toolName] = match;
-                    try {
-                        const parsed = JSON.parse(hermesJson);
-                        matches.push({
-                            fullMatch,
-                            toolName,
-                            args: JSON.stringify(parsed.arguments || {}),
-                        });
-                    }
-                    catch (error) {
-                        console.error(`[GemmaToolCallParser] Failed to parse Hermes format: ${error}`);
-                        // Still need to track the match to remove it from content
-                        matches.push({ fullMatch, toolName: '', args: '' });
-                    }
-                }
-                else if (pattern === this.patterns[4]) {
-                    // Format 5: XML with <invoke> tags (Claude-style)
-                    const [fullMatch, toolName, xmlContent] = match;
-                    matches.push({ fullMatch, toolName, args: xmlContent });
-                }
-                else if (pattern === this.patterns[5]) {
-                    // Format 6: Generic XML tool format
-                    const [fullMatch, toolName, xmlArgs] = match;
-                    matches.push({ fullMatch, toolName, args: xmlArgs });
-                }
-                else if (pattern === this.patterns[6] ||
-                    pattern === this.patterns[7]) {
-                    // Format 7: <use toolName ...>
-                    const [fullMatch, toolNameRaw, attributeText] = match;
-                    const toolName = toolNameRaw?.trim();
-                    const args = {};
-                    const attributeMatches = Array.from(attributeText.matchAll(/([a-zA-Z0-9_.-]+)\s*=\s*"(.*?)"/g));
-                    for (const [, key, rawValue] of attributeMatches) {
-                        if (!key)
-                            continue;
-                        const trimmedValue = rawValue.trim();
-                        if (trimmedValue.startsWith('{') || trimmedValue.startsWith('[')) {
-                            try {
-                                args[key] = JSON.parse(trimmedValue);
-                                continue;
-                            }
-                            catch (_error) {
-                                // fall back to string
-                            }
-                        }
-                        if (/^-?\d+(\.\d+)?$/.test(trimmedValue)) {
-                            args[key] = Number(trimmedValue);
-                        }
-                        else if (trimmedValue.toLowerCase() === 'true' ||
-                            trimmedValue.toLowerCase() === 'false') {
-                            args[key] = trimmedValue.toLowerCase() === 'true';
-                        }
-                        else {
-                            args[key] = trimmedValue;
-                        }
-                    }
-                    matches.push({ fullMatch, toolName, args });
-                }
-                else {
-                    // Format 1: tool name followed by JSON arguments
-                    const [fullMatch, toolName, jsonArgs] = match;
-                    matches.push({ fullMatch, toolName, args: jsonArgs });
-                }
+        const matches = this.collectMatches(content);
+        const toolCalls = [];
+        const ranges = [];
+        for (const match of matches) {
+            ranges.push({ start: match.start, end: match.end });
+            if (!match.toolName) {
+                continue;
             }
-            // Reset the regex state for next use
-            pattern.lastIndex = 0;
+            const parsedArgs = this.normalizeArguments(match.rawArgs, match.toolName, match.fullMatch);
+            if (!parsedArgs) {
+                continue;
+            }
+            toolCalls.push({
+                name: match.toolName,
+                arguments: parsedArgs,
+            });
         }
-        // Process each match
-        for (const { fullMatch, toolName, args } of matches) {
-            // Remove the tool call pattern from the content regardless of parsing success so markers are always stripped
-            cleanedContent = cleanedContent.replace(fullMatch, '');
-            // Skip if toolName is empty (failed parsing)
-            if (!toolName) {
+        const withoutMatches = this.removeMatchedRanges(content, ranges);
+        const cleanedContent = this.postProcessCleanedContent(withoutMatches);
+        return { cleanedContent, toolCalls };
+    }
+    collectMatches(content) {
+        const matches = [
+            ...this.findBracketToolRequests(content),
+            ...this.findJsonToolRequests(content),
+            ...this.findHermesToolRequests(content),
+            ...this.findInvokeToolRequests(content),
+            ...this.findGenericXmlToolRequests(content),
+            ...this.findUseToolRequests(content),
+            ...this.findUseUnderscoreToolRequests(content),
+            ...this.findKeyValueToolRequests(content),
+        ];
+        return matches.sort((a, b) => a.start - b.start);
+    }
+    findBracketToolRequests(content) {
+        const matches = [];
+        const startMarker = '[TOOL_REQUEST]';
+        const endMarker = '[TOOL_REQUEST_END]';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(startMarker, searchIndex);
+            if (start === -1)
+                break;
+            const afterStart = start + startMarker.length;
+            const endMarkerIndex = content.indexOf(endMarker, afterStart);
+            if (endMarkerIndex === -1)
+                break;
+            const segment = content.slice(afterStart, endMarkerIndex);
+            const toolNameMatch = segment.match(/^\s*([^\s{]+)\s+/);
+            if (!toolNameMatch) {
+                searchIndex = endMarkerIndex + endMarker.length;
+                continue;
+            }
+            const toolName = toolNameMatch[1];
+            const braceOffset = segment.indexOf('{', toolNameMatch[0].length);
+            if (braceOffset === -1) {
+                searchIndex = endMarkerIndex + endMarker.length;
+                continue;
+            }
+            const jsonStart = afterStart + braceOffset;
+            const jsonSegment = this.extractBalancedSegment(content, jsonStart, '{', '}');
+            if (!jsonSegment || jsonSegment.endIndex > endMarkerIndex) {
+                searchIndex = endMarkerIndex + endMarker.length;
+                continue;
+            }
+            const fullEnd = endMarkerIndex + endMarker.length;
+            matches.push({
+                start,
+                end: fullEnd,
+                toolName,
+                rawArgs: jsonSegment.segment,
+                fullMatch: content.slice(start, fullEnd),
+            });
+            searchIndex = fullEnd;
+        }
+        return matches;
+    }
+    findJsonToolRequests(content) {
+        const matches = [];
+        const marker = '{"name":';
+        const endMarker = '[END_TOOL_REQUEST]';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const candidateIndex = content.indexOf(marker, searchIndex);
+            if (candidateIndex === -1) {
+                break;
+            }
+            let startIndex = candidateIndex;
+            let backPointer = candidateIndex;
+            while (backPointer > 0 && /\s/.test(content.charAt(backPointer - 1))) {
+                backPointer--;
+            }
+            let digitPointer = backPointer;
+            while (digitPointer > 0 && /\d/.test(content.charAt(digitPointer - 1))) {
+                digitPointer--;
+            }
+            if (digitPointer < backPointer) {
+                startIndex = digitPointer;
+            }
+            const jsonSegment = this.extractBalancedSegment(content, candidateIndex, '{', '}');
+            if (!jsonSegment) {
+                searchIndex = candidateIndex + marker.length;
                 continue;
             }
             try {
-                let parsedArgs;
-                if (typeof args === 'string') {
-                    // Check if it's XML content (Claude-style or generic)
-                    if (args.includes('<parameter') ||
-                        (args.includes('<') && args.includes('>'))) {
-                        parsedArgs = this.parseXMLParameters(args);
-                    }
-                    else {
-                        // Handle JSON string arguments
-                        parsedArgs = JSON.parse(args);
-                    }
-                }
-                else {
-                    // Already parsed (from key-value format)
-                    parsedArgs = args;
+                const parsed = JSON.parse(jsonSegment.segment);
+                const toolName = String(parsed.name ?? '');
+                const argsText = JSON.stringify(parsed.arguments ?? {});
+                const endMarkerIndex = content.indexOf(endMarker, jsonSegment.endIndex);
+                if (toolName && endMarkerIndex !== -1) {
+                    const fullEnd = endMarkerIndex + endMarker.length;
+                    matches.push({
+                        start: startIndex,
+                        end: fullEnd,
+                        toolName,
+                        rawArgs: argsText,
+                        fullMatch: content.slice(startIndex, fullEnd),
+                    });
+                    searchIndex = fullEnd;
+                    continue;
                 }
-                toolCalls.push({
-                    name: toolName,
-                    arguments: parsedArgs,
-                });
             }
             catch (error) {
-                if (typeof args === 'string') {
-                    // Attempt targeted repair for common unescaped inner quotes in JSON strings
-                    const repaired = this.tryRepairJson(args);
-                    if (repaired) {
-                        try {
-                            const parsedArgs = JSON.parse(repaired);
-                            toolCalls.push({
-                                name: toolName,
-                                arguments: parsedArgs,
-                            });
-                            continue;
-                        }
-                        catch (_ignored) {
-                            // fall through to legacy fallback
-                        }
-                    }
-                    // Try to extract a simpler JSON pattern if the full match fails
-                    const simpleJsonMatch = args.match(/^{[^{]*}$/);
-                    if (simpleJsonMatch) {
-                        try {
-                            const parsedArgs = JSON.parse(simpleJsonMatch[0]);
-                            toolCalls.push({
-                                name: toolName,
-                                arguments: parsedArgs,
-                            });
-                            cleanedContent = cleanedContent.replace(fullMatch, '');
-                        }
-                        catch (_secondError) {
-                            console.error(`[GemmaToolCallParser] Failed to parse tool arguments for ${toolName}:`, error);
-                            console.error(`[GemmaToolCallParser] Raw arguments: ${args}`);
-                            // Keep the original text if we can't parse it
-                        }
-                    }
-                    else {
-                        console.error(`[GemmaToolCallParser] Failed to parse tool arguments for ${toolName}:`, error);
-                        console.error(`[GemmaToolCallParser] Raw arguments: ${args}`);
-                    }
-                }
+                console.error(`[GemmaToolCallParser] Failed to parse structured tool call JSON: ${error}`);
+            }
+            searchIndex = candidateIndex + marker.length;
+        }
+        return matches;
+    }
+    findHermesToolRequests(content) {
+        const matches = [];
+        const startTag = '<tool_call>';
+        const endTag = '</tool_call>';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(startTag, searchIndex);
+            if (start === -1)
+                break;
+            const end = content.indexOf(endTag, start + startTag.length);
+            if (end === -1)
+                break;
+            const jsonText = content.slice(start + startTag.length, end).trim();
+            let toolName = '';
+            let args = '{}';
+            try {
+                const parsed = JSON.parse(jsonText);
+                toolName = String(parsed.name ?? '');
+                args = JSON.stringify(parsed.arguments ?? {});
+            }
+            catch (error) {
+                console.error(`[GemmaToolCallParser] Failed to parse Hermes format: ${error}`);
+            }
+            const fullEnd = end + endTag.length;
+            matches.push({
+                start,
+                end: fullEnd,
+                toolName,
+                rawArgs: args,
+                fullMatch: content.slice(start, fullEnd),
+            });
+            searchIndex = fullEnd;
+        }
+        return matches;
+    }
+    findInvokeToolRequests(content) {
+        const matches = [];
+        const tagPrefix = '<invoke';
+        const closing = '</invoke>';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(tagPrefix, searchIndex);
+            if (start === -1) {
+                break;
+            }
+            const tagEnd = this.findTagClose(content, start + tagPrefix.length);
+            if (tagEnd === -1) {
+                break;
+            }
+            const header = content.slice(start + tagPrefix.length, tagEnd);
+            const attributes = this.parseAttributeArguments(header);
+            const toolNameValue = attributes.name;
+            const toolName = typeof toolNameValue === 'string' ? toolNameValue.trim() : '';
+            const bodyStart = tagEnd + 1;
+            const closingIndex = content.indexOf(closing, bodyStart);
+            if (!toolName || closingIndex === -1) {
+                searchIndex = bodyStart;
+                continue;
+            }
+            const fullEnd = closingIndex + closing.length;
+            matches.push({
+                start,
+                end: fullEnd,
+                toolName,
+                rawArgs: content.slice(bodyStart, closingIndex),
+                fullMatch: content.slice(start, fullEnd),
+            });
+            searchIndex = fullEnd;
+        }
+        return matches;
+    }
+    findGenericXmlToolRequests(content) {
+        const matches = [];
+        const startTag = '<tool>';
+        const endTag = '</tool>';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(startTag, searchIndex);
+            if (start === -1)
+                break;
+            const end = content.indexOf(endTag, start + startTag.length);
+            if (end === -1)
+                break;
+            const inner = content.slice(start + startTag.length, end);
+            const nameMatch = inner.match(/<name>([^<]+)<\/name>/i);
+            const argsMatch = inner.match(/<arguments>([\s\S]*?)<\/arguments>/i);
+            if (!nameMatch || !argsMatch) {
+                searchIndex = end + endTag.length;
+                continue;
+            }
+            const fullEnd = end + endTag.length;
+            matches.push({
+                start,
+                end: fullEnd,
+                toolName: nameMatch[1].trim(),
+                rawArgs: argsMatch[1],
+                fullMatch: content.slice(start, fullEnd),
+            });
+            searchIndex = fullEnd;
+        }
+        return matches;
+    }
+    findUseToolRequests(content) {
+        const matches = [];
+        const prefix = '<use';
+        const closing = '</use>';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(prefix, searchIndex);
+            if (start === -1)
+                break;
+            const tagEnd = this.findTagClose(content, start + prefix.length);
+            if (tagEnd === -1)
+                break;
+            const header = content.slice(start + prefix.length, tagEnd);
+            const { toolName, attributeText } = this.extractToolNameAndAttributes(header);
+            const closingIndex = content.startsWith(closing, tagEnd + 1)
+                ? tagEnd + 1 + closing.length
+                : tagEnd + 1;
+            if (!toolName) {
+                searchIndex = tagEnd + 1;
+                continue;
+            }
+            matches.push({
+                start,
+                end: closingIndex,
+                toolName,
+                rawArgs: this.parseAttributeArguments(attributeText),
+                fullMatch: content.slice(start, closingIndex),
+            });
+            searchIndex = closingIndex;
+        }
+        return matches;
+    }
+    findUseUnderscoreToolRequests(content) {
+        const matches = [];
+        const prefix = '<use_';
+        let searchIndex = 0;
+        while (searchIndex < content.length) {
+            const start = content.indexOf(prefix, searchIndex);
+            if (start === -1)
+                break;
+            let nameEnd = start + prefix.length;
+            while (nameEnd < content.length &&
+                /[A-Za-z0-9_.-]/.test(content[nameEnd])) {
+                nameEnd++;
+            }
+            const toolName = content.slice(start + prefix.length, nameEnd);
+            const tagEnd = this.findTagClose(content, nameEnd);
+            if (tagEnd === -1)
+                break;
+            const attributeText = content.slice(nameEnd, tagEnd);
+            const closingTag = `</use_${toolName}>`;
+            const bodyEnd = tagEnd + 1;
+            const closingIndex = content.startsWith(closingTag, bodyEnd)
+                ? bodyEnd + closingTag.length
+                : bodyEnd;
+            if (!toolName) {
+                searchIndex = bodyEnd;
+                continue;
             }
+            matches.push({
+                start,
+                end: closingIndex,
+                toolName,
+                rawArgs: this.parseAttributeArguments(attributeText),
+                fullMatch: content.slice(start, closingIndex),
+            });
+            searchIndex = closingIndex;
+        }
+        return matches;
+    }
+    findKeyValueToolRequests(content) {
+        const matches = [];
+        let match;
+        while ((match = this.keyValuePattern.exec(content)) !== null) {
+            const fullMatch = match[0];
+            matches.push({
+                start: match.index,
+                end: match.index + fullMatch.length,
+                toolName: match[1],
+                rawArgs: this.parseKeyValuePairs(match[2]),
+                fullMatch,
+            });
+        }
+        this.keyValuePattern.lastIndex = 0;
+        return matches;
+    }
+    removeMatchedRanges(content, ranges) {
+        if (ranges.length === 0) {
+            return content;
+        }
+        const sorted = ranges
+            .filter(({ start, end }) => start < end)
+            .sort((a, b) => a.start - b.start);
+        const merged = [];
+        for (const range of sorted) {
+            const last = merged[merged.length - 1];
+            if (last && range.start <= last.end) {
+                last.end = Math.max(last.end, range.end);
+            }
+            else {
+                merged.push({ ...range });
+            }
+        }
+        let cursor = 0;
+        const pieces = [];
+        for (const range of merged) {
+            if (cursor < range.start) {
+                pieces.push(content.slice(cursor, range.start));
+            }
+            cursor = Math.max(cursor, range.end);
         }
-        // Clean up stray markers that were not matched (best effort) but preserve original whitespace
-        cleanedContent = cleanedContent
+        pieces.push(content.slice(cursor));
+        return pieces.join('');
+    }
+    postProcessCleanedContent(content) {
+        return content
             .replace(/\[TOOL_REQUEST(?:_END)?]/g, '')
             .replace(/<\|im_start\|>assistant/g, '')
             .replace(/<\|im_end\|>/g, '')
-            .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '') // Remove any remaining tool_call tags
-            .replace(/<function_calls>[\s\S]*?<\/function_calls>/g, '') // Remove function_calls wrapper
-            .replace(/<invoke[\s\S]*?<\/invoke>/g, '') // Remove any remaining invoke tags
-            .replace(/<tool>[\s\S]*?<\/tool>/g, '') // Remove any remaining tool tags
-            .replace(/<\/use_[a-zA-Z0-9_.-]+>/g, '') // Remove closing custom use_ tags
-            .replace(/<\/use>/g, '') // Remove generic closing use tags
-            // .replace(/<think>[\s\S]*?<\/think>/g, '') // Keep think tags visible by default
-            .replace(/<tool_call>\s*\{[^}]*$/gm, '') // Remove incomplete tool calls
-            .replace(/\{"name"\s*:\s*"[^"]*"\s*,?\s*"arguments"\s*:\s*\{[^}]*$/gm, '') // Remove incomplete JSON tool calls
+            .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '')
+            .replace(/<function_calls>[\s\S]*?<\/function_calls>/g, '')
+            .replace(/<invoke[\s\S]*?<\/invoke>/g, '')
+            .replace(/<tool>[\s\S]*?<\/tool>/g, '')
+            .replace(/<\/use_[A-Za-z0-9_.-]+>/g, '')
+            .replace(/<\/use>/g, '')
+            .replace(/<tool_call>\s*\{[^}]*$/gm, '')
+            .replace(/\{"name"\s*:\s*"[^"]*"\s*,?\s*"arguments"\s*:\s*\{[^}]*$/gm, '')
             .replace(/✦\s*<think>/g, '')
-            .trim();
-        // Collapse multiple consecutive newlines/spaces after removing tool calls
-        cleanedContent = cleanedContent
             .replace(/\n\s*\n/g, '\n')
             .replace(/\n/g, ' ')
             .trim();
-        return {
-            cleanedContent,
-            toolCalls,
-        };
+    }
+    normalizeArguments(args, toolName, fullMatch) {
+        if (typeof args !== 'string') {
+            return args;
+        }
+        try {
+            if (args.includes('<parameter') ||
+                (args.includes('<') && args.includes('>'))) {
+                return this.parseXMLParameters(args);
+            }
+            return JSON.parse(args);
+        }
+        catch (error) {
+            const repaired = this.tryRepairJson(args);
+            if (repaired) {
+                try {
+                    return JSON.parse(repaired);
+                }
+                catch {
+                    // ignore and fall through
+                }
+            }
+            const simpleJsonMatch = args.match(/^{[^{]*}$/);
+            if (simpleJsonMatch) {
+                try {
+                    return JSON.parse(simpleJsonMatch[0]);
+                }
+                catch {
+                    // fall through to logging
+                }
+            }
+            console.error(`[GemmaToolCallParser] Failed to parse tool arguments for ${toolName}:`, error);
+            console.error(`[GemmaToolCallParser] Raw arguments excerpt: ${fullMatch.slice(0, 200)}`);
+            return null;
+        }
+    }
+    extractBalancedSegment(content, startIndex, openChar, closeChar) {
+        if (content[startIndex] !== openChar) {
+            return null;
+        }
+        let depth = 0;
+        let inString = null;
+        let escapeNext = false;
+        for (let i = startIndex; i < content.length; i++) {
+            const char = content[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\' && inString) {
+                escapeNext = true;
+                continue;
+            }
+            if (inString) {
+                if (char === inString) {
+                    inString = null;
+                }
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                inString = char;
+                continue;
+            }
+            if (char === openChar) {
+                depth++;
+            }
+            else if (char === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    return {
+                        segment: content.slice(startIndex, i + 1),
+                        endIndex: i + 1,
+                    };
+                }
+            }
+        }
+        return null;
     }
     // Best-effort repair for JSON with unescaped inner quotes in string values.
     tryRepairJson(args) {
@@ -228,7 +466,7 @@ export class GemmaToolCallParser {
         catch {
             // Target only inner quotes within JSON string values, preserving multibyte and spacing
             // e.g., { "command": "printf "ありがとう 世界"" } -> { "command": "printf \"ありがとう 世界\"" }
-            const repaired = args.replace(/:(\s)*"((?:\\.|[^"])*?)"(\s*)([,}])/gs, (_m, s1, val, s2, tail) => {
+            const repaired = args.replace(/:(\s*)"((?:\\.|[^"\\])*)"(\s*)([,}])/g, (_m, s1, val, s2, tail) => {
                 // Escape only unescaped quotes inside the value
                 const fixed = val.replace(/(?<!\\)"/g, '\\"');
                 return `:${s1}"${fixed}"${s2}${tail}`;
@@ -279,6 +517,88 @@ export class GemmaToolCallParser {
         }
         return args;
     }
+    parseAttributeArguments(attributeText) {
+        const args = {};
+        const text = attributeText ?? '';
+        const length = text.length;
+        let index = 0;
+        const readIdentifier = () => {
+            const start = index;
+            while (index < length && /[A-Za-z0-9_.-]/.test(text.charAt(index))) {
+                index++;
+            }
+            return text.slice(start, index);
+        };
+        const skipWhitespace = () => {
+            while (index < length && /\s/.test(text.charAt(index))) {
+                index++;
+            }
+        };
+        while (index < length) {
+            skipWhitespace();
+            const key = readIdentifier();
+            if (!key) {
+                index++;
+                continue;
+            }
+            skipWhitespace();
+            if (text.charAt(index) !== '=') {
+                index++;
+                continue;
+            }
+            index++;
+            skipWhitespace();
+            const quote = text.charAt(index);
+            if (quote !== '"' && quote !== "'") {
+                index++;
+                continue;
+            }
+            index++;
+            let value = '';
+            let escaped = false;
+            while (index < length) {
+                const char = text.charAt(index);
+                index++;
+                if (escaped) {
+                    value += char;
+                    escaped = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escaped = true;
+                    continue;
+                }
+                if (char === quote) {
+                    break;
+                }
+                value += char;
+            }
+            const unescaped = value.trim();
+            if (!key) {
+                continue;
+            }
+            if (unescaped.startsWith('{') || unescaped.startsWith('[')) {
+                try {
+                    args[key] = JSON.parse(unescaped);
+                    continue;
+                }
+                catch {
+                    // fall through to scalar handling
+                }
+            }
+            if (/^-?\d+(\.\d+)?$/.test(unescaped)) {
+                args[key] = Number(unescaped);
+            }
+            else if (unescaped.toLowerCase() === 'true' ||
+                unescaped.toLowerCase() === 'false') {
+                args[key] = unescaped.toLowerCase() === 'true';
+            }
+            else {
+                args[key] = unescaped;
+            }
+        }
+        return args;
+    }
     parseXMLParameters(xmlContent) {
         const args = {};
         // Parse Claude-style <parameter name="key">value</parameter>
@@ -316,5 +636,39 @@ export class GemmaToolCallParser {
             .replace(/&quot;/g, '"')
             .replace(/&#39;/g, "'");
     }
+    findTagClose(content, fromIndex) {
+        let inQuote = null;
+        for (let i = fromIndex; i < content.length; i++) {
+            const char = content[i];
+            if (inQuote) {
+                if (char === inQuote && content[i - 1] !== '\\') {
+                    inQuote = null;
+                }
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                inQuote = char;
+                continue;
+            }
+            if (char === '>') {
+                return i;
+            }
+        }
+        return -1;
+    }
+    extractToolNameAndAttributes(header) {
+        let index = 0;
+        const length = header.length;
+        while (index < length && /\s/.test(header.charAt(index))) {
+            index++;
+        }
+        const nameStart = index;
+        while (index < length && /[A-Za-z0-9_.-]/.test(header.charAt(index))) {
+            index++;
+        }
+        const toolName = header.slice(nameStart, index).trim();
+        const attributeText = header.slice(index);
+        return { toolName, attributeText };
+    }
 }
 //# sourceMappingURL=TextToolCallParser.js.map