@nhtio/adk 1.20260625.0 → 1.20260626.0

package/reasoning_parsers-Dp66LFBt.mjs

@@ -0,0 +1,747 @@
+import { u as isObject } from "./tool_registry-Bj0JhXCv.mjs";
+import "./guards.mjs";
+//#region src/batteries/llm/chat_common/tool_parsers.ts
+/**
+* Runtime-agnostic tool-call text parsers for text-only LLM batteries.
+*
+* @remarks
+* **Why this exists.** On-device runtimes like transformers.js and LiteRT-LM (v0.13.1) are
+* text-in / text-out: they inject tool definitions into the chat template, but the model emits its
+* tool calls as **raw text in the assistant message**, in a format specific to the model family it
+* was fine-tuned on. Unlike the OpenAI/Ollama wire batteries — where the provider returns a
+* structured `tool_calls` array — these batteries must parse the call out of the text themselves.
+*
+* This mirrors how vLLM / SGLang / Ollama do it: one **post-hoc** parser per model family, selected
+* by a flag, run *after* generation (sub-millisecond, fails gracefully, never constrains decoding).
+* Each family parser is anchored on a literal marker (or, for the weak-signal JSON/pythonic forms, on
+* the callee name matching a real tool) so cross-family false positives are structurally impossible.
+*
+* **Formats are model-specific and drift across versions** (e.g. Gemma has three incompatible tool
+* formats across its generations; gpt-oss's Harmony channel ordering is an active upstream bug). The
+* bundled defaults target the small ONNX models that actually run in transformers.js; the `'auto'`
+* driver fails gracefully and a custom {@link ToolCallParserFn} is the escape hatch for anything else.
+*
+* NOT `@module`-tagged: private to the bundled LLM batteries, re-exported through their public
+* surfaces (`transformers_js`, `litert_lm`). Consumers import from those battery subpaths.
+*/
+var NO_MATCH$1 = (rawText) => ({
+	calls: [],
+	cleanedText: rawText
+});
+var asArgsObject = (value) => isObject(value) ? value : {};
+/**
+* Remove a set of `[start, end)` spans from `text` (descending by start so offsets stay valid),
+* collapse the resulting whitespace seams, and trim.
+*/
+var removeSpans$1 = (text, spans) => {
+	let out = text;
+	for (const [start, end] of [...spans].sort((a, b) => b[0] - a[0])) out = out.slice(0, start) + out.slice(end);
+	return out.replace(/\n{3,}/g, "\n\n").trim();
+};
+/** Try to JSON.parse; return undefined on failure (parsers decline rather than throw). */
+var tryJsonParse = (s) => {
+	try {
+		return JSON.parse(s);
+	} catch {
+		return;
+	}
+};
+/**
+* From `text`, with `from` pointing AT an opening `open` char, return the index of its matching
+* `close` char — string-aware, so a delimiter inside a JSON string literal (e.g. a `}` or `]` or a
+* `</tool_call>`-shaped substring inside `{"text":"…"}`) is NOT miscounted. Returns -1 if the run is
+* unbalanced (e.g. a truncated stream). This is the brace/bracket scan that makes the marker-anchored
+* parsers robust to embedded markup in argument values — the dominant failure class the red-team panel
+* found in the old lazy/greedy regexes.
+*/
+var scanBalanced = (text, from, open, close) => {
+	let depth = 0;
+	let inStr = false;
+	let escaped = false;
+	for (let i = from; i < text.length; i++) {
+		const ch = text[i];
+		if (inStr) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inStr = false;
+			continue;
+		}
+		if (ch === "\"") inStr = true;
+		else if (ch === open) depth++;
+		else if (ch === close) {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+};
+var HERMES_OPEN = "<tool_call>";
+/**
+* Parse Hermes-style `<tool_call>{"name":…,"arguments":{…}}</tool_call>` tags. The de-facto standard,
+* reused by Qwen2.5/Qwen3-Instruct. Anchored on the literal tags — zero collision with bare JSON.
+*
+* @remarks
+* The JSON object after each `<tool_call>` is located by a string-aware balanced-brace scan (not a lazy
+* `</tool_call>` regex), so an embedded `</tool_call>` or `{`/`}` inside a string argument value (e.g.
+* `{"text":"</tool_call>"}`) survives instead of truncating the call. The literal `</tool_call>` close
+* is still consumed for span removal when present immediately after the object.
+*/
+var hermesToolCallParser = (rawText) => {
+	const calls = [];
+	const spans = [];
+	let searchFrom = 0;
+	for (;;) {
+		const openIdx = rawText.indexOf(HERMES_OPEN, searchFrom);
+		if (openIdx === -1) break;
+		const braceStart = rawText.indexOf("{", openIdx + 11);
+		if (braceStart === -1) break;
+		const braceEnd = scanBalanced(rawText, braceStart, "{", "}");
+		if (braceEnd === -1) break;
+		const obj = tryJsonParse(rawText.slice(braceStart, braceEnd + 1));
+		const afterObj = rawText.slice(braceEnd + 1);
+		const closeRel = /^\s*<\/tool_call>/.exec(afterObj);
+		if (closeRel && isObject(obj) && typeof obj.name === "string") {
+			const o = obj;
+			calls.push({
+				name: o.name,
+				arguments: asArgsObject(o.arguments)
+			});
+			spans.push([openIdx, braceEnd + 1 + closeRel[0].length]);
+			searchFrom = braceEnd + 1 + closeRel[0].length;
+		} else searchFrom = braceEnd + 1;
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, spans)
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link hermesToolCallParser}. */
+var defaultHermesToolCallParser = hermesToolCallParser;
+var GEMMA_WRAP_RE = /<\|tool_call>\s*call:\s*([A-Za-z_]\w*)\s*(\{[^{}]*\})\s*<tool_call\|>/g;
+var GEMMA_BARE_RE = /call:\s*([A-Za-z_]\w*)\s*(\{[^{}]*\})/g;
+/** Normalise a Gemma arg block (`{k:<|"|>v<|"|>}` or stripped `{k:v}`) into JSON. */
+var gemmaArgsToJson = (argsBlock) => {
+	return tryJsonParse(argsBlock.replace(/<\|"\|>/g, "\"").replace(/([{,]\s*)([A-Za-z_]\w*)\s*:/g, "$1\"$2\":").replace(/:\s*(?!["\d-]|true\b|false\b|null\b)([^,}\]]+?)\s*([,}\]])/g, ":\"$1\"$2"));
+};
+/**
+* Parse Gemma E2B/E4B tool calls. Accepts the wrapped template form
+* (`<|tool_call>call:NAME{k:<|"|>v<|"|>}<tool_call|>`) AND the decoder-stripped runtime form
+* (`call:NAME{k:v}`, special tokens removed, scalars unquoted — the shape a real ONNX run emits).
+* Targets the E2B/E4B form only — Gemma 3 (`tool_code` fences) and FunctionGemma
+* (`<start_function_call>`) are out of scope (use a custom {@link ToolCallParserFn}).
+*/
+var gemmaToolCallParser = (rawText) => {
+	const calls = [];
+	const spans = [];
+	for (const m of rawText.matchAll(GEMMA_WRAP_RE)) {
+		calls.push({
+			name: m[1],
+			arguments: asArgsObject(gemmaArgsToJson(m[2]))
+		});
+		spans.push([m.index ?? 0, (m.index ?? 0) + m[0].length]);
+	}
+	if (calls.length === 0) for (const m of rawText.matchAll(GEMMA_BARE_RE)) {
+		calls.push({
+			name: m[1],
+			arguments: asArgsObject(gemmaArgsToJson(m[2]))
+		});
+		spans.push([m.index ?? 0, (m.index ?? 0) + m[0].length]);
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, spans)
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link gemmaToolCallParser}. */
+var defaultGemmaToolCallParser = gemmaToolCallParser;
+var GPT_OSS_HEAD_RE = /<\|channel\|>commentary\s+to=functions\.([A-Za-z0-9_]+)[\s\S]*?<\|message\|>/g;
+var GPT_OSS_CALL = "<|call|>";
+/**
+* Parse gpt-oss Harmony tool calls on the `commentary` channel:
+* `<|channel|>commentary to=functions.NAME <|constrain|>json<|message|>{…}<|call|>`. The arguments
+* payload after `<|message|>` is JSON, located by a string-aware balanced-brace scan so an embedded
+* `<|call|>` / brace inside a string value survives. Anchored on the literal Harmony markers.
+*
+* @remarks The Harmony channel/constrain ordering has a documented upstream template-vs-spec drift;
+* this matches the common ordering. Verify against a real gpt-oss ONNX run when one is available.
+*/
+var gptOssToolCallParser = (rawText) => {
+	const calls = [];
+	const spans = [];
+	for (const m of rawText.matchAll(GPT_OSS_HEAD_RE)) {
+		const headStart = m.index ?? 0;
+		const afterMsg = headStart + m[0].length;
+		const braceStart = rawText.indexOf("{", afterMsg);
+		if (braceStart === -1) continue;
+		const braceEnd = scanBalanced(rawText, braceStart, "{", "}");
+		if (braceEnd === -1) continue;
+		const obj = tryJsonParse(rawText.slice(braceStart, braceEnd + 1));
+		if (!isObject(obj)) continue;
+		const afterObj = rawText.slice(braceEnd + 1);
+		const callRel = new RegExp(`^\\s*${GPT_OSS_CALL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).exec(afterObj);
+		if (!callRel) continue;
+		calls.push({
+			name: m[1],
+			arguments: asArgsObject(obj)
+		});
+		spans.push([headStart, braceEnd + 1 + callRel[0].length]);
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, spans)
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link gptOssToolCallParser}. */
+var defaultGptOssToolCallParser = gptOssToolCallParser;
+var PYTHONIC_SHAPE_RE = /^\[\s*[A-Za-z_]\w*\s*\(.*\)\s*\]$/s;
+var PYTHONIC_CALL_RE = /([A-Za-z_]\w*)\s*\(([^)]*)\)/g;
+/** Read a single pythonic literal: quoted string, number, True/False/None. */
+var readPythonLiteral = (raw) => {
+	const t = raw.trim();
+	if (/^(['"]).*\1$/s.test(t)) return t.slice(1, -1);
+	if (t === "True" || t === "true") return true;
+	if (t === "False" || t === "false") return false;
+	if (t === "None" || t === "null") return null;
+	const n = Number(t);
+	return Number.isFinite(n) ? n : t;
+};
+/** Split `k=v, k2=v2` on top-level commas (ignores commas inside quotes/brackets). */
+var splitPythonArgs = (s) => {
+	const parts = [];
+	let depth = 0;
+	let quote;
+	let cur = "";
+	for (const ch of s) {
+		if (quote) {
+			cur += ch;
+			if (ch === quote) quote = void 0;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			cur += ch;
+			continue;
+		}
+		if (ch === "(" || ch === "[" || ch === "{") depth++;
+		if (ch === ")" || ch === "]" || ch === "}") depth--;
+		if (ch === "," && depth === 0) {
+			parts.push(cur);
+			cur = "";
+			continue;
+		}
+		cur += ch;
+	}
+	if (cur.trim().length > 0) parts.push(cur);
+	return parts;
+};
+/**
+* Parse pythonic tool calls — `[get_weather(city='SF'), get_time()]`. Requires the **whole trimmed
+* output** to be the bracketed call list, so it cannot false-positive on incidental prose. Parallel
+* calls are inherent to the format.
+*
+* **Disambiguation, NOT authorization.** The `[fn(args), …]` shape (whole-output) is the structural
+* signal that this is a call list. It deliberately does NOT check callees against `ctx.toolNames` —
+* whether a tool is *allowed* is the consumer's call, and the dispatch layer already replies "Tool not
+* found: … Available tools: …" so the model can self-correct. Dropping an unknown-tool call here would
+* hide the request and that feedback loop.
+*/
+var pythonicToolCallParser = (rawText) => {
+	const t = rawText.trim();
+	if (!PYTHONIC_SHAPE_RE.test(t)) return NO_MATCH$1(rawText);
+	const inner = t.slice(1, -1);
+	const calls = [];
+	for (const m of inner.matchAll(PYTHONIC_CALL_RE)) {
+		const name = m[1];
+		const args = {};
+		for (const pair of splitPythonArgs(m[2])) {
+			const eq = pair.indexOf("=");
+			if (eq < 0) continue;
+			args[pair.slice(0, eq).trim()] = readPythonLiteral(pair.slice(eq + 1));
+		}
+		calls.push({
+			name,
+			arguments: args
+		});
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: ""
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link pythonicToolCallParser}. */
+var defaultPythonicToolCallParser = pythonicToolCallParser;
+/** Strip a single surrounding ```` ```json … ``` ```` (or bare ```` ``` ```` ) fence, if present. */
+var stripCodeFence = (text) => {
+	const m = /^```(?:json)?\s*\n?([\s\S]*?)\n?```$/.exec(text.trim());
+	return m ? m[1].trim() : text.trim();
+};
+/**
+* Parse bare top-level JSON tool call(s) — `{"name":"x","parameters":{…}}` (or `"arguments"`),
+* optionally wrapped in a ```` ```json … ``` ```` fence (a common small-model emission — verified via
+* the real-model matrix on Qwen2.5-Coder-0.5B). The weakest signal, so it is gated hard: after
+* un-fencing, the output must be ONLY top-level JSON object(s) AND every callee must be a real tool
+* (`ctx.toolNames`). Runs after every marker-anchored family in `'auto'`.
+*
+* @remarks
+* **Parallel calls.** Small Llama-family / Qwen-Coder models emit MULTIPLE calls as several top-level
+* objects separated by `,` / `;` / whitespace (verified on the real-model matrix:
+* Llama-3.2-1B → `{…}; {…}`, Qwen2.5-Coder-0.5B → a fenced `{…},\n{…}`). So we string-aware brace-scan
+* the (un-fenced) text into successive balanced `{…}` objects, accepting only the separators above
+* between them — if any NON-separator prose sits between or around the objects, the whole thing declines
+* (the hard whole-output gate, so this never false-positives on JSON embedded in a sentence).
+*
+* **Disambiguation, NOT authorization.** This parser is marker-free, so it must distinguish a tool call
+* from arbitrary JSON content. It does that STRUCTURALLY: whole-output-is-object(s) + each object has a
+* string `name`. It deliberately does NOT check the callee against `ctx.toolNames` — whether a requested
+* tool is *allowed* is the consumer's decision, not the parser's. An unknown-tool call is surfaced like
+* any other; the dispatch layer already replies "Tool not found: … Available tools: …" so the model can
+* self-correct. Silently dropping the call here would hide both the request and that feedback loop.
+*/
+var llama3JsonToolCallParser = (rawText) => {
+	const t = stripCodeFence(rawText);
+	if (!t.startsWith("{") || !t.endsWith("}")) return NO_MATCH$1(rawText);
+	const calls = [];
+	let i = 0;
+	while (i < t.length) {
+		if (/[\s,;]/.test(t[i])) {
+			i++;
+			continue;
+		}
+		if (t[i] !== "{") return NO_MATCH$1(rawText);
+		const end = scanBalanced(t, i, "{", "}");
+		if (end === -1) return NO_MATCH$1(rawText);
+		const obj = tryJsonParse(t.slice(i, end + 1));
+		if (!isObject(obj)) return NO_MATCH$1(rawText);
+		const o = obj;
+		if (typeof o.name !== "string") return NO_MATCH$1(rawText);
+		calls.push({
+			name: o.name,
+			arguments: asArgsObject(o.parameters ?? o.arguments)
+		});
+		i = end + 1;
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: ""
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link llama3JsonToolCallParser}. */
+var defaultLlama3JsonToolCallParser = llama3JsonToolCallParser;
+var MISTRAL_BOT_TOKEN = "[TOOL_CALLS]";
+/**
+* Parse Mistral tool calls — the `[TOOL_CALLS]` token followed by a JSON array of
+* `{ name, arguments }`. Anchored on the literal `[TOOL_CALLS]` token.
+*
+* @remarks
+* The array is located by a string-aware balanced-bracket scan from the first `[` after the token (same
+* approach as {@link phiToolCallParser}), so a `]` inside a string argument value (e.g.
+* `{"text":"a]b"}`) does not truncate the array the way the old greedy `\[[\s\S]*\]` regex did.
+*/
+var mistralToolCallParser = (rawText) => {
+	const tokenIdx = rawText.indexOf(MISTRAL_BOT_TOKEN);
+	if (tokenIdx === -1) return NO_MATCH$1(rawText);
+	const arrStart = rawText.indexOf("[", tokenIdx + 12);
+	if (arrStart === -1) return NO_MATCH$1(rawText);
+	const arrEnd = scanBalanced(rawText, arrStart, "[", "]");
+	if (arrEnd === -1) return NO_MATCH$1(rawText);
+	const arr = tryJsonParse(rawText.slice(arrStart, arrEnd + 1));
+	if (!Array.isArray(arr)) return NO_MATCH$1(rawText);
+	const calls = [];
+	for (const entry of arr) if (isObject(entry) && typeof entry.name === "string") {
+		const e = entry;
+		calls.push({
+			name: e.name,
+			arguments: asArgsObject(e.arguments)
+		});
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, [[tokenIdx, arrEnd + 1]])
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link mistralToolCallParser}. */
+var defaultMistralToolCallParser = mistralToolCallParser;
+var QWEN3_CODER_RE = /<tool_call>\s*<function=([A-Za-z0-9_]+)>([\s\S]*?)<\/function>\s*<\/tool_call>/g;
+var QWEN3_PARAM_RE = /<parameter=([A-Za-z0-9_]+)>([\s\S]*?)<\/parameter>/g;
+/**
+* Parse Qwen3-Coder's custom per-parameter XML — `<tool_call><function=NAME><parameter=k>v</parameter>
+* …</function></tool_call>`. Values are taken as trimmed strings (the format is untyped). Anchored on
+* the literal `<function=` tag, distinct from Hermes's JSON-in-`<tool_call>`.
+*/
+var qwen3CoderToolCallParser = (rawText) => {
+	const calls = [];
+	const spans = [];
+	for (const m of rawText.matchAll(QWEN3_CODER_RE)) {
+		const args = {};
+		for (const p of m[2].matchAll(QWEN3_PARAM_RE)) args[p[1]] = p[2].trim();
+		calls.push({
+			name: m[1],
+			arguments: args
+		});
+		spans.push([m.index ?? 0, (m.index ?? 0) + m[0].length]);
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, spans)
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link qwen3CoderToolCallParser}. */
+var defaultQwen3CoderToolCallParser = qwen3CoderToolCallParser;
+var PHI_BOT_TOKEN = "functools";
+/**
+* Parse Phi-4-mini tool calls: the literal `functools` token followed by a JSON array of
+* `{ name, arguments }` objects (e.g. `functools[{"name":"get_weather","arguments":{"city":"SF"}}]`).
+*
+* @remarks
+* Anchored on the `functools` begin-of-tool token (vLLM's `phi4_mini_json`). The array is located by
+* scanning for the first `[` after the token and matching to its balanced closing `]`, so trailing
+* prose after the call does not break parsing. Declines (no-match) if the payload is not a JSON array
+* of name-bearing objects.
+*/
+var phiToolCallParser = (rawText) => {
+	const tokenIdx = rawText.indexOf(PHI_BOT_TOKEN);
+	if (tokenIdx === -1) return NO_MATCH$1(rawText);
+	const arrStart = rawText.indexOf("[", tokenIdx + 9);
+	if (arrStart === -1) return NO_MATCH$1(rawText);
+	let depth = 0;
+	let inStr = false;
+	let escaped = false;
+	let arrEnd = -1;
+	for (let i = arrStart; i < rawText.length; i++) {
+		const ch = rawText[i];
+		if (inStr) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inStr = false;
+			continue;
+		}
+		if (ch === "\"") inStr = true;
+		else if (ch === "[") depth++;
+		else if (ch === "]") {
+			depth--;
+			if (depth === 0) {
+				arrEnd = i;
+				break;
+			}
+		}
+	}
+	if (arrEnd === -1) return NO_MATCH$1(rawText);
+	const arr = tryJsonParse(rawText.slice(arrStart, arrEnd + 1));
+	if (!Array.isArray(arr)) return NO_MATCH$1(rawText);
+	const calls = [];
+	for (const entry of arr) if (isObject(entry) && typeof entry.name === "string") {
+		const e = entry;
+		calls.push({
+			name: e.name,
+			arguments: asArgsObject(e.arguments)
+		});
+	}
+	return calls.length > 0 ? {
+		calls,
+		cleanedText: removeSpans$1(rawText, [[tokenIdx, arrEnd + 1]])
+	} : NO_MATCH$1(rawText);
+};
+/** Default {@link phiToolCallParser}. */
+var defaultPhiToolCallParser = phiToolCallParser;
+/** A parser that never extracts anything — disables tool-call parsing entirely. */
+var noneToolCallParser = (rawText) => NO_MATCH$1(rawText);
+/** Default {@link noneToolCallParser}. */
+var defaultNoneToolCallParser = noneToolCallParser;
+/** The bundled family parsers keyed by name (excluding `'auto'`/`'none'`). */
+var BUNDLED_TOOL_CALL_PARSERS = {
+	hermes: hermesToolCallParser,
+	gemma: gemmaToolCallParser,
+	gpt_oss: gptOssToolCallParser,
+	pythonic: pythonicToolCallParser,
+	llama3_json: llama3JsonToolCallParser,
+	mistral: mistralToolCallParser,
+	qwen3_coder: qwen3CoderToolCallParser,
+	phi: phiToolCallParser
+};
+/**
+* The default `'auto'` precedence. Marker-anchored families first (collision-free); the weak-signal
+* pythonic/llama3_json forms run last and are gated on callee∈toolNames.
+*/
+var DEFAULT_TOOL_CALL_PARSER_ORDER = [
+	"hermes",
+	"gemma",
+	"gpt_oss",
+	"phi",
+	"pythonic",
+	"llama3_json",
+	"mistral",
+	"qwen3_coder"
+];
+/**
+* Compose an `'auto'` parser: run each family parser in `order` until one returns a non-empty
+* `calls` array; that result wins. Returns no-match if none claim the text.
+*/
+var createAutoToolCallParser = (parsers = BUNDLED_TOOL_CALL_PARSERS, order = DEFAULT_TOOL_CALL_PARSER_ORDER) => {
+	return (rawText, ctx) => {
+		for (const name of order) {
+			const parser = parsers[name];
+			if (!parser) continue;
+			const result = parser(rawText, ctx);
+			if (result.calls.length > 0) return result;
+		}
+		return NO_MATCH$1(rawText);
+	};
+};
+/** Default {@link createAutoToolCallParser}. */
+var defaultCreateAutoToolCallParser = createAutoToolCallParser;
+/**
+* Resolve a `toolCallParser` option (a name, `'auto'`, `'none'`, or a custom fn) to a concrete
+* {@link ToolCallParserFn}.
+*
+* @param option - The option value. Defaults to `'auto'` when undefined.
+* @param parsers - Override the bundled family parsers (e.g. swap the Gemma parser).
+*/
+var resolveToolCallParser = (option, parsers = BUNDLED_TOOL_CALL_PARSERS) => {
+	if (typeof option === "function") return option;
+	if (option === void 0 || option === "auto") return createAutoToolCallParser(parsers);
+	if (option === "none") return noneToolCallParser;
+	return parsers[option] ?? BUNDLED_TOOL_CALL_PARSERS[option] ?? noneToolCallParser;
+};
+/** Default {@link resolveToolCallParser}. */
+var defaultResolveToolCallParser = resolveToolCallParser;
+//#endregion
+//#region src/batteries/llm/chat_common/generation.ts
+/** Deterministic-friendly defaults, identical across batteries. */
+var GENERATION_DEFAULTS = {
+	maxTokens: 1024,
+	sampler: "greedy",
+	temperature: .7,
+	topK: 40,
+	topP: .95,
+	enableThinking: false,
+	multimodal: {
+		image: false,
+		audio: false
+	}
+};
+/** Pick the first defined value (canonical-wins precedence is encoded by argument order at call sites). */
+var firstDefined = (...values) => {
+	for (const v of values) if (v !== void 0) return v;
+};
+/**
+* Resolve the canonical {@link ChatGenerationOptions} (already merged across option layers) into a
+* fully-defaulted {@link ResolvedGenerationOptions}. Native per-battery fallbacks are passed via
+* `nativeFallbacks` and consulted ONLY when the canonical field is absent (canonical wins). The adapter
+* then maps the resolved shape onto its runtime API.
+*
+* @param canonical - The canonical fields from the merged adapter options.
+* @param nativeFallbacks - Battery-native equivalents to fall back to when a canonical field is unset
+*   (e.g. transformers.js `maxNewTokens`, LiteRT `maxOutputTokens`). Each is consulted second.
+*/
+var resolveGenerationOptions = (canonical, nativeFallbacks = {}) => {
+	const mm = firstDefined(canonical.multimodal, nativeFallbacks.multimodal) ?? {};
+	return {
+		maxTokens: firstDefined(canonical.maxTokens, nativeFallbacks.maxTokens) ?? GENERATION_DEFAULTS.maxTokens,
+		sampler: firstDefined(canonical.sampler, nativeFallbacks.sampler) ?? GENERATION_DEFAULTS.sampler,
+		temperature: firstDefined(canonical.temperature, nativeFallbacks.temperature) ?? GENERATION_DEFAULTS.temperature,
+		topK: firstDefined(canonical.topK, nativeFallbacks.topK) ?? GENERATION_DEFAULTS.topK,
+		topP: firstDefined(canonical.topP, nativeFallbacks.topP) ?? GENERATION_DEFAULTS.topP,
+		seed: firstDefined(canonical.seed, nativeFallbacks.seed),
+		enableThinking: firstDefined(canonical.enableThinking, nativeFallbacks.enableThinking) ?? GENERATION_DEFAULTS.enableThinking,
+		multimodal: {
+			image: mm.image ?? GENERATION_DEFAULTS.multimodal.image,
+			audio: mm.audio ?? GENERATION_DEFAULTS.multimodal.audio
+		}
+	};
+};
+/** Default {@link resolveGenerationOptions}. */
+var defaultResolveGenerationOptions = resolveGenerationOptions;
+//#endregion
+//#region src/batteries/llm/chat_common/reasoning_parsers.ts
+var NO_MATCH = (rawText) => ({
+	reasoning: [],
+	cleanedText: rawText
+});
+var removeSpans = (text, spans) => {
+	let out = text;
+	for (const [start, end] of [...spans].sort((a, b) => b[0] - a[0])) out = out.slice(0, start) + out.slice(end);
+	return out.replace(/\n{3,}/g, "\n\n").trim();
+};
+/**
+* Collect reasoning spans, recovering UNPAIRED markers by inferring the missing half from the
+* pseudo-streaming order (see {@link ReasoningParserOptions}). Algorithm, in precedence:
+*
+* 1. **Paired** spans first — each OPEN whose following text contains a CLOSE forms a complete span
+*    `[openStart, closeEnd]`; the trace is the text between. (Unchanged from the strict path.)
+* 2. **Lone closes** — in the text NOT covered by a pair, scan left-to-right for CLOSE markers that
+*    have no preceding OPEN. Each spans `[cursor, closeEnd]` where `cursor` starts at start-of-text and
+*    advances to each consumed close, so `A </c> B </c> C` → traces `A`, `B` and answer `C` (the second
+*    orphan-close opens at the first close, not back at 0).
+* 3. **Lone open** — a final OPEN with no following CLOSE spans `[openStart, end-of-text]` (truncated
+*    stream).
+*
+* When `orphanRecovery` is false this collapses to strict paired-only behaviour (identical to the old
+* `collect`). Returns NO_MATCH only when nothing — no pair, no orphan — was found.
+*/
+var collectWithOrphans = (rawText, markers, orphanRecovery) => {
+	const { openRe, close } = markers;
+	const reasoning = [];
+	const spans = [];
+	openRe.lastIndex = 0;
+	let cursor = 0;
+	while (cursor <= rawText.length) {
+		openRe.lastIndex = cursor;
+		const openMatch = openRe.exec(rawText);
+		const openStart = openMatch ? openMatch.index : -1;
+		const openEnd = openMatch ? openMatch.index + openMatch[0].length : -1;
+		const closeStart = rawText.indexOf(close, cursor);
+		if (closeStart !== -1 && (openStart === -1 || closeStart < openStart)) {
+			if (!orphanRecovery) {
+				cursor = closeStart + close.length;
+				continue;
+			}
+			const trace = rawText.slice(cursor, closeStart).trim();
+			if (trace.length > 0) reasoning.push(trace);
+			spans.push([cursor, closeStart + close.length]);
+			cursor = closeStart + close.length;
+			continue;
+		}
+		if (openStart !== -1) {
+			const pairedClose = rawText.indexOf(close, openEnd);
+			if (pairedClose !== -1) {
+				const trace = rawText.slice(openEnd, pairedClose).trim();
+				if (trace.length > 0) reasoning.push(trace);
+				spans.push([openStart, pairedClose + close.length]);
+				cursor = pairedClose + close.length;
+				continue;
+			}
+			if (!orphanRecovery) break;
+			const trace = rawText.slice(openEnd).trim();
+			if (trace.length > 0) reasoning.push(trace);
+			spans.push([openStart, rawText.length]);
+			break;
+		}
+		break;
+	}
+	return spans.length > 0 ? {
+		reasoning,
+		cleanedText: removeSpans(rawText, spans)
+	} : NO_MATCH(rawText);
+};
+var THINK_OPEN_RE = /<think>/g;
+var THINKING_OPEN_RE = /<thinking>/g;
+/**
+* Parse `<think>…</think>` (and the `<thinking>…</thinking>` variant) reasoning blocks — the dominant
+* convention, used by Qwen3, DeepSeek-R1, and most distilled reasoning models. Unpaired markers (a lone
+* `</think>` or a truncated `<think>`) are recovered by default — see {@link ReasoningParserOptions}.
+*/
+var makeThinkTagReasoningParser = (opts = {}) => (rawText) => {
+	const orphan = opts.orphanRecovery ?? true;
+	const first = collectWithOrphans(rawText, {
+		openRe: THINK_OPEN_RE,
+		close: "</think>"
+	}, orphan);
+	const second = collectWithOrphans(first.cleanedText, {
+		openRe: THINKING_OPEN_RE,
+		close: "</thinking>"
+	}, orphan);
+	const reasoning = [...first.reasoning, ...second.reasoning];
+	return reasoning.length > 0 || second.cleanedText !== rawText ? {
+		reasoning,
+		cleanedText: second.cleanedText
+	} : NO_MATCH(rawText);
+};
+/** Default {@link makeThinkTagReasoningParser} (orphan recovery on). */
+var thinkTagReasoningParser = makeThinkTagReasoningParser();
+/** Default {@link thinkTagReasoningParser}. */
+var defaultThinkTagReasoningParser = thinkTagReasoningParser;
+var HARMONY_OPEN_RE = /<\|channel\|>analysis\s*<\|message\|>/g;
+/**
+* Parse gpt-oss Harmony chain-of-thought on the `analysis` channel:
+* `<|channel|>analysis<|message|>…<|end|>`. (The user-visible answer is the separate `final` channel;
+* tool calls are `commentary` — handled by the tool-call parser.) Unpaired markers are recovered by
+* default — see {@link ReasoningParserOptions}.
+*/
+var makeHarmonyAnalysisReasoningParser = (opts = {}) => (rawText) => collectWithOrphans(rawText, {
+	openRe: HARMONY_OPEN_RE,
+	close: "<|end|>"
+}, opts.orphanRecovery ?? true);
+/** Default {@link makeHarmonyAnalysisReasoningParser} (orphan recovery on). */
+var harmonyAnalysisReasoningParser = makeHarmonyAnalysisReasoningParser();
+/** Default {@link harmonyAnalysisReasoningParser}. */
+var defaultHarmonyAnalysisReasoningParser = harmonyAnalysisReasoningParser;
+var GEMMA_OPEN_RE = /<\|channel>thought\b[^\n]*\n?/g;
+/**
+* Parse Gemma E2B/E4B reasoning emitted on the thought channel:
+* `<|channel>thought\n…<channel|>`. Targets the E2B/E4B delimited form (the transformers.js-runnable
+* one). Reasoning is only emitted when `<|think|>` is injected into the system prompt. Unpaired markers
+* are recovered by default — see {@link ReasoningParserOptions}.
+*/
+var makeGemmaChannelReasoningParser = (opts = {}) => (rawText) => collectWithOrphans(rawText, {
+	openRe: GEMMA_OPEN_RE,
+	close: "<channel|>"
+}, opts.orphanRecovery ?? true);
+/** Default {@link makeGemmaChannelReasoningParser} (orphan recovery on). */
+var gemmaChannelReasoningParser = makeGemmaChannelReasoningParser();
+/** Default {@link gemmaChannelReasoningParser}. */
+var defaultGemmaChannelReasoningParser = gemmaChannelReasoningParser;
+/** A parser that never extracts anything — disables reasoning parsing entirely. */
+var noneReasoningParser = (rawText) => NO_MATCH(rawText);
+/** Default {@link noneReasoningParser}. */
+var defaultNoneReasoningParser = noneReasoningParser;
+/** The bundled reasoning parsers keyed by name (excluding `'auto'`/`'none'`), orphan recovery ON. */
+var BUNDLED_REASONING_PARSERS = {
+	think_tag: thinkTagReasoningParser,
+	harmony_analysis: harmonyAnalysisReasoningParser,
+	gemma_channel: gemmaChannelReasoningParser
+};
+/** Build the bundled family parsers honouring {@link ReasoningParserOptions} (e.g. orphan recovery). */
+var buildBundledReasoningParsers = (opts = {}) => ({
+	think_tag: makeThinkTagReasoningParser(opts),
+	harmony_analysis: makeHarmonyAnalysisReasoningParser(opts),
+	gemma_channel: makeGemmaChannelReasoningParser(opts)
+});
+/** The default `'auto'` precedence. All three are literal-marker-anchored, so order is collision-free. */
+var DEFAULT_REASONING_PARSER_ORDER = [
+	"think_tag",
+	"harmony_analysis",
+	"gemma_channel"
+];
+/**
+* Compose an `'auto'` reasoning parser: run each parser in `order` until one returns a non-empty
+* `reasoning` array; that result wins. Returns no-match if none claim the text.
+*/
+var createAutoReasoningParser = (parsers = BUNDLED_REASONING_PARSERS, order = DEFAULT_REASONING_PARSER_ORDER) => {
+	return (rawText) => {
+		for (const name of order) {
+			const parser = parsers[name];
+			if (!parser) continue;
+			const result = parser(rawText);
+			if (result.reasoning.length > 0 || result.cleanedText !== rawText) return result;
+		}
+		return NO_MATCH(rawText);
+	};
+};
+/** Default {@link createAutoReasoningParser}. */
+var defaultCreateAutoReasoningParser = createAutoReasoningParser;
+/**
+* Resolve a `reasoningParser` option (a name, `'auto'`, `'none'`, or a custom fn) to a concrete
+* {@link ReasoningParserFn}.
+*
+* @param option - The option value. Defaults to `'auto'` when undefined.
+* @param parsers - Override the bundled parsers. Ignored when `opts.orphanRecovery` is set (the bundled
+*   family parsers are rebuilt with that setting); pass a custom `option` fn for full control.
+* @param opts - {@link ReasoningParserOptions}; `orphanRecovery` defaults to `true`. When `false`, the
+*   named/auto bundled parsers are rebuilt in strict pair-only mode.
+*/
+var resolveReasoningParser = (option, parsers = BUNDLED_REASONING_PARSERS, opts = {}) => {
+	if (typeof option === "function") return option;
+	if (option === "none") return noneReasoningParser;
+	const resolved = opts.orphanRecovery === false ? buildBundledReasoningParsers(opts) : {
+		...BUNDLED_REASONING_PARSERS,
+		...parsers
+	};
+	if (option === void 0 || option === "auto") return createAutoReasoningParser(resolved);
+	return resolved[option] ?? noneReasoningParser;
+};
+/** Default {@link resolveReasoningParser}. */
+var defaultResolveReasoningParser = resolveReasoningParser;
+//#endregion
+export { defaultMistralToolCallParser as A, mistralToolCallParser as B, DEFAULT_TOOL_CALL_PARSER_ORDER as C, defaultGptOssToolCallParser as D, defaultGemmaToolCallParser as E, defaultResolveToolCallParser as F, resolveToolCallParser as G, phiToolCallParser as H, gemmaToolCallParser as I, gptOssToolCallParser as L, defaultPhiToolCallParser as M, defaultPythonicToolCallParser as N, defaultHermesToolCallParser as O, defaultQwen3CoderToolCallParser as P, hermesToolCallParser as R, BUNDLED_TOOL_CALL_PARSERS as S, defaultCreateAutoToolCallParser as T, pythonicToolCallParser as U, noneToolCallParser as V, qwen3CoderToolCallParser as W, resolveReasoningParser as _, defaultCreateAutoReasoningParser as a, defaultResolveGenerationOptions as b, defaultNoneReasoningParser as c, gemmaChannelReasoningParser as d, harmonyAnalysisReasoningParser as f, noneReasoningParser as g, makeThinkTagReasoningParser as h, createAutoReasoningParser as i, defaultNoneToolCallParser as j, defaultLlama3JsonToolCallParser as k, defaultResolveReasoningParser as l, makeHarmonyAnalysisReasoningParser as m, DEFAULT_REASONING_PARSER_ORDER as n, defaultGemmaChannelReasoningParser as o, makeGemmaChannelReasoningParser as p, buildBundledReasoningParsers as r, defaultHarmonyAnalysisReasoningParser as s, BUNDLED_REASONING_PARSERS as t, defaultThinkTagReasoningParser as u, thinkTagReasoningParser as v, createAutoToolCallParser as w, resolveGenerationOptions as x, GENERATION_DEFAULTS as y, llama3JsonToolCallParser as z };
+
+//# sourceMappingURL=reasoning_parsers-Dp66LFBt.mjs.map