llmz 0.7.0 → 0.8.0

package/dist/{_baseForOwn-buOZDFbK.cjs → _baseForOwn-BfWDTL8L.cjs}

@@ -1,35 +1,3 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
 const require__baseIteratee = require("./_baseIteratee-CF4qP2a8.cjs");
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createBaseFor.js
 /**
@@ -77,24 +45,6 @@ function baseForOwn(object, iteratee) {
 	return object && baseFor(object, iteratee, require__baseIteratee.keys);
 }
 //#endregion
-Object.defineProperty(exports, "__commonJSMin", {
-	enumerable: true,
-	get: function() {
-		return __commonJSMin;
-	}
-});
-Object.defineProperty(exports, "__exportAll", {
-	enumerable: true,
-	get: function() {
-		return __exportAll;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
 Object.defineProperty(exports, "baseForOwn", {
 	enumerable: true,
 	get: function() {

package/dist/common-DdArNQhl.cjs

@@ -0,0 +1,643 @@
+const require_compiler = require("./compiler-C-OI9sim.cjs");
+let json5 = require("json5");
+json5 = require_compiler.__toESM(json5, 1);
+let jsonrepair = require("jsonrepair");
+//#region src/message-stream/types.ts
+/**
+* Reserved protocol symbol. Every block of an LLM response starts with `■`:
+*
+*   ■send=<component> { props? }
+*   streaming body here
+*
+*   ■run
+*   // code here
+*
+*   ■next=<name> { props? }
+*
+* The model must never emit `■` inside props or body content.
+*/
+const MARKER = "■";
+/** Component and exit names are normalized to lowercase (kebab or snake case). */
+const NAME_REGEX = /^[a-z][a-z0-9_-]*$/;
+//#endregion
+//#region src/message-stream/parser.ts
+const isWhitespace = (char) => /\s/.test(char);
+/**
+* Lenient JSON parsing: JSON5 first (unquoted keys, single quotes, trailing
+* commas), then jsonrepair for anything else the model got slightly wrong.
+*/
+const tryParseJson = (text) => {
+	try {
+		return json5.default.parse(text);
+	} catch {
+		try {
+			return json5.default.parse((0, jsonrepair.jsonrepair)(text));
+		} catch {
+			const trimmed = text.trim();
+			if (/^\{\s*\{/.test(trimmed) && /\}\s*\}$/.test(trimmed)) try {
+				return json5.default.parse(trimmed.slice(1, -1));
+			} catch {}
+			return;
+		}
+	}
+};
+/**
+* Incremental, chunk-boundary-agnostic parser for the message-stream protocol.
+*
+* The parser is purely syntactic: it knows the reserved `■` symbol and the
+* directive grammar, but nothing about registered components, exits or their
+* schemas. Semantic validation is a separate step (see `validator.ts`).
+* Text outside protocol blocks is always discarded with a diagnostic; only
+* explicit `■send` blocks can produce messages.
+*
+* Pushing the same text split across arbitrary chunk boundaries always produces
+* the same items and the same concatenated body deltas. For a higher-level
+* `AsyncIterable` API, see `stream.ts`.
+*/
+var StreamingMessageParser = class {
+	_maxPropsLength;
+	_state = "idle";
+	_items = [];
+	_diagnostics = [];
+	_current;
+	_currentReady = false;
+	_counter = 0;
+	_finished = false;
+	_directiveBuffer = "";
+	_nameBuffer = "";
+	_propsBuffer = "";
+	_propsDepth = 0;
+	_quoteChar;
+	_escaped = false;
+	_propsBroken = false;
+	_bodyDelta = "";
+	_pendingWhitespace = "";
+	_preambleHeader;
+	_closingFenceTicks;
+	constructor(options = {}) {
+		this._maxPropsLength = options.maxPropsLength ?? 1e5;
+	}
+	/** All items parsed so far, in order of appearance. */
+	get items() {
+		return [...this._items];
+	}
+	/** All syntax diagnostics, including discarded text that has no protocol item. */
+	get diagnostics() {
+		return [...this._diagnostics];
+	}
+	push(chunk) {
+		if (this._finished) throw new Error("Parser has already finished. Call reset() before parsing a new stream.");
+		const events = [];
+		for (const char of chunk) this._processChar(char, events);
+		this._flushBodyDelta(events);
+		return events;
+	}
+	/**
+	* Signals the end of the transport stream.
+	* Pass `'interrupted'` when the stream was cut short (aborted request, network
+	* error) so the active item is marked `interrupted` instead of `complete`.
+	* All received content is preserved either way.
+	*/
+	finish(reason = "end") {
+		if (this._finished) return [];
+		this._finished = true;
+		const events = [];
+		if (this._closingFenceTicks !== void 0 && this._closingFenceTicks !== 3) this._skipUnexpectedText(events);
+		this._closingFenceTicks = void 0;
+		const status = reason === "interrupted" ? "interrupted" : void 0;
+		if (this._state === "skip" && this._preambleHeader) this._recoverPreambleHeader(events);
+		switch (this._state) {
+			case "directive":
+				this._endDirective(events, void 0);
+				this._completeCurrent(events, status);
+				break;
+			case "name":
+				this._endName(events);
+				this._completeCurrent(events, status);
+				break;
+			case "header":
+			case "body-wait":
+				this._completeCurrent(events, status);
+				break;
+			case "props":
+				this._endPartialProps(events);
+				this._completeCurrent(events, "interrupted");
+				break;
+			case "body":
+				this._pendingWhitespace = "";
+				this._flushBodyDelta(events);
+				this._completeCurrent(events, status);
+		}
+		return events;
+	}
+	reset() {
+		this._state = "idle";
+		this._items = [];
+		this._diagnostics = [];
+		this._current = void 0;
+		this._currentReady = false;
+		this._counter = 0;
+		this._finished = false;
+		this._directiveBuffer = "";
+		this._nameBuffer = "";
+		this._propsBuffer = "";
+		this._propsDepth = 0;
+		this._quoteChar = void 0;
+		this._escaped = false;
+		this._propsBroken = false;
+		this._bodyDelta = "";
+		this._pendingWhitespace = "";
+		this._preambleHeader = void 0;
+		this._closingFenceTicks = void 0;
+	}
+	_processChar(char, events) {
+		if (this._closingFenceTicks !== void 0) {
+			if (char === "`" && this._closingFenceTicks < 3) {
+				this._closingFenceTicks++;
+				return;
+			}
+			if (isWhitespace(char) && this._closingFenceTicks === 3) return;
+			this._closingFenceTicks = void 0;
+			this._skipUnexpectedText(events);
+		}
+		switch (this._state) {
+			case "idle":
+				if (char === "■") this._beginItem();
+				else if (!isWhitespace(char)) {
+					const last = this._items.at(-1);
+					if (char === "`" && (last === null || last === void 0 ? void 0 : last.kind) === "next" && last.status === "complete") {
+						this._closingFenceTicks = 1;
+						return;
+					}
+					this._skipUnexpectedText(events);
+					if (!this._items.length) this._preambleHeader = "";
+				}
+				return;
+			case "directive":
+				if (char === "=") this._endDirective(events, "=");
+				else if (char === "■") {
+					this._endDirective(events, void 0);
+					this._completeCurrent(events);
+					this._beginItem();
+				} else if (char === "\n") this._endDirective(events, "\n");
+				else if (isWhitespace(char)) this._endDirective(events, " ");
+				else if (char === "{") this._endDirective(events, "{");
+				else this._directiveBuffer += char;
+				return;
+			case "name":
+				if (char === "■") {
+					this._endName(events);
+					this._completeCurrent(events);
+					this._beginItem();
+				} else if (char === "{") {
+					this._endName(events);
+					this._afterHeaderChar(char, events);
+				} else if (char === "\n") {
+					this._endName(events);
+					this._afterHeaderChar(char, events);
+				} else if (isWhitespace(char)) {
+					this._endName(events);
+					this._state = "header";
+				} else this._nameBuffer += char;
+				return;
+			case "header":
+				this._afterHeaderChar(char, events);
+				return;
+			case "props":
+				this._processPropsChar(char, events);
+				return;
+			case "body-wait":
+				if (char === "■") {
+					this._completeCurrent(events);
+					this._beginItem();
+				} else if (!isWhitespace(char)) {
+					this._startBody(events);
+					this._appendBody(char);
+				}
+				return;
+			case "body":
+				if (char === "■") {
+					this._pendingWhitespace = "";
+					this._flushBodyDelta(events);
+					this._completeCurrent(events);
+					this._beginItem();
+				} else this._appendBody(char);
+				return;
+			case "skip":
+				if (this._preambleHeader !== void 0) {
+					if (char === "■") this._preambleHeader = "■";
+					else if (this._preambleHeader) {
+						this._preambleHeader += char;
+						if (char === "\n") this._recoverPreambleHeader(events);
+						else if (this._preambleHeader.length > this._maxPropsLength) this._preambleHeader = "";
+					}
+					return;
+				}
+				if (char === "■") this._beginItem();
+				return;
+		}
+	}
+	_recoverPreambleHeader(events) {
+		const header = this._preambleHeader ?? "";
+		if (/^■(?:run|(?:send|next)=[a-z][a-z0-9_-]*(?:[ \t]*\{[^\r\n]*\})?)[ \t]*\r?\n?$/i.test(header)) {
+			this._preambleHeader = void 0;
+			this._state = "idle";
+			for (const char of header) this._processChar(char, events);
+		} else this._preambleHeader = "";
+	}
+	/** Handles a character on the header line, after the directive and name have been parsed. */
+	_afterHeaderChar(char, events) {
+		const item = this._current;
+		if (char === "■") {
+			this._completeCurrent(events);
+			this._beginItem();
+			return;
+		}
+		if (char === "{" && (item.kind === "send" || item.kind === "next")) {
+			this._startProps(char);
+			return;
+		}
+		if (char === "\n") {
+			if (item.kind === "next") {
+				this._completeCurrent(events);
+				this._state = "idle";
+			} else this._state = "body-wait";
+			return;
+		}
+		if (isWhitespace(char)) return;
+		if (item.kind === "next") {
+			this._completeCurrent(events);
+			this._skipUnexpectedText(events);
+			return;
+		}
+		this._startBody(events);
+		this._appendBody(char);
+	}
+	_processPropsChar(char, events) {
+		this._propsBuffer += char;
+		if (this._propsBuffer.length > this._maxPropsLength) {
+			this._failProps(events, `props exceeded the maximum length of ${this._maxPropsLength} characters`, "props-too-long");
+			this._completeCurrent(events);
+			this._state = "skip";
+			return;
+		}
+		if (this._escaped) {
+			this._escaped = false;
+			return;
+		}
+		if (this._quoteChar) {
+			if (char === "\\") this._escaped = true;
+			else if (char === this._quoteChar) this._quoteChar = void 0;
+			else if (char === "\n" || char === "\r") this._propsBroken = true;
+			else if (char === "■" && this._propsBroken) {
+				this._failProps(events, "props were interrupted by a new block");
+				this._completeCurrent(events);
+				this._beginItem();
+			}
+			return;
+		}
+		if (char === "\"" || char === "'") this._quoteChar = char;
+		else if (char === "■") {
+			this._failProps(events, "props were interrupted by a new block");
+			this._completeCurrent(events);
+			this._beginItem();
+		} else if (char === "{" || char === "[") this._propsDepth++;
+		else if (char === "}" || char === "]") {
+			this._propsDepth--;
+			if (this._propsDepth <= 0) this._endProps(events);
+		}
+	}
+	_beginItem() {
+		const item = {
+			id: `item-${this._counter++}`,
+			kind: "unknown",
+			name: "",
+			props: {},
+			status: "pending",
+			diagnostics: []
+		};
+		this._items.push(item);
+		this._current = item;
+		this._currentReady = false;
+		this._directiveBuffer = "";
+		this._nameBuffer = "";
+		this._state = "directive";
+	}
+	/**
+	* Finalizes the directive token. `terminator` tells us what ended it:
+	* '=' (a name follows), whitespace/newline/'{' (no name), or undefined (■ or end of stream).
+	*/
+	_endDirective(events, terminator) {
+		const item = this._current;
+		const directive = this._directiveBuffer.toLowerCase();
+		if (directive === "send" || directive === "next" || directive === "run") item.kind = directive;
+		else {
+			item.kind = "unknown";
+			item.status = "invalid";
+			this._diagnostic(events, {
+				code: "invalid-directive",
+				message: `Unknown directive "■${this._directiveBuffer}". Expected ■send, ■run or ■next.`,
+				itemId: item.id
+			});
+			events.push({
+				type: "item-start",
+				item
+			});
+			this._completeCurrent(events);
+			this._state = "skip";
+			return;
+		}
+		if (item.kind === "run") {
+			events.push({
+				type: "item-start",
+				item
+			});
+			if (terminator === "=") {
+				this._diagnostic(events, {
+					code: "invalid-directive",
+					message: "■run does not take a name",
+					itemId: item.id
+				});
+				this._state = "header";
+			} else if (terminator === "\n") this._state = "body-wait";
+			else if (terminator === "{" || terminator === " ") {
+				this._state = "header";
+				if (terminator === "{") {
+					this._startBody(events);
+					this._appendBody("{");
+				}
+			}
+			return;
+		}
+		if (terminator === "=") {
+			this._nameBuffer = "";
+			this._state = "name";
+			return;
+		}
+		item.status = "invalid";
+		this._diagnostic(events, {
+			code: "invalid-name",
+			message: `■${directive} requires a name (e.g. ■${directive}=example)`,
+			itemId: item.id
+		});
+		events.push({
+			type: "item-start",
+			item
+		});
+		if (terminator === "\n") {
+			this._state = item.kind === "next" ? "idle" : "body-wait";
+			if (item.kind === "next") this._completeCurrent(events);
+		} else if (terminator === "{") this._startProps("{");
+		else this._state = "header";
+	}
+	_endName(events) {
+		const item = this._current;
+		const name = this._nameBuffer.toLowerCase();
+		item.name = name;
+		if (!NAME_REGEX.test(name)) {
+			item.status = "invalid";
+			this._diagnostic(events, {
+				code: "invalid-name",
+				message: `Invalid name "${this._nameBuffer}" for ■${item.kind}`,
+				itemId: item.id
+			});
+		}
+		events.push({
+			type: "item-start",
+			item
+		});
+	}
+	_startProps(char) {
+		this._propsBuffer = char;
+		this._propsDepth = 1;
+		this._quoteChar = void 0;
+		this._escaped = false;
+		this._propsBroken = false;
+		this._state = "props";
+	}
+	_endProps(events) {
+		const item = this._current;
+		const parsed = tryParseJson(this._propsBuffer);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) this._failProps(events, "props are not a valid JSON object");
+		else {
+			item.props = parsed;
+			this._ready(events);
+		}
+		if (item.kind === "next") {
+			this._completeCurrent(events);
+			this._state = "idle";
+		} else this._state = "body-wait";
+	}
+	/** Attempts to salvage props that were cut off by the end of the stream. */
+	_endPartialProps(events) {
+		const item = this._current;
+		const repaired = tryParseJson(this._propsBuffer);
+		this._diagnostic(events, {
+			code: "interrupted",
+			message: `Props of ■${item.kind} were interrupted by the end of the stream`,
+			itemId: item.id
+		});
+		if (repaired && typeof repaired === "object" && !Array.isArray(repaired)) item.props = repaired;
+		else {
+			item.status = "invalid";
+			this._diagnostic(events, {
+				code: "invalid-props",
+				message: `Invalid props for ■${item.kind}: props are not a valid JSON object`,
+				itemId: item.id
+			});
+		}
+	}
+	_failProps(events, detail, code = "invalid-props") {
+		const item = this._current;
+		item.status = "invalid";
+		item.props = {};
+		this._diagnostic(events, {
+			code,
+			message: `Invalid props for ■${item.kind}${item.name ? `=${item.name}` : ""}: ${detail}`,
+			itemId: item.id
+		});
+	}
+	_startBody(events) {
+		const item = this._current;
+		this._ready(events);
+		item.body ??= "";
+		this._pendingWhitespace = "";
+		events.push({
+			type: "body-start",
+			itemId: item.id
+		});
+		this._state = "body";
+	}
+	_appendBody(char) {
+		if (isWhitespace(char)) {
+			this._pendingWhitespace += char;
+			return;
+		}
+		if (this._pendingWhitespace) {
+			this._emitBodyText(this._pendingWhitespace);
+			this._pendingWhitespace = "";
+		}
+		this._emitBodyText(char);
+	}
+	_emitBodyText(text) {
+		this._current.body += text;
+		this._bodyDelta += text;
+	}
+	_flushBodyDelta(events) {
+		if (this._bodyDelta && this._current) events.push({
+			type: "body-delta",
+			itemId: this._current.id,
+			delta: this._bodyDelta
+		});
+		this._bodyDelta = "";
+	}
+	_ready(events) {
+		const item = this._current;
+		if (!item || this._currentReady) return;
+		this._currentReady = true;
+		if (item.status !== "invalid") item.status = "streaming";
+		events.push({
+			type: "item-ready",
+			item
+		});
+	}
+	_completeCurrent(events, forcedStatus) {
+		const item = this._current;
+		if (!item) return;
+		this._ready(events);
+		if (item.status !== "invalid") item.status = forcedStatus ?? "complete";
+		events.push({
+			type: "item-complete",
+			item
+		});
+		this._current = void 0;
+		this._currentReady = false;
+	}
+	_skipUnexpectedText(events) {
+		this._diagnostic(events, {
+			code: "unexpected-text",
+			message: "Encountered text outside of a ■ block"
+		});
+		this._state = "skip";
+	}
+	_diagnostic(events, diagnostic) {
+		this._diagnostics.push(diagnostic);
+		if (diagnostic.itemId) {
+			const item = this._items.find((i) => i.id === diagnostic.itemId);
+			item === null || item === void 0 || item.diagnostics.push(diagnostic);
+		}
+		events.push({
+			type: "diagnostic",
+			diagnostic
+		});
+	}
+};
+//#endregion
+//#region src/prompts/common.ts
+var common_exports = /* @__PURE__ */ require_compiler.__exportAll({
+	parseAssistantResponse: () => parseAssistantResponse,
+	replacePlaceholders: () => replacePlaceholders,
+	toParsedAssistantResponse: () => toParsedAssistantResponse
+});
+/** Strips wrapping code fences the model may have added around the whole response. */
+const stripWrappingFences = (text) => text.trim().split("\n").filter((line, index, arr) => {
+	if ((index === 0 || index === arr.length - 1) && line.trim().startsWith("```")) return false;
+	return true;
+}).join("\n");
+/** Builds a {@link ParsedAssistantResponse} from parsed protocol items. */
+const toParsedAssistantResponse = (items, raw, diagnostics = []) => {
+	var _run$body;
+	const runIndex = items.findIndex((item) => item.kind === "run");
+	const run = items[runIndex];
+	const awaitsResult = !!(run === null || run === void 0 ? void 0 : run.body) && require_compiler.hasTopLevelReturn(run.body);
+	const prematureSends = awaitsResult ? items.slice(runIndex + 1).filter((item) => item.kind === "send") : [];
+	const sends = items.filter((item, index) => item.kind === "send" && (!awaitsResult || index < runIndex)).map((item) => ({
+		name: item.name,
+		props: item.props,
+		body: item.body
+	}));
+	const next = items.find((item) => item.kind === "next" && item.status !== "invalid");
+	return {
+		raw,
+		items,
+		diagnostics: [...diagnostics, ...prematureSends.map((item) => ({
+			code: "send-after-run",
+			itemId: item.id,
+			message: "Discarded a message generated after code returning a result, before that result was available to the model."
+		}))],
+		sends,
+		code: (run === null || run === void 0 || (_run$body = run.body) === null || _run$body === void 0 ? void 0 : _run$body.trim()) || void 0,
+		next: next ? {
+			name: next.name,
+			props: next.props
+		} : void 0
+	};
+};
+const parseAssistantResponse = (response) => {
+	const parser = new StreamingMessageParser();
+	parser.push(stripWrappingFences(response));
+	parser.finish();
+	return toParsedAssistantResponse(parser.items, response, parser.diagnostics);
+};
+const replacePlaceholders = (prompt, values) => {
+	const regex = /* @__PURE__ */ new RegExp("■■■([A-Z0-9_\\.-]+)■■■", "gi");
+	const obj = Object.assign({}, values);
+	const replaced = prompt.replace(regex, (_match, name) => {
+		if (name in values) {
+			delete obj[name];
+			return typeof values[name] === "string" ? values[name] : JSON.stringify(values[name]);
+		} else throw new Error(`Placeholder not found: ${name}`);
+	});
+	const remaining = Object.keys(obj).filter((key) => key !== "is_message_enabled" && key !== "exits" && key !== "components" && key !== "transcript");
+	if (remaining.length) throw new Error(`Missing placeholders: ${remaining.join(", ")}`);
+	return replaced.replace(/\n{3,}/g, "\n\n").trim();
+};
+//#endregion
+Object.defineProperty(exports, "MARKER", {
+	enumerable: true,
+	get: function() {
+		return MARKER;
+	}
+});
+Object.defineProperty(exports, "NAME_REGEX", {
+	enumerable: true,
+	get: function() {
+		return NAME_REGEX;
+	}
+});
+Object.defineProperty(exports, "StreamingMessageParser", {
+	enumerable: true,
+	get: function() {
+		return StreamingMessageParser;
+	}
+});
+Object.defineProperty(exports, "common_exports", {
+	enumerable: true,
+	get: function() {
+		return common_exports;
+	}
+});
+Object.defineProperty(exports, "parseAssistantResponse", {
+	enumerable: true,
+	get: function() {
+		return parseAssistantResponse;
+	}
+});
+Object.defineProperty(exports, "replacePlaceholders", {
+	enumerable: true,
+	get: function() {
+		return replacePlaceholders;
+	}
+});
+Object.defineProperty(exports, "toParsedAssistantResponse", {
+	enumerable: true,
+	get: function() {
+		return toParsedAssistantResponse;
+	}
+});
+Object.defineProperty(exports, "tryParseJson", {
+	enumerable: true,
+	get: function() {
+		return tryParseJson;
+	}
+});