@xiaoso/dsh-tool-plus 0.1.5 → 0.1.7-beta.0

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

@@ -0,0 +1,267 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { E as createInbandScanner } from "./utils-CUPhpw9A.mjs";
+import { t as ThinkingInbandScanner } from "./thinking-CiLa2LFB.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen-xml.ts
+const SECTION_OPEN = "<tool_calls>";
+const SECTION_CLOSE = "</tool_calls>";
+const TOOL_ELEMENT = /^<([A-Za-z_][\w.-]*)(\s[^<>]*?)?\s*\/>$/s;
+const ATTRIBUTE = /([A-Za-z_][\w.-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+var QwenXmlInbandScanner = class {
+	#buffer = "";
+	#insideSection = false;
+	feed(chunk) {
+		this.#buffer += chunk;
+		return this.#drain(false);
+	}
+	flush() {
+		return this.#drain(true);
+	}
+	#drain(flush) {
+		const events = [];
+		while (this.#buffer.length > 0) {
+			if (!this.#insideSection) {
+				const open = this.#buffer.indexOf(SECTION_OPEN);
+				if (open >= 0) {
+					if (open > 0) events.push({
+						type: "text",
+						text: this.#buffer.slice(0, open)
+					});
+					this.#buffer = this.#buffer.slice(open + 12);
+					this.#insideSection = true;
+					continue;
+				}
+				if (flush) {
+					events.push({
+						type: "text",
+						text: this.#buffer
+					});
+					this.#buffer = "";
+					break;
+				}
+				const held = longestSuffixPrefix(this.#buffer, SECTION_OPEN);
+				const visibleLength = this.#buffer.length - held;
+				if (visibleLength > 0) {
+					events.push({
+						type: "text",
+						text: this.#buffer.slice(0, visibleLength)
+					});
+					this.#buffer = this.#buffer.slice(visibleLength);
+				}
+				break;
+			}
+			const close = this.#buffer.indexOf(SECTION_CLOSE);
+			if (close < 0) {
+				if (flush) this.#buffer = "";
+				break;
+			}
+			const section = this.#buffer.slice(0, close);
+			for (const element of section.match(/<[^<>]+\/>/gs) ?? []) {
+				const call = parseToolElement(element);
+				if (!call) continue;
+				const id = `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+				events.push({
+					type: "toolStart",
+					id,
+					name: call.name
+				});
+				events.push({
+					type: "toolEnd",
+					id,
+					name: call.name,
+					arguments: call.arguments,
+					rawBlock: element
+				});
+			}
+			this.#buffer = this.#buffer.slice(close + 13);
+			this.#insideSection = false;
+		}
+		return events;
+	}
+};
+function parseToolElement(element) {
+	const match = TOOL_ELEMENT.exec(element);
+	if (!match) return void 0;
+	const args = {};
+	for (const attribute of match[2]?.matchAll(ATTRIBUTE) ?? []) args[attribute[1]] = attribute[3] ?? attribute[4] ?? "";
+	return {
+		name: match[1],
+		arguments: args
+	};
+}
+function longestSuffixPrefix(text, target) {
+	const max = Math.min(text.length, target.length - 1);
+	for (let length = max; length > 0; length--) if (text.endsWith(target.slice(0, length))) return length;
+	return 0;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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" }) : options.pattern === "qwen" ? new QwenXmlInbandScanner() : 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;
+		}
+		if (this.#pattern === "qwen") {
+			this.#sectionTerminated = text.includes("</tool_calls>");
+			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)}`;
+}
+/**
+* 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(model) {
+	if (model.identity.class === "kimi") return "kimi";
+	if (model.identity.class === "deepseek") return "dsml";
+	return "thinking";
+}
+//#endregion
+export { getStreamMarkupHealingPattern as n, StreamMarkupHealing as t };

package/lib/{strict-tool-validation-imVLUcbI.mjs → strict-tool-validation-CBTz1dAA.mjs}

@@ -1,6 +1,6 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/strict-tool-validation.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/strict-tool-validation.ts
 const SCHEMA_TYPE_NAMES = {
 	string: true,
 	number: true,
@@ -73,7 +73,7 @@ function findStrictToolSchemaViolation(schema, path = "#", options) {
 		if (Array.isArray(node.enum) && node.enum.some((v) => !types.some((t) => jsonValueMatchesType(v, t)))) return `${path}/enum`;
 		if ("const" in node && !types.some((t) => jsonValueMatchesType(node.const, t))) return `${path}/const`;
 	}
-	if (options?.rejectXaiRootObjectUnion && path === "#" && (types.includes("object") || node.properties !== void 0 && typeof node.properties === "object")) for (const key of ["anyOf", "oneOf"]) {
+	if (options?.rejectRootObjectUnion && path === "#" && (types.includes("object") || node.properties !== void 0 && typeof node.properties === "object")) for (const key of ["anyOf", "oneOf"]) {
 		const arr = node[key];
 		if (!Array.isArray(arr) || arr.length === 0) continue;
 		if (arr.some((branch) => {