@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/utils/tools/dialect.js

@@ -1,20 +0,0 @@
-/**
- * Detects the tool-call dialect from a model's registry name and file path.
- * Defaults to "hermes" (its parser chain also covers unknown JSON-payload
- * models). Bypass with `completion({ toolDialect })`.
- */
-export function detectToolDialectFromName(name, path) {
-    const basename = path.toLowerCase().split(/[/\\]/).pop() ?? '';
-    const tag = `${(name ?? '').toLowerCase()}|${basename}`;
-    if (/qwen3[._-]?[56](?![a-z0-9])/.test(tag))
-        return 'qwen35';
-    if (/gemma[-_]?4(?=[^a-z0-9]|$)/.test(tag))
-        return 'gemma4';
-    if (/gpt[_-]?oss/.test(tag))
-        return 'harmony';
-    if (/deepseek[-_. ]?v(?:4|3[._-]?2)(?![0-9])/.test(tag))
-        return 'dsml';
-    if (/lfm[_-]?\d/.test(tag))
-        return 'pythonic';
-    return 'hermes';
-}

package/dist/server/utils/tools/index.d.ts

@@ -1,3 +0,0 @@
-export { detectToolDialectFromName } from './dialect.js';
-export { parseToolCalls } from './parser.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/utils/tools/index.js

@@ -1,2 +0,0 @@
-export { detectToolDialectFromName } from './dialect.js';
-export { parseToolCalls } from './parser.js';

package/dist/server/utils/tools/parser.d.ts

@@ -1,6 +0,0 @@
-import type { Tool, ToolCall, ToolCallError, ToolDialect } from '../../../schemas/index.js';
-export declare function parseToolCalls(text: string, tools: Tool[], dialect?: ToolDialect): {
-    toolCalls: ToolCall[];
-    errors: ToolCallError[];
-};
-//# sourceMappingURL=parser.d.ts.map

package/dist/server/utils/tools/parser.js

@@ -1,69 +0,0 @@
-import { stripThinkingBlocks } from '../../../server/utils/tools/shared.js';
-import { parseGemmaFormat, parseGenericFormat, parseLlamacppFormat } from '../../../server/utils/tools/parsers/json.js';
-import { parseHermesFormat } from '../../../server/utils/tools/parsers/hermes.js';
-import { parsePythonicFormat } from '../../../server/utils/tools/parsers/pythonic.js';
-import { parseHarmonyFormat } from '../../../server/utils/tools/parsers/harmony.js';
-import { parseQwen35Format } from '../../../server/utils/tools/parsers/qwen35.js';
-import { parseGemma4NativeFormat } from '../../../server/utils/tools/parsers/gemma4native.js';
-import { parseDsmlFormat } from '../../../server/utils/tools/parsers/dsml.js';
-function pickFormatParsers(dialect) {
-    switch (dialect) {
-        case 'pythonic':
-            return [parsePythonicFormat];
-        case 'hermes':
-            // Hermes first so frame errors surface; JSON fallbacks then cover
-            // unknown JSON-payload models.
-            return [parseHermesFormat, parseGemmaFormat, parseLlamacppFormat];
-        case 'json':
-            return [parseGemmaFormat, parseLlamacppFormat];
-        case 'harmony':
-            return [parseHarmonyFormat];
-        case 'qwen35':
-            // Hermes fallback: Qwen3.5 templates sometimes emit OpenAI-style JSON
-            // when the native XML format fails; Hermes chain recovers those.
-            return [parseQwen35Format, parseHermesFormat];
-        case 'gemma4':
-            // No JSON fallback: Gemma4 emits only its native channel-thought dialect
-            // and never falls back to JSON-envelope formats.
-            return [parseGemma4NativeFormat];
-        case 'dsml':
-            // Hermes fallback: DeepSeek templates fall back to OpenAI-style JSON when
-            // the DSML block fails to materialise.
-            return [parseDsmlFormat, parseHermesFormat, parseLlamacppFormat];
-        default:
-            // DSML first: the `<｜DSML｜` token is unique to DeepSeek and can't
-            // false-match another dialect.
-            // Gemma4 next: `<|tool_call>` is uniquely distinctive and can't
-            // false-match other dialects.
-            // Harmony next: `to=functions.` is also uniquely Harmony.
-            // Qwen35 before Hermes: defers to Hermes when JSON is inside <tool_call>,
-            // so the XML path is recovered without breaking Hermes-JSON payloads.
-            // Pythonic last: its bare `[name(...)]` form can match payloads that
-            // look like other dialects.
-            return [
-                parseDsmlFormat,
-                parseGemma4NativeFormat,
-                parseHarmonyFormat,
-                parseQwen35Format,
-                parseHermesFormat,
-                parseGemmaFormat,
-                parseLlamacppFormat,
-                parsePythonicFormat
-            ];
-    }
-}
-export function parseToolCalls(text, tools, dialect) {
-    if (!tools || tools.length === 0) {
-        return { toolCalls: [], errors: [] };
-    }
-    const cleaned = stripThinkingBlocks(text);
-    const formatParsers = pickFormatParsers(dialect);
-    for (const parser of formatParsers) {
-        const result = parser(cleaned, tools);
-        if (result.matched) {
-            return { toolCalls: result.toolCalls, errors: result.errors };
-        }
-    }
-    const generic = parseGenericFormat(cleaned, tools);
-    return { toolCalls: generic.toolCalls, errors: generic.errors };
-}

