@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

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

@@ -1,267 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { E as createInbandScanner } from "./utils-cZX3f_Ls.mjs";
-import { t as ThinkingInbandScanner } from "./thinking-ngMwf_1Y.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-CBTz1dAA.mjs

@@ -1,105 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-//#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,
-	integer: true,
-	boolean: true,
-	object: true,
-	array: true,
-	null: true
-};
-function jsonValueMatchesType(value, type) {
-	switch (type) {
-		case "string": return typeof value === "string";
-		case "number": return typeof value === "number";
-		case "integer": return typeof value === "number" && Number.isInteger(value);
-		case "boolean": return typeof value === "boolean";
-		case "null": return value === null;
-		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
-		case "array": return Array.isArray(value);
-		default: return true;
-	}
-}
-function declaredTypes(node) {
-	const t = node.type;
-	if (typeof t === "string") return t in SCHEMA_TYPE_NAMES ? [t] : [];
-	if (Array.isArray(t)) return t.filter((x) => typeof x === "string" && x in SCHEMA_TYPE_NAMES);
-	return [];
-}
-const CHILD_MAP_KEYS = [
-	"properties",
-	"patternProperties",
-	"$defs",
-	"definitions",
-	"dependentSchemas"
-];
-const CHILD_SCHEMA_KEYS = [
-	"items",
-	"contains",
-	"not",
-	"if",
-	"then",
-	"else",
-	"propertyNames",
-	"additionalProperties",
-	"unevaluatedProperties",
-	"unevaluatedItems"
-];
-const CHILD_ARRAY_KEYS = [
-	"anyOf",
-	"oneOf",
-	"allOf",
-	"prefixItems"
-];
-/**
-* Walk a tool parameter schema for OpenAI-strict `enum`/`const`-vs-`type`
-* contradictions. Returns a JSON-pointer-ish path to the first offending node,
-* or `null` when the schema is safe to emit.
-*/
-function findStrictToolSchemaViolation(schema, path = "#", options) {
-	if (Array.isArray(schema)) {
-		for (let i = 0; i < schema.length; i++) {
-			const hit = findStrictToolSchemaViolation(schema[i], `${path}/${i}`, options);
-			if (hit) return hit;
-		}
-		return null;
-	}
-	if (typeof schema !== "object" || schema === null) return null;
-	const node = schema;
-	const types = declaredTypes(node);
-	if (types.length > 0) {
-		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?.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) => {
-			if (typeof branch !== "object" || branch === null || Array.isArray(branch)) return true;
-			return !declaredTypes(branch).includes("object");
-		})) return `${path}/${key}`;
-	}
-	for (const key of CHILD_MAP_KEYS) {
-		const sub = node[key];
-		if (sub && typeof sub === "object" && !Array.isArray(sub)) for (const k of Object.keys(sub)) {
-			const hit = findStrictToolSchemaViolation(sub[k], `${path}/${key}/${k}`, options);
-			if (hit) return hit;
-		}
-	}
-	for (const key of CHILD_SCHEMA_KEYS) if (key in node) {
-		const hit = findStrictToolSchemaViolation(node[key], `${path}/${key}`, options);
-		if (hit) return hit;
-	}
-	for (const key of CHILD_ARRAY_KEYS) {
-		const arr = node[key];
-		if (Array.isArray(arr)) {
-			const hit = findStrictToolSchemaViolation(arr, `${path}/${key}`, options);
-			if (hit) return hit;
-		}
-	}
-	return null;
-}
-//#endregion
-export { findStrictToolSchemaViolation as t };