@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/stream-markup-healing-KMkiAA00.mjs

@@ -0,0 +1,491 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { D as partialSuffixOverlapAny, E as FencedThinkingScanner, T as createInbandScanner } from "./utils-Cp76gCyk.mjs";
+import { h as isDeepseekModelIdOrName } from "./models-SGASygJ3.mjs";
+import "./identity-Da1GPU9a.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/thinking.ts
+/**
+* Every dialect's in-band thinking section in its canonical `renderThinking`
+* form (see the sibling `./*.ts` scanners). {@link ThinkingInbandScanner} heals
+* reasoning a model leaked into its visible text channel back into thinking
+* events, whichever dialect idiom the leak used.
+*
+* Plain (attribute-free) delimiters only — matching what `renderThinking`
+* emits and what models leak in practice. Attributed or namespaced XML thinking
+* tags (`<thinking signature="…">`, `antml:thinking`) are recovered by the owned
+* anthropic-dialect parser, not this text-channel healing fallback.
+*/
+const TAGS = [
+	{
+		open: "<think>",
+		close: "</think>"
+	},
+	{
+		open: "<thinking>",
+		close: "</thinking>"
+	},
+	{
+		open: "<scratchpad>",
+		close: "</scratchpad>"
+	},
+	{
+		open: "```thinking\n",
+		close: "```",
+		fenced: true
+	},
+	{
+		open: "<|channel>thought\n",
+		close: "<channel|>"
+	},
+	{
+		open: "<|start|>assistant<|channel|>analysis<|message|>",
+		close: "<|end|>"
+	},
+	{
+		open: "<|channel|>analysis<|message|>",
+		close: "<|end|>"
+	}
+];
+const OPENS = TAGS.map((tag) => tag.open);
+var ThinkingInbandScanner = class {
+	#buffer = "";
+	#closeTag = "";
+	#thinking = "";
+	/** Fence-aware close-matcher while inside a ` ```thinking ` block; undefined otherwise. */
+	#fenced;
+	/** Backtick count that opened the Markdown code span/fence we are inside; 0 when not in code. */
+	#codeTicks = 0;
+	/** True when {@link #codeTicks} opened a fenced block (closes on a fence line), not an inline span. */
+	#codeFenced = false;
+	/**
+	* Leading-space count on the current output line, or -1 once a non-space
+	* character has appeared. Starts at 0 (line start) so a fence opening the
+	* stream — or one indented ≤3 spaces, as CommonMark allows — is recognized.
+	*/
+	#lineIndent = 0;
+	feed(text) {
+		if (text.length === 0) return [];
+		this.#buffer += text;
+		return this.#consume(false);
+	}
+	flush() {
+		const events = this.#consume(true);
+		if (this.#buffer.length === 0) return events;
+		if (this.#closeTag) {
+			this.#emitThinking(this.#buffer, events);
+			events.push({
+				type: "thinkingEnd",
+				thinking: this.#thinking
+			});
+		} else events.push({
+			type: "text",
+			text: this.#buffer
+		});
+		this.#buffer = "";
+		this.#closeTag = "";
+		return events;
+	}
+	#consume(final) {
+		const events = [];
+		for (;;) {
+			if (this.#fenced) {
+				const result = this.#fenced.feed(this.#buffer, final);
+				this.#buffer = result.closed ? result.rest : "";
+				this.#emitThinking(result.thinking, events);
+				if (result.closed || final) {
+					events.push({
+						type: "thinkingEnd",
+						thinking: this.#thinking
+					});
+					this.#thinking = "";
+					this.#closeTag = "";
+					this.#fenced = void 0;
+				}
+				if (this.#fenced) break;
+				continue;
+			}
+			if (this.#buffer.length === 0) break;
+			if (this.#closeTag) {
+				const close = this.#buffer.indexOf(this.#closeTag);
+				if (close === -1) {
+					const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, [this.#closeTag]);
+					this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
+					this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+					break;
+				}
+				this.#emitThinking(this.#buffer.slice(0, close), events);
+				this.#buffer = this.#buffer.slice(close + this.#closeTag.length);
+				events.push({
+					type: "thinkingEnd",
+					thinking: this.#thinking
+				});
+				this.#thinking = "";
+				this.#closeTag = "";
+				continue;
+			}
+			if (this.#codeTicks > 0) {
+				if (this.#emitCode(final, events)) continue;
+				break;
+			}
+			const hit = scanVisible(this.#buffer, final);
+			if (hit.kind === "none") {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				break;
+			}
+			if (hit.index > 0) this.#emitText(this.#buffer.slice(0, hit.index), events);
+			if (hit.kind === "hold") {
+				this.#buffer = this.#buffer.slice(hit.index);
+				break;
+			}
+			if (hit.kind === "code") {
+				const fenced = hit.ticks >= 3 && this.#lineIndent >= 0 && this.#lineIndent <= 3;
+				this.#emitText(this.#buffer.slice(hit.index, hit.index + hit.ticks), events);
+				this.#buffer = this.#buffer.slice(hit.index + hit.ticks);
+				this.#codeTicks = hit.ticks;
+				this.#codeFenced = fenced;
+				continue;
+			}
+			this.#buffer = this.#buffer.slice(hit.index + hit.tag.open.length);
+			this.#closeTag = hit.tag.close;
+			this.#thinking = "";
+			if (hit.tag.fenced) this.#fenced = new FencedThinkingScanner();
+			events.push({ type: "thinkingStart" });
+		}
+		return events;
+	}
+	/**
+	* Emit buffered content while inside a Markdown code region, suppressing
+	* reasoning-tag detection. A fenced block closes only on a fence line (a line
+	* of backticks ≥ the opener); an inline span closes on the first backtick run
+	* of exactly the opener length. Returns true when the region closed and the
+	* loop should continue, false when it held back and should break.
+	*/
+	#emitCode(final, events) {
+		if (this.#codeFenced) {
+			const end = findFenceCloseEnd(this.#buffer, this.#codeTicks, final);
+			if (end !== -1) {
+				this.#emitText(this.#buffer.slice(0, end), events);
+				this.#buffer = this.#buffer.slice(end);
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return true;
+			}
+			if (final) {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return false;
+			}
+			const lastNl = this.#buffer.lastIndexOf("\n");
+			if (lastNl !== -1) {
+				this.#emitText(this.#buffer.slice(0, lastNl + 1), events);
+				this.#buffer = this.#buffer.slice(lastNl + 1);
+			}
+			return false;
+		}
+		const close = findBacktickRun(this.#buffer, 0, this.#codeTicks);
+		if (close !== -1 && (final || close + this.#codeTicks < this.#buffer.length)) {
+			this.#emitText(this.#buffer.slice(0, close + this.#codeTicks), events);
+			this.#buffer = this.#buffer.slice(close + this.#codeTicks);
+			this.#codeTicks = 0;
+			return true;
+		}
+		const hold = final ? 0 : trailingBacktickRun(this.#buffer);
+		this.#emitText(this.#buffer.slice(0, this.#buffer.length - hold), events);
+		this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+		if (final) this.#codeTicks = 0;
+		return false;
+	}
+	#emitText(text, events) {
+		if (text.length === 0) return;
+		events.push({
+			type: "text",
+			text
+		});
+		this.#lineIndent = trailingLineIndent(text, this.#lineIndent);
+	}
+	#emitThinking(delta, events) {
+		if (delta.length === 0) return;
+		this.#thinking += delta;
+		events.push({
+			type: "thinkingDelta",
+			delta
+		});
+	}
+};
+/**
+* Walk idle visible text for the earliest boundary: a leaked reasoning-tag open,
+* a Markdown code-span/fence opener (a backtick run), or — when more chunks may
+* follow — a held partial delimiter at the buffer tail.
+*
+* Reasoning tags win at any position so the gemini ` ```thinking ` fence is
+* healed instead of being read as a code fence. Backtick runs enter code mode so
+* a literal `<think>` inside inline code or a fenced block stays visible text.
+*/
+function scanVisible(buffer, final) {
+	for (let i = 0; i < buffer.length; i++) {
+		const tag = TAGS.find((candidate) => buffer.startsWith(candidate.open, i));
+		if (tag) return {
+			kind: "tag",
+			index: i,
+			tag
+		};
+		if (!final) {
+			const rest = buffer.slice(i);
+			if (OPENS.some((open) => open.length > rest.length && open.startsWith(rest))) return {
+				kind: "hold",
+				index: i
+			};
+		}
+		if (buffer[i] === "`") {
+			const ticks = backtickRun(buffer, i);
+			if (!final && i + ticks === buffer.length) return {
+				kind: "hold",
+				index: i
+			};
+			return {
+				kind: "code",
+				index: i,
+				ticks
+			};
+		}
+	}
+	return { kind: "none" };
+}
+/** Length of the maximal backtick run beginning at `from`. */
+function backtickRun(buffer, from) {
+	let end = from;
+	while (end < buffer.length && buffer[end] === "`") end++;
+	return end - from;
+}
+/** Index of the first maximal backtick run of exactly `ticks` at/after `from`, else -1. */
+function findBacktickRun(buffer, from, ticks) {
+	for (let i = buffer.indexOf("`", from); i !== -1; i = buffer.indexOf("`", i)) {
+		const run = backtickRun(buffer, i);
+		if (run === ticks) return i;
+		i += run;
+	}
+	return -1;
+}
+/** Length of a backtick run that ends at the buffer tail; 0 when the tail is not a backtick. */
+function trailingBacktickRun(buffer) {
+	let start = buffer.length;
+	while (start > 0 && buffer[start - 1] === "`") start--;
+	return buffer.length - start;
+}
+/**
+* Leading-space count of the line at the tail of `text`, continuing from the
+* prior line's `indent` state (see {@link ThinkingInbandScanner.#lineIndent}).
+* Returns -1 once any non-space character has appeared on the current line.
+*/
+function trailingLineIndent(text, prior) {
+	const lastNl = text.lastIndexOf("\n");
+	let indent = lastNl === -1 ? prior : 0;
+	for (let i = lastNl + 1; i < text.length; i++) {
+		if (indent === -1) break;
+		indent = text[i] === " " ? indent + 1 : -1;
+	}
+	return indent;
+}
+/**
+* Index just past the first closing fence line for a fenced block opened with
+* `ticks` backticks, or -1 when none is committed yet. A closing fence is a whole
+* line whose trimmed content is only backticks, at least `ticks` of them. A line
+* without a terminating newline is committed only when `final` (no more input can
+* extend it into a non-fence line).
+*/
+function findFenceCloseEnd(buffer, ticks, final) {
+	for (let start = 0; start <= buffer.length;) {
+		const nl = buffer.indexOf("\n", start);
+		const terminated = nl !== -1;
+		const line = buffer.slice(start, terminated ? nl : buffer.length).trim();
+		if (line.length >= ticks && isAllBackticks(line) && (terminated || final)) return terminated ? nl + 1 : buffer.length;
+		if (!terminated) break;
+		start = nl + 1;
+	}
+	return -1;
+}
+/** True when `text` is non-empty and every character is a backtick. */
+function isAllBackticks(text) {
+	for (let i = 0; i < text.length; i++) if (text[i] !== "`") return false;
+	return text.length > 0;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/stream-markup-healing.ts
+/**
+* Streaming-safe filters for leaked chat-template tool-call and thinking markup.
+*
+* Hosted models sometimes leak raw template markup into visible `content` instead
+* of returning structured events. Tool-call healing delegates to the same
+* dialect scanners used by owned in-band tool calling; this file keeps the
+* provider-facing compatibility wrapper and model/provider gating.
+*/
+const KIMI_SECTION_END = "<|tool_calls_section_end|>";
+const DSML_TOOL_CALLS_CLOSE_FULLWIDTH = "</｜DSML｜tool_calls>";
+const DSML_TOOL_CALLS_CLOSE_ASCII = "</|DSML|tool_calls>";
+/**
+* State machine that consumes streamed visible text and emits cleaned text,
+* thinking deltas, and reconstructed tool calls.
+*
+* A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+* (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+* the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+* runs first and its cleaned text is piped through that thinking healer, so a
+* model can leak tool-call markup and reasoning in the same stream.
+*
+* Feed only one stream channel (usually `delta.content` / `message.content`).
+* Mixing reasoning and visible text into the same instance can corrupt held-back
+* partial tag buffers.
+*/
+var StreamMarkupHealing = class {
+	#pattern;
+	/** Provider tool-call grammar (Kimi tokens / DSML envelope); absent for plain text streams. */
+	#toolScanner;
+	/** Always-on healer for leaked reasoning idioms in the visible text channel. */
+	#thinkingScanner = new ThinkingInbandScanner();
+	#sectionTerminated = false;
+	#completed = [];
+	constructor(options) {
+		this.#pattern = options.pattern;
+		this.#toolScanner = options.pattern === "kimi" ? createInbandScanner("kimi") : options.pattern === "dsml" ? createInbandScanner("xml", { xmlTagset: "dsml" }) : void 0;
+	}
+	get pattern() {
+		return this.#pattern;
+	}
+	/**
+	* Feed a chunk and return visible text only. Reconstructed tool calls are
+	* stored for {@link drainCompleted}; thinking blocks are intentionally not
+	* returned by this compatibility helper. Use {@link feedEvents} when the caller
+	* needs ordered text/thinking/tool-call events.
+	*/
+	feed(text) {
+		let clean = "";
+		for (const event of this.feedEvents(text)) if (event.type === "text") clean += event.text;
+		else if (event.type === "toolCall") this.#completed.push(event.call);
+		return clean;
+	}
+	/** Feed a chunk and return cleaned text/thinking/tool-call events in stream order. */
+	feedEvents(text) {
+		if (text.length === 0) return [];
+		this.#markSectionClosed(text);
+		if (!this.#toolScanner) return this.#convertScannerEvents(this.#thinkingScanner.feed(text));
+		return this.#convertScannerEvents(this.#healThinking(this.#toolScanner.feed(text)));
+	}
+	/**
+	* Feed a chunk and return cleaned events, excluding synthesized tool calls.
+	* Used when the upstream chunk also carries structured `tool_calls`, keeping
+	* that structured payload as the single source of truth while preserving
+	* adjacent text and thinking events.
+	*/
+	feedEventsWithoutCalls(text) {
+		const events = this.feedEvents(text);
+		let out;
+		for (let i = 0; i < events.length; i++) {
+			const event = events[i];
+			if (event.type === "toolCall") out ??= events.slice(0, i);
+			else if (out) out.push(event);
+		}
+		return out ?? events;
+	}
+	/** Drain accumulated tool calls from calls to {@link feed}. */
+	drainCompleted() {
+		if (this.#completed.length === 0) return [];
+		return this.#completed.splice(0, this.#completed.length);
+	}
+	/**
+	* Flush held-back stream-end fragments as ordered events. Partial tool-call
+	* sections/envelopes are dropped by the delegated scanners; unterminated
+	* thinking blocks are emitted as thinking, matching the previous MiniMax parser
+	* behavior.
+	*/
+	flushEvents() {
+		const tail = this.#toolScanner ? this.#healThinking(this.#toolScanner.flush()) : [];
+		tail.push(...this.#thinkingScanner.flush());
+		return this.#convertScannerEvents(tail);
+	}
+	/** Flush held-back text only. Reconstructed calls are retained for {@link drainCompleted}. */
+	flushPending() {
+		let clean = "";
+		for (const event of this.flushEvents()) if (event.type === "text") clean += event.text;
+		else if (event.type === "toolCall") this.#completed.push(event.call);
+		return clean;
+	}
+	/** True once any configured tool-call section/envelope has fully closed. */
+	get sectionClosed() {
+		return this.#sectionTerminated;
+	}
+	#markSectionClosed(text) {
+		if (this.#sectionTerminated || !this.#toolScanner) return;
+		if (this.#pattern === "kimi") {
+			this.#sectionTerminated = text.includes(KIMI_SECTION_END);
+			return;
+		}
+		this.#sectionTerminated = text.includes(DSML_TOOL_CALLS_CLOSE_FULLWIDTH) || text.includes(DSML_TOOL_CALLS_CLOSE_ASCII);
+	}
+	/**
+	* Re-scan the tool scanner's visible text through the always-on thinking
+	* healer: `text` events are healed for leaked reasoning idioms, while the tool
+	* scanner's own thinking / tool-call events pass through in stream order.
+	*/
+	#healThinking(toolEvents) {
+		const out = [];
+		for (const event of toolEvents) if (event.type === "text") out.push(...this.#thinkingScanner.feed(event.text));
+		else out.push(event);
+		return out;
+	}
+	#convertScannerEvents(events) {
+		const out = [];
+		for (const event of events) switch (event.type) {
+			case "text":
+				out.push({
+					type: "text",
+					text: event.text
+				});
+				break;
+			case "thinkingDelta":
+				if (event.delta.length > 0) out.push({
+					type: "thinking",
+					thinking: event.delta
+				});
+				break;
+			case "toolEnd": out.push({
+				type: "toolCall",
+				call: {
+					id: generateHealedToolCallId(),
+					name: event.name,
+					arguments: JSON.stringify(event.arguments)
+				}
+			});
+		}
+		return out;
+	}
+};
+function generateHealedToolCallId() {
+	return `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+}
+/** Cheap model/provider gate for Kimi-K2 chat-template token leaks. */
+function modelMayLeakKimiToolCalls(provider, modelId) {
+	if (provider === "kimi-code" || provider === "moonshot") return true;
+	return /kimi[-/_.]?k2/i.test(modelId);
+}
+/** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
+function modelMayLeakDsmlToolCalls(provider, modelId) {
+	if (!isDeepseekModelIdOrName(modelId)) return false;
+	return provider === "ollama" || provider === "ollama-cloud" || provider === "nvidia" || provider === "deepseek" || provider === "fireworks" || provider === "nanogpt" || provider === "opencode-go" || provider === "openrouter";
+}
+/**
+* Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+* stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+* dedicated tool-call grammars; every other model uses `"thinking"`. All three
+* patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+* idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+*/
+function getStreamMarkupHealingPattern(provider, modelId) {
+	if (modelMayLeakKimiToolCalls(provider, modelId)) return "kimi";
+	if (modelMayLeakDsmlToolCalls(provider, modelId)) return "dsml";
+	return "thinking";
+}
+//#endregion
+export { getStreamMarkupHealingPattern as n, StreamMarkupHealing as t };