package/dist/server/utils/tools/parsers/dsml.d.ts

@@ -1,4 +0,0 @@
-import type { Tool } from '../../../../schemas/index.js';
-import { type ParserResult } from '../../../../server/utils/tools/shared.js';
-export declare function parseDsmlFormat(text: string, tools: Tool[]): ParserResult;
-//# sourceMappingURL=dsml.d.ts.map

package/dist/server/utils/tools/parsers/dsml.js

@@ -1,176 +0,0 @@
-import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-// DeepSeek marks DSML tags with a fullwidth vertical line (U+FF5C `｜`), not
-// the ASCII pipe used by the visually similar `<|...|>` markers of the harmony
-// and gemma4 dialects — the two must not be conflated. V4 wraps calls in
-// `tool_calls`; V3.2 used `function_calls`. Both carry the same invoke/
-// parameter grammar, so only the wrapper name differs.
-const OPENER_REGEX = /<｜DSML｜(?:tool_calls|function_calls|invoke)/;
-const INVOKE_OPEN_REGEX = /<｜DSML｜invoke([ \t\r\n][^>]*)?>/g;
-const INVOKE_CLOSE_TAG = '</｜DSML｜invoke>';
-const PARAMETER_REGEX = /<｜DSML｜parameter([ \t\r\n][^>]*)?>([\s\S]*?)<\/｜DSML｜parameter>/g;
-const NAME_ATTR_REGEX = /(?:^|\s)name="([^"]*)"/;
-const STRING_ATTR_REGEX = /(?:^|\s)string="(true|false)"/i;
-const FALLBACK_DIALECT_REGEX = /<tool_call>|"name"\s*:/;
-function coerceBySchemaType(value, type) {
-    switch (type) {
-        case 'number': {
-            const n = Number(value);
-            if (value.length === 0 || Number.isNaN(n))
-                throw new Error(`invalid number value: "${value}"`);
-            return n;
-        }
-        case 'integer': {
-            const n = Number(value);
-            if (value.length === 0 || Number.isNaN(n) || !Number.isInteger(n))
-                throw new Error(`invalid integer value: "${value}"`);
-            return n;
-        }
-        case 'boolean': {
-            const v = value.toLowerCase();
-            if (v === 'true')
-                return true;
-            if (v === 'false')
-                return false;
-            throw new Error(`invalid boolean value: "${value}"`);
-        }
-        case 'array':
-        case 'object':
-            return JSON.parse(value);
-        default:
-            return value;
-    }
-}
-function coerceParamValue(raw, isString, type) {
-    const trimmed = raw.trim();
-    if (isString === undefined)
-        return coerceBySchemaType(trimmed, type);
-    if (isString === 'true')
-        return trimmed;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch (err) {
-        throw new Error(`invalid JSON for string="false" parameter: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-function collectInvokes(text) {
-    const openers = Array.from(text.matchAll(INVOKE_OPEN_REGEX));
-    return openers.map((opener, i) => {
-        const start = opener.index;
-        const bodyStart = start + opener[0].length;
-        const limit = openers[i + 1]?.index ?? text.length;
-        const rel = text.slice(bodyStart, limit).indexOf(INVOKE_CLOSE_TAG);
-        const closed = rel !== -1;
-        const closeAt = bodyStart + rel;
-        const end = closed ? closeAt + INVOKE_CLOSE_TAG.length : limit;
-        return {
-            attrs: opener[1] ?? '',
-            body: closed ? text.slice(bodyStart, closeAt) : '',
-            closed,
-            start,
-            consumedEnd: closed ? end : bodyStart,
-            raw: text.slice(start, end).trim()
-        };
-    });
-}
-function textOutsideInvokes(text, invokes) {
-    const parts = [];
-    let cursor = 0;
-    for (const invoke of invokes) {
-        parts.push(text.slice(cursor, invoke.start));
-        cursor = invoke.consumedEnd;
-    }
-    parts.push(text.slice(cursor));
-    return parts.join('\n');
-}
-// Parses DeepSeek's DSML tool-call dialect (V3.2 / V4):
-//   <｜DSML｜tool_calls>
-//   <｜DSML｜invoke name="NAME">
-//   <｜DSML｜parameter name="KEY" string="true">VALUE</｜DSML｜parameter>
-//   </｜DSML｜invoke>
-//   </｜DSML｜tool_calls>
-export function parseDsmlFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    if (!OPENER_REGEX.test(text)) {
-        return { matched: false, toolCalls, errors };
-    }
-    // Invokes are collected from the whole text rather than per block: a block
-    // cut off before its close tag still carries complete invokes, and a single
-    // pass recovers them without re-counting the ones inside closed blocks.
-    const invokes = collectInvokes(text);
-    if (invokes.length === 0) {
-        if (FALLBACK_DIALECT_REGEX.test(text)) {
-            return { matched: false, toolCalls, errors };
-        }
-        return {
-            matched: true,
-            toolCalls,
-            errors: [
-                {
-                    code: 'PARSE_ERROR',
-                    message: 'DSML tool call block contains no <｜DSML｜invoke name="NAME"> element',
-                    raw: text.trim()
-                }
-            ]
-        };
-    }
-    for (const invoke of invokes) {
-        const raw = invoke.raw;
-        if (!invoke.closed) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `DSML invoke is missing its ${INVOKE_CLOSE_TAG} close tag`,
-                raw
-            });
-            continue;
-        }
-        const name = NAME_ATTR_REGEX.exec(invoke.attrs)?.[1]?.trim();
-        if (!name) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: 'DSML invoke is missing a name attribute',
-                raw
-            });
-            continue;
-        }
-        const properties = tools.find((t) => t.name === name)?.parameters?.properties ?? {};
-        const args = {};
-        let parseError;
-        for (const param of invoke.body.matchAll(PARAMETER_REGEX)) {
-            const attrs = param[1] ?? '';
-            const key = NAME_ATTR_REGEX.exec(attrs)?.[1]?.trim();
-            if (!key) {
-                parseError = 'DSML parameter is missing a name attribute';
-                break;
-            }
-            const isString = STRING_ATTR_REGEX.exec(attrs)?.[1]?.toLowerCase();
-            try {
-                args[key] = coerceParamValue(param[2], isString, properties[key]?.type);
-            }
-            catch (err) {
-                parseError = `${key}: ${err instanceof Error ? err.message : String(err)}`;
-                break;
-            }
-        }
-        if (parseError !== undefined) {
-            errors.push({ code: 'PARSE_ERROR', message: parseError, raw });
-            continue;
-        }
-        const validation = validateToolArguments(name, args, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({ ...validation.error, raw });
-            continue;
-        }
-        toolCalls.push({
-            id: generateStableToolCallId(name, args),
-            name,
-            arguments: args,
-            raw
-        });
-    }
-    if (toolCalls.length === 0 && FALLBACK_DIALECT_REGEX.test(textOutsideInvokes(text, invokes))) {
-        return { matched: false, toolCalls: [], errors: [] };
-    }
-    return { matched: true, toolCalls, errors };
-}

package/dist/server/utils/tools/parsers/gemma4native.d.ts

@@ -1,4 +0,0 @@
-import type { Tool } from '../../../../schemas/index.js';
-import { type ParserResult } from '../../../../server/utils/tools/shared.js';
-export declare function parseGemma4NativeFormat(text: string, tools: Tool[]): ParserResult;
-//# sourceMappingURL=gemma4native.d.ts.map

package/dist/server/utils/tools/parsers/gemma4native.js

@@ -1,65 +0,0 @@
-import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-// Transliterates Gemma 4's JS-literal argument body to valid JSON so it can
-// be parsed with JSON.parse. The body uses:
-//   - <|"|>...<|"|> instead of "..." for string values
-//   - bare (unquoted) object keys
-// Strategy: split by <|"|> tokens so structural parts (even indices) and
-// string value parts (odd indices) are processed separately, preventing
-// the key-quoting regex from matching `, key:` patterns inside string values.
-function gemmaArgsToJson(argsRaw) {
-    const parts = ('{' + argsRaw + '}').split(/<\|"\|>/);
-    return parts
-        .map((part, i) => i % 2 === 0
-        ? part.replace(/([{,]\s*)([A-Za-z_][\w-]*)\s*:/g, '$1"$2":')
-        : '"' +
-            part
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"')
-                .replace(/[\x00-\x1f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`) +
-            '"')
-        .join('');
-}
-// Parses Gemma 4's native tool-call dialect:
-//   <|tool_call>call:NAME{key:<|"|>val<|"|>,key2:bareNum,...}<tool_call|>
-// Keys are bare identifiers; string values are wrapped in <|"|>...<|"|>;
-// numbers/booleans are bare literals; nested objects/arrays use JS-literal
-// syntax throughout. Transliterates to JSON then parses.
-export function parseGemma4NativeFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    if (!text.includes('<|tool_call>')) {
-        return { matched: false, toolCalls, errors };
-    }
-    const callRegex = /<\|tool_call>call:([A-Za-z_][\w-]*)\{([\s\S]*?)\}<tool_call\|>/g;
-    const matches = Array.from(text.matchAll(callRegex));
-    if (matches.length === 0)
-        return { matched: false, toolCalls, errors };
-    for (const match of matches) {
-        const name = match[1];
-        const argsRaw = match[2];
-        let args;
-        try {
-            args = JSON.parse(gemmaArgsToJson(argsRaw));
-        }
-        catch (err) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `Failed to parse Gemma 4 tool call arguments: ${err instanceof Error ? err.message : String(err)}`,
-                raw: match[0]
-            });
-            continue;
-        }
-        const validation = validateToolArguments(name, args, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({ ...validation.error, raw: match[0] });
-            continue;
-        }
-        toolCalls.push({
-            id: generateStableToolCallId(name, args),
-            name,
-            arguments: args,
-            raw: match[0]
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}

package/dist/server/utils/tools/parsers/harmony.d.ts

@@ -1,4 +0,0 @@
-import type { Tool } from '../../../../schemas/index.js';
-import { type ParserResult } from '../../../../server/utils/tools/shared.js';
-export declare function parseHarmonyFormat(text: string, tools: Tool[]): ParserResult;
-//# sourceMappingURL=harmony.d.ts.map

package/dist/server/utils/tools/parsers/harmony.js

@@ -1,57 +0,0 @@
-import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-const HARMONY_FRAME_RE = /to=functions\.([\w-]+)\s+<\|constrain\|>json<\|message\|>([\s\S]*?)(?=<\|call\|>|$)/g;
-export function parseHarmonyFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    if (!text.includes('to=functions.')) {
-        return { matched: false, toolCalls, errors };
-    }
-    HARMONY_FRAME_RE.lastIndex = 0;
-    let m;
-    while ((m = HARMONY_FRAME_RE.exec(text)) !== null) {
-        const name = m[1];
-        const payload = m[2]?.trim();
-        const raw = m[0];
-        if (!name || payload === undefined)
-            continue;
-        let parsedArgs;
-        try {
-            parsedArgs = JSON.parse(payload);
-        }
-        catch (error) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `Failed to parse Harmony tool call JSON for ${name}: ${error instanceof Error ? error.message : String(error)}`,
-                raw
-            });
-            continue;
-        }
-        if (typeof parsedArgs !== 'object' || parsedArgs === null || Array.isArray(parsedArgs)) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `Harmony tool call payload for ${name} is not a JSON object`,
-                raw
-            });
-            continue;
-        }
-        const args = parsedArgs;
-        const validation = validateToolArguments(name, args, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({ ...validation.error, raw });
-            continue;
-        }
-        toolCalls.push({
-            id: generateStableToolCallId(name, args),
-            name,
-            arguments: args,
-            raw
-        });
-    }
-    // Defer `matched` to extraction so partial Harmony shapes fall through
-    // to the next parser instead of short-circuiting the chain.
-    return {
-        matched: toolCalls.length > 0 || errors.length > 0,
-        toolCalls,
-        errors
-    };
-}

package/dist/server/utils/tools/parsers/hermes.d.ts

@@ -1,4 +0,0 @@
-import type { Tool } from '../../../../schemas/index.js';
-import { type ParserResult } from '../../../../server/utils/tools/shared.js';
-export declare function parseHermesFormat(text: string, tools: Tool[]): ParserResult;
-//# sourceMappingURL=hermes.d.ts.map

package/dist/server/utils/tools/parsers/hermes.js

@@ -1,122 +0,0 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-// Qwen3.5/3.6 can fuse its two tool templates into one frame, embedding the
-// XML `<function=NAME>` token as a bare string key inside the JSON envelope:
-//   {"function=NAME","arguments":{...}}  (invalid JSON, not parseable as-is)
-// Rewrite only that exact shape to a canonical `{"name":NAME,"arguments":...}`
-// frame. Kept deliberately narrow so well-formed JSON frames are never touched.
-function repairFunctionEqualsJson(candidate) {
-    const match = /^\{\s*"function=([^"]+)"\s*,\s*"arguments"\s*:\s*([\s\S]+)\}\s*$/.exec(candidate);
-    if (!match)
-        return undefined;
-    return `{"name":${JSON.stringify(match[1])},"arguments":${match[2]}}`;
-}
-function parseHermesJson(candidate) {
-    try {
-        return JSON.parse(candidate);
-    }
-    catch (err) {
-        const repaired = repairFunctionEqualsJson(candidate);
-        if (repaired === undefined)
-            throw err;
-        return JSON.parse(repaired);
-    }
-}
-// Hermes-style: JSON payload wrapped in `<tool_call>...</tool_call>` tags
-export function parseHermesFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    if (!text.includes('<tool_call>')) {
-        return { matched: false, toolCalls, errors };
-    }
-    // Incomplete frame: open marker without close (cutoff/abort). Recover
-    // the inner buffer here — fallthrough to JSON parsers can't strip the
-    // `<tool_call>` prefix on its own.
-    if (!text.includes('</tool_call>')) {
-        return recoverIncompleteHermesFrame(text, tools);
-    }
-    const toolCallRegex = /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g;
-    const matches = Array.from(text.matchAll(toolCallRegex));
-    for (const match of matches) {
-        const callJson = match[1];
-        if (!callJson)
-            continue;
-        const trimmedJson = callJson.trim();
-        let callItem;
-        try {
-            callItem = parseHermesJson(trimmedJson);
-        }
-        catch (error) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `Failed to parse Hermes tool call: ${error instanceof Error ? error.message : String(error)}`,
-                raw: trimmedJson
-            });
-            continue;
-        }
-        if (!isValidToolCall(callItem)) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: 'Hermes tool call is missing name/arguments',
-                raw: trimmedJson
-            });
-            continue;
-        }
-        const call = callItem;
-        const validation = validateToolArguments(call.name, call.arguments, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({
-                ...validation.error,
-                raw: trimmedJson
-            });
-            continue;
-        }
-        toolCalls.push({
-            id: call.id || generateStableToolCallId(call.name, call.arguments),
-            name: call.name,
-            arguments: call.arguments,
-            raw: trimmedJson
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}
-// Strips a possible truncated close-tag tail (`</tool`, `</tool_c`)
-// before parsing. Bounded to buffers that actually contain the open marker.
-function recoverIncompleteHermesFrame(text, tools) {
-    const openIdx = text.indexOf('<tool_call>');
-    const inner = text.slice(openIdx + '<tool_call>'.length).trim();
-    const partialCloseIdx = inner.search(/<\/tool/);
-    const candidate = partialCloseIdx === -1 ? inner : inner.slice(0, partialCloseIdx).trim();
-    if (candidate.length === 0) {
-        return { matched: false, toolCalls: [], errors: [] };
-    }
-    let parsed;
-    try {
-        parsed = parseHermesJson(candidate);
-    }
-    catch {
-        return { matched: false, toolCalls: [], errors: [] };
-    }
-    if (!isValidToolCall(parsed)) {
-        return { matched: false, toolCalls: [], errors: [] };
-    }
-    const validation = validateToolArguments(parsed.name, parsed.arguments, tools);
-    if (!validation.isValid && validation.error) {
-        return {
-            matched: true,
-            toolCalls: [],
-            errors: [{ ...validation.error, raw: candidate }]
-        };
-    }
-    return {
-        matched: true,
-        toolCalls: [
-            {
-                id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
-                name: parsed.name,
-                arguments: parsed.arguments,
-                raw: candidate
-            }
-        ],
-        errors: []
-    };
-}

package/dist/server/utils/tools/parsers/json.d.ts

@@ -1,6 +0,0 @@
-import type { Tool } from '../../../../schemas/index.js';
-import { type ParserResult } from '../../../../server/utils/tools/shared.js';
-export declare function parseGemmaFormat(text: string, tools: Tool[]): ParserResult;
-export declare function parseLlamacppFormat(text: string, tools: Tool[]): ParserResult;
-export declare function parseGenericFormat(text: string, tools: Tool[]): ParserResult;
-//# sourceMappingURL=json.d.ts.map

package/dist/server/utils/tools/parsers/json.js

@@ -1,115 +0,0 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-export function parseGemmaFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        return { matched: false, toolCalls, errors };
-    }
-    if (!parsed ||
-        typeof parsed !== 'object' ||
-        !('tool_calls' in parsed) ||
-        !Array.isArray(parsed.tool_calls)) {
-        return { matched: false, toolCalls, errors };
-    }
-    for (const callItem of parsed.tool_calls) {
-        if (!isValidToolCall(callItem)) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: 'Gemma tool_calls entry is missing name/arguments',
-                raw: JSON.stringify(callItem)
-            });
-            continue;
-        }
-        const call = callItem;
-        const validation = validateToolArguments(call.name, call.arguments, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({
-                ...validation.error,
-                raw: JSON.stringify(call)
-            });
-            continue;
-        }
-        toolCalls.push({
-            id: call.id || generateStableToolCallId(call.name, call.arguments),
-            name: call.name,
-            arguments: call.arguments,
-            raw: JSON.stringify(call)
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}
-export function parseLlamacppFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    let parsedItem;
-    try {
-        parsedItem = JSON.parse(text);
-    }
-    catch {
-        return { matched: false, toolCalls, errors };
-    }
-    if (!isValidToolCall(parsedItem)) {
-        return { matched: false, toolCalls, errors };
-    }
-    const parsed = parsedItem;
-    const validation = validateToolArguments(parsed.name, parsed.arguments, tools);
-    if (!validation.isValid && validation.error) {
-        errors.push({
-            ...validation.error,
-            raw: text
-        });
-    }
-    else {
-        toolCalls.push({
-            id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
-            name: parsed.name,
-            arguments: parsed.arguments,
-            raw: text
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}
-// Last-resort fallback: loose JSON `{"name":..., "arguments":...}` objects
-// anywhere in the text. Runs after dialect-specific parsers all miss.
-export function parseGenericFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    const jsonObjectRegex = /\{[\s\S]*?"name"[\s\S]*?"arguments"[\s\S]*?\}/g;
-    let match;
-    let matched = false;
-    while ((match = jsonObjectRegex.exec(text)) !== null) {
-        matched = true;
-        try {
-            const objItem = JSON.parse(match[0]);
-            if (isValidToolCall(objItem)) {
-                const obj = objItem;
-                const validation = validateToolArguments(obj.name, obj.arguments, tools);
-                if (!validation.isValid && validation.error) {
-                    errors.push({
-                        ...validation.error,
-                        raw: match[0]
-                    });
-                    continue;
-                }
-                toolCalls.push({
-                    id: obj.id || generateStableToolCallId(obj.name, obj.arguments),
-                    name: obj.name,
-                    arguments: obj.arguments,
-                    raw: match[0]
-                });
-            }
-        }
-        catch (error) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: `Failed to parse generic tool call: ${error instanceof Error ? error.message : String(error)}`,
-                raw: match[0]
-            });
-        }
-    }
-    return { matched, toolCalls, errors };
-}