llmz 0.9.0 → 1.0.2

package/dist/errors-C6ppQUZX.cjs

@@ -0,0 +1,893 @@
+//#region src/errors/catalog.ts
+const ERROR_BRAND = Symbol.for("llmz.error.v1");
+/** Stable library failures. Control-flow signals (such as ThinkSignal) are not errors. */
+var LLMzError = class extends Error {
+	critical;
+	constructor(message, critical, options) {
+		super(message, options);
+		this.critical = critical;
+		this.name = new.target.name;
+	}
+	/** Shared across independently loaded copies of the library. */
+	get [ERROR_BRAND]() {
+		return true;
+	}
+	static is = (value) => isLLMzError(value);
+};
+function validationMessage(subject, issues, expectedInput) {
+	return `${subject} received invalid input:\n${issues.map((issue) => `- ${issue.path.join(".") || "input"}: ${issue.message}`).join("\n")}\n\nExpected input (TypeScript):\n${expectedInput}`;
+}
+var CodeExecutionError = class extends LLMzError {
+	source;
+	stacktrace;
+	originalErrorName;
+	static is = (value) => isLLMzError(value, "EXECUTION_FAILED");
+	code = "EXECUTION_FAILED";
+	constructor(message, source, stacktrace, originalErrorName, cause) {
+		super(message, isCriticalError(cause), { cause });
+		this.source = source;
+		this.stacktrace = stacktrace;
+		this.originalErrorName = originalErrorName;
+	}
+};
+var InvalidCodeError = class extends LLMzError {
+	source;
+	static is = (value) => isLLMzError(value, "INVALID_CODE");
+	code = "INVALID_CODE";
+	constructor(message, source, options) {
+		super(message, false, options);
+		this.source = source;
+	}
+};
+var CodeFormattingError = class extends LLMzError {
+	source;
+	static is = (value) => isLLMzError(value, "CODE_FORMATTING_FAILED");
+	code = "CODE_FORMATTING_FAILED";
+	constructor(message, source) {
+		super(message, true);
+		this.source = source;
+	}
+};
+var ToolInputError = class extends LLMzError {
+	toolName;
+	issues;
+	expectedInput;
+	static is = (value) => isLLMzError(value, "INVALID_TOOL_INPUT");
+	code = "INVALID_TOOL_INPUT";
+	constructor(toolName, issues, expectedInput) {
+		super(validationMessage(`Tool "${toolName}"`, issues, expectedInput), false);
+		this.toolName = toolName;
+		this.issues = issues;
+		this.expectedInput = expectedInput;
+	}
+};
+var ExitInputError = class extends LLMzError {
+	exitName;
+	issues;
+	expectedInput;
+	static is = (value) => isLLMzError(value, "INVALID_EXIT_INPUT");
+	code = "INVALID_EXIT_INPUT";
+	constructor(exitName, issues, expectedInput) {
+		super(validationMessage(`Exit "${exitName}"`, issues, expectedInput), false);
+		this.exitName = exitName;
+		this.issues = issues;
+		this.expectedInput = expectedInput;
+	}
+};
+var ObjectPropertyError = class extends LLMzError {
+	objectName;
+	propertyName;
+	issues;
+	expectedInput;
+	static is = (value) => isLLMzError(value, "INVALID_OBJECT_PROPERTY");
+	code = "INVALID_OBJECT_PROPERTY";
+	constructor(objectName, propertyName, issues, expectedInput) {
+		super(validationMessage(`Object property ${objectName}.${propertyName}`, issues, expectedInput), false);
+		this.objectName = objectName;
+		this.propertyName = propertyName;
+		this.issues = issues;
+		this.expectedInput = expectedInput;
+	}
+};
+var ComponentInputError = class extends LLMzError {
+	componentName;
+	issues;
+	expectedInput;
+	static is = (value) => isLLMzError(value, "INVALID_COMPONENT_INPUT");
+	code = "INVALID_COMPONENT_INPUT";
+	constructor(componentName, issues, expectedInput) {
+		super(validationMessage(`Component "${componentName}"`, issues, expectedInput), false);
+		this.componentName = componentName;
+		this.issues = issues;
+		this.expectedInput = expectedInput;
+	}
+};
+var UnknownToolError = class extends LLMzError {
+	toolName;
+	availableTools;
+	static is = (value) => isLLMzError(value, "UNKNOWN_TOOL");
+	code = "UNKNOWN_TOOL";
+	constructor(toolName, availableTools = [], message) {
+		super(message ?? `Tool "${toolName}" is not available. Use a documented tool from the JavaScript API.`, false);
+		this.toolName = toolName;
+		this.availableTools = availableTools;
+	}
+};
+var UnknownComponentError = class extends LLMzError {
+	componentName;
+	availableComponents;
+	static is = (value) => isLLMzError(value, "UNKNOWN_COMPONENT");
+	code = "UNKNOWN_COMPONENT";
+	constructor(componentName, availableComponents) {
+		super(`Component "chat.${componentName}" is not available. Available components: ${availableComponents.map((name) => `chat.${name}`).join(", ") || "(none)"}. Use native assistant text for ordinary replies.`, false);
+		this.componentName = componentName;
+		this.availableComponents = availableComponents;
+	}
+};
+var UnknownExitError = class extends LLMzError {
+	exitName;
+	availableExits;
+	static is = (value) => isLLMzError(value, "UNKNOWN_EXIT");
+	code = "UNKNOWN_EXIT";
+	constructor(exitName, availableExits) {
+		super(`Exit "${exitName}" is not available. Use a registered exit name. Available exits: ${availableExits.join(", ")}.`, false);
+		this.exitName = exitName;
+		this.availableExits = availableExits;
+	}
+};
+var ReservedIdentifierError = class extends LLMzError {
+	identifier;
+	kind;
+	static is = (value) => isLLMzError(value, "RESERVED_IDENTIFIER");
+	code = "RESERVED_IDENTIFIER";
+	constructor(identifier, kind, critical = kind !== "variable", message = `Runtime name "${identifier}" is reserved.`) {
+		super(message, critical);
+		this.identifier = identifier;
+		this.kind = kind;
+	}
+};
+var ToolExecutionError = class extends LLMzError {
+	toolName;
+	static is = (value) => isLLMzError(value, "TOOL_EXECUTION_FAILED");
+	code = "TOOL_EXECUTION_FAILED";
+	constructor(toolName, cause) {
+		super(cause instanceof Error ? cause.message : String(cause), false, { cause });
+		this.toolName = toolName;
+	}
+};
+var LoopExceededError = class extends LLMzError {
+	limit;
+	static is = (value) => isLLMzError(value, "ITERATION_LIMIT");
+	code = "ITERATION_LIMIT";
+	constructor(limit) {
+		super("Loop exceeded error", true);
+		this.limit = limit;
+	}
+};
+var TokenOverflowError = class extends LLMzError {
+	tokens;
+	limit;
+	phase;
+	static is = (value) => isLLMzError(value, "TOKEN_OVERFLOW");
+	code = "TOKEN_OVERFLOW";
+	constructor(message, tokens, limit, phase = "input") {
+		super(message, true);
+		this.tokens = tokens;
+		this.limit = limit;
+		this.phase = phase;
+	}
+};
+var MemoryCapacityError = class extends LLMzError {
+	maxBytes;
+	static is = (value) => isLLMzError(value, "MEMORY_CAPACITY");
+	code = "MEMORY_CAPACITY";
+	constructor(maxBytes) {
+		super(`Memory limit exceeded (${maxBytes} bytes). Compact retained iterations before continuing.`, true);
+		this.maxBytes = maxBytes;
+	}
+};
+/** A generated program tried to change read-only runtime state. */
+var AssignmentError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_ASSIGNMENT");
+	code = "INVALID_ASSIGNMENT";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** The provider failed, or returned an incomplete or malformed generation. */
+var CognitiveError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "GENERATION_FAILED");
+	code = "GENERATION_FAILED";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Summarization failed; canonical history is preserved. */
+var CompactionError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "COMPACTION_FAILED");
+	code = "COMPACTION_FAILED";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid tool definition. */
+var InvalidToolError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_TOOL");
+	code = "INVALID_TOOL";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid object definition. */
+var InvalidObjectError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_OBJECT");
+	code = "INVALID_OBJECT";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid exit definition. */
+var InvalidExitError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_EXIT");
+	code = "INVALID_EXIT";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid chat component definition. */
+var InvalidComponentError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_COMPONENT");
+	code = "INVALID_COMPONENT";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid execution, chat, or library configuration. */
+var InvalidConfigurationError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_CONFIG");
+	code = "INVALID_CONFIG";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid session input message. */
+var InvalidMessageError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_MESSAGE");
+	code = "INVALID_MESSAGE";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid external event name or payload. */
+var InvalidEventError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_EVENT");
+	code = "INVALID_EVENT";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** Invalid persisted session or native history. */
+var InvalidSessionError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_SESSION");
+	code = "INVALID_SESSION";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** The operation is not allowed in the current session state. */
+var SessionStateError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "SESSION_STATE");
+	code = "SESSION_STATE";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** A value cannot be retained in session memory. */
+var MemoryValueError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_MEMORY_VALUE");
+	code = "INVALID_MEMORY_VALUE";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** The model returned an invalid native tool call. */
+var NativeProtocolError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INVALID_NATIVE_CALL");
+	code = "INVALID_NATIVE_CALL";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** Generated code used a closed or unawaited host operation. */
+var HostOperationError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "HOST_OPERATION_FAILED");
+	code = "HOST_OPERATION_FAILED";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** Chat tried to wait for the user without delivering any message. */
+var MissingChatResponseError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "MISSING_CHAT_RESPONSE");
+	code = "MISSING_CHAT_RESPONSE";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** Message delivery failed; external delivery may have partially completed. */
+var DeliveryError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "DELIVERY_FAILED");
+	code = "DELIVERY_FAILED";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** An execution hook failed; its external effects may be incomplete. */
+var HookError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "HOOK_FAILED");
+	code = "HOOK_FAILED";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
+/** Execution was cancelled or timed out. */
+var ExecutionAbortedError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "EXECUTION_ABORTED");
+	code = "EXECUTION_ABORTED";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** An unexpected library failure; inspect cause for the original exception. */
+var InternalError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "INTERNAL_ERROR");
+	code = "INTERNAL_ERROR";
+	constructor(message, options) {
+		super(message, true, options);
+	}
+};
+/** @internal Constructor registry for VM diagnostics. */
+const errorClasses$1 = {
+	CodeExecutionError,
+	InvalidCodeError,
+	CodeFormattingError,
+	ToolInputError,
+	ExitInputError,
+	ObjectPropertyError,
+	ComponentInputError,
+	UnknownToolError,
+	UnknownExitError,
+	UnknownComponentError,
+	ReservedIdentifierError,
+	ToolExecutionError,
+	LoopExceededError,
+	TokenOverflowError,
+	MemoryCapacityError,
+	AssignmentError,
+	CognitiveError,
+	CompactionError,
+	InvalidToolError,
+	InvalidObjectError,
+	InvalidExitError,
+	InvalidComponentError,
+	InvalidConfigurationError,
+	InvalidMessageError,
+	InvalidEventError,
+	InvalidSessionError,
+	SessionStateError,
+	MemoryValueError,
+	NativeProtocolError,
+	HostOperationError,
+	DeliveryError,
+	MissingChatResponseError,
+	HookError,
+	ExecutionAbortedError,
+	InternalError
+};
+const ERROR_CODES = /* @__PURE__ */ new Set([
+	"EXECUTION_FAILED",
+	"INVALID_CODE",
+	"CODE_FORMATTING_FAILED",
+	"INVALID_TOOL_INPUT",
+	"INVALID_EXIT_INPUT",
+	"INVALID_OBJECT_PROPERTY",
+	"INVALID_COMPONENT_INPUT",
+	"UNKNOWN_TOOL",
+	"UNKNOWN_COMPONENT",
+	"UNKNOWN_EXIT",
+	"RESERVED_IDENTIFIER",
+	"TOOL_EXECUTION_FAILED",
+	"ITERATION_LIMIT",
+	"TOKEN_OVERFLOW",
+	"MEMORY_CAPACITY",
+	"INVALID_ASSIGNMENT",
+	"GENERATION_FAILED",
+	"COMPACTION_FAILED",
+	"INVALID_TOOL",
+	"INVALID_OBJECT",
+	"INVALID_EXIT",
+	"INVALID_COMPONENT",
+	"INVALID_CONFIG",
+	"INVALID_MESSAGE",
+	"INVALID_EVENT",
+	"INVALID_SESSION",
+	"SESSION_STATE",
+	"INVALID_MEMORY_VALUE",
+	"INVALID_NATIVE_CALL",
+	"HOST_OPERATION_FAILED",
+	"DELIVERY_FAILED",
+	"MISSING_CHAT_RESPONSE",
+	"HOOK_FAILED",
+	"EXECUTION_ABORTED",
+	"INTERNAL_ERROR"
+]);
+function isLLMzError(error, code) {
+	if (!error || typeof error !== "object") return false;
+	try {
+		const value = error;
+		return value[ERROR_BRAND] === true && typeof value.message === "string" && typeof value.name === "string" && typeof value.critical === "boolean" && typeof value.code === "string" && ERROR_CODES.has(value.code) && (code === void 0 || value.code === code);
+	} catch {
+		return false;
+	}
+}
+/** Critical errors end execution; they are never sent back to the model for retry. */
+function isCriticalError(error) {
+	return isLLMzError(error) && error.critical;
+}
+//#endregion
+//#region src/stack-traces.ts
+const isInternalLine = (line) => {
+	return line.includes("/llmz/") || line.includes("\\llmz\\src\\") || line.includes("node_modules");
+};
+function cleanStackTrace(stack, cleanInternal = true) {
+	let lines = stack.split("\n");
+	const until = lines.findIndex((line) => isInternalLine(line));
+	if (cleanInternal && until >= 0) lines = lines.slice(0, until);
+	else lines = lines.map((line) => {
+		let llmzIndex = line.indexOf("/llmz/");
+		if (llmzIndex === -1) llmzIndex = line.indexOf("\\llmz\\");
+		if (llmzIndex === -1) return line;
+		let lastSpaceIndex = line.lastIndexOf(" ", llmzIndex);
+		if (lastSpaceIndex === -1) lastSpaceIndex = 0;
+		const maybeParen = line[lastSpaceIndex + 1] === "(" ? "(" : "";
+		return line.slice(0, lastSpaceIndex + 1) + maybeParen + line.slice(llmzIndex);
+	});
+	return lines.join("\n");
+}
+//#endregion
+//#region src/errors.ts
+const errorClasses = { ...errorClasses$1 };
+/** @internal Serialize diagnostics without losing non-enumerable Error fields. */
+function describeError(error, seen = /* @__PURE__ */ new Set()) {
+	const value = Signals.maybeDeserializeError(error);
+	const details = {
+		...diagnosticProperties(value),
+		name: value.name === "Error" ? value.constructor.name : value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	delete details.cause;
+	seen.add(error);
+	if (value.cause instanceof Error && !seen.has(value.cause)) details.cause = describeError(value.cause, seen);
+	else if (value.cause !== void 0 && !(value.cause instanceof Error)) details.cause = {
+		name: "ThrownValue",
+		message: String(value.cause),
+		value: diagnosticValue(value.cause)
+	};
+	return details;
+}
+/** User-supplied exceptions can carry cycles, bigint metadata, or throwing accessors. */
+function diagnosticValue(value) {
+	if (value === void 0) return;
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		const encoded = JSON.stringify(value, (_key, item) => {
+			if (typeof item === "bigint") return item.toString();
+			if (item && typeof item === "object") {
+				if (seen.has(item)) return "[Circular]";
+				seen.add(item);
+			}
+			return item;
+		});
+		return encoded === void 0 ? String(value) : JSON.parse(encoded);
+	} catch {
+		return "[Unserializable]";
+	}
+}
+function diagnosticProperties(error) {
+	const entries = Object.entries(Object.getOwnPropertyDescriptors(error)).filter(([key, descriptor]) => key !== "cause" && descriptor.enumerable && "value" in descriptor).map(([key, descriptor]) => [key, diagnosticValue(descriptor.value)]);
+	return Object.fromEntries(entries);
+}
+function registerErrorClass(name, errorClass) {
+	errorClasses[name] = errorClass;
+}
+const tryParseMessage = (str) => {
+	try {
+		return JSON.parse(str);
+	} catch {
+		return str;
+	}
+};
+let Signals;
+(function(_Signals) {
+	function isWrappedError(error) {
+		var _error$message, _error$message2;
+		return error.name === "Error" && (error === null || error === void 0 || (_error$message = error.message) === null || _error$message === void 0 ? void 0 : _error$message.startsWith("{")) && (error === null || error === void 0 || (_error$message2 = error.message) === null || _error$message2 === void 0 ? void 0 : _error$message2.endsWith("}"));
+	}
+	_Signals.isWrappedError = isWrappedError;
+	function serializeError(error, seen = /* @__PURE__ */ new Set()) {
+		seen.add(error);
+		const properties = diagnosticProperties(error);
+		if (error.cause instanceof Error && !seen.has(error.cause)) Object.assign(properties, { cause: serializeError(error.cause, seen) });
+		else if (error.cause !== void 0 && !(error.cause instanceof Error)) properties.cause = { value: diagnosticValue(error.cause) };
+		if (isWrappedError(error)) {
+			const msg = tryParseMessage(error.message);
+			return JSON.stringify({
+				...typeof msg === "object" ? msg : { message: msg },
+				properties
+			});
+		}
+		return JSON.stringify({
+			name: error.constructor.name,
+			message: error.message,
+			stack: cleanStackTrace(error.stack ?? ""),
+			properties
+		});
+	}
+	_Signals.serializeError = serializeError;
+	function maybeDeserializeError(error) {
+		if (isLLMzError(error) || error instanceof Error && !!errorClasses[error.name] && error instanceof errorClasses[error.name]) return error;
+		let serializedError = (error === null || error === void 0 ? void 0 : error.toString()) ?? "";
+		if (error instanceof Error) serializedError = error.message;
+		else if (typeof error === "string") serializedError = error;
+		try {
+			const parsed = JSON.parse(serializedError);
+			if (parsed && typeof parsed.name === "string" && typeof parsed.message === "string") {
+				const { name, message, properties = {} } = parsed;
+				const ErrorClass = Object.values(errorClasses$1).find((candidate) => candidate.is({
+					...properties,
+					name,
+					message,
+					[Symbol.for("llmz.error.v1")]: true
+				})) ?? (Object.hasOwn(errorClasses, name) ? errorClasses[name] : Error);
+				const errorInstance = Object.setPrototypeOf(new Error(message), ErrorClass.prototype);
+				errorInstance.message = message;
+				errorInstance.name = name;
+				errorInstance.stack = cleanStackTrace((error === null || error === void 0 ? void 0 : error.stack) ?? "");
+				Object.assign(errorInstance, properties);
+				if (typeof properties.cause === "string") errorInstance.cause = maybeDeserializeError(properties.cause);
+				else if (properties.cause && typeof properties.cause === "object" && "value" in properties.cause) errorInstance.cause = properties.cause.value;
+				if (isWrappedError(errorInstance)) return maybeDeserializeError(errorInstance);
+				return errorInstance;
+			}
+		} catch {}
+		return error;
+	}
+	_Signals.maybeDeserializeError = maybeDeserializeError;
+})(Signals || (Signals = {}));
+const SIGNAL_BRAND = Symbol.for("llmz.signal.v1");
+function isSignal(value) {
+	if (!value || typeof value !== "object") return false;
+	try {
+		return value[SIGNAL_BRAND] === true;
+	} catch {
+		return false;
+	}
+}
+var VMSignal = class extends Error {
+	message;
+	get [SIGNAL_BRAND]() {
+		return true;
+	}
+	signalKind = "vm";
+	static is = (value) => isSignal(value);
+	/**
+	* The code that was executed by the VM up to the point of the signal
+	*/
+	truncatedCode = "";
+	/**
+	* Contains all the declared and executed variables during the VM execution
+	* See file plugins/variable-extraction.ts for more details
+	*/
+	variables = {};
+	constructor(message) {
+		super(message);
+		this.message = message;
+		this.message = Signals.serializeError(this);
+	}
+};
+/** Loop means LLMz will continue the execution (unless it exhausted its iterations) */
+var VMLoopSignal = class extends VMSignal {
+	signalKind = "loop";
+	static is = (value) => isSignal(value) && (value.signalKind === "loop" || value.signalKind === "think");
+	constructor(message) {
+		super(message);
+		this.message = Signals.serializeError(this);
+	}
+};
+/**
+* A successful tool result that requires model inspection before completion.
+* Tools may throw or return this signal. Its context becomes the JavaScript
+* return value; calls and assignments continue, and inspection overrides any
+* attempted exit at iteration settlement. Cancellation and critical errors still stop execution.
+*/
+var ThinkSignal = class extends VMLoopSignal {
+	reason;
+	context;
+	metadata;
+	signalKind = "think";
+	static is = (value) => isSignal(value) && value.signalKind === "think";
+	constructor(reason, context, metadata) {
+		super("Think signal received: " + reason);
+		this.reason = reason;
+		this.context = context;
+		this.metadata = metadata;
+		this.message = Signals.serializeError(this);
+		this.stack = "";
+	}
+	toString() {
+		return Signals.serializeError(this);
+	}
+};
+registerErrorClass("VMSignal", VMSignal);
+registerErrorClass("VMLoopSignal", VMLoopSignal);
+registerErrorClass("ThinkSignal", ThinkSignal);
+//#endregion
+Object.defineProperty(exports, "AssignmentError", {
+	enumerable: true,
+	get: function() {
+		return AssignmentError;
+	}
+});
+Object.defineProperty(exports, "CodeExecutionError", {
+	enumerable: true,
+	get: function() {
+		return CodeExecutionError;
+	}
+});
+Object.defineProperty(exports, "CodeFormattingError", {
+	enumerable: true,
+	get: function() {
+		return CodeFormattingError;
+	}
+});
+Object.defineProperty(exports, "CognitiveError", {
+	enumerable: true,
+	get: function() {
+		return CognitiveError;
+	}
+});
+Object.defineProperty(exports, "CompactionError", {
+	enumerable: true,
+	get: function() {
+		return CompactionError;
+	}
+});
+Object.defineProperty(exports, "ComponentInputError", {
+	enumerable: true,
+	get: function() {
+		return ComponentInputError;
+	}
+});
+Object.defineProperty(exports, "DeliveryError", {
+	enumerable: true,
+	get: function() {
+		return DeliveryError;
+	}
+});
+Object.defineProperty(exports, "ExecutionAbortedError", {
+	enumerable: true,
+	get: function() {
+		return ExecutionAbortedError;
+	}
+});
+Object.defineProperty(exports, "ExitInputError", {
+	enumerable: true,
+	get: function() {
+		return ExitInputError;
+	}
+});
+Object.defineProperty(exports, "HookError", {
+	enumerable: true,
+	get: function() {
+		return HookError;
+	}
+});
+Object.defineProperty(exports, "HostOperationError", {
+	enumerable: true,
+	get: function() {
+		return HostOperationError;
+	}
+});
+Object.defineProperty(exports, "InternalError", {
+	enumerable: true,
+	get: function() {
+		return InternalError;
+	}
+});
+Object.defineProperty(exports, "InvalidCodeError", {
+	enumerable: true,
+	get: function() {
+		return InvalidCodeError;
+	}
+});
+Object.defineProperty(exports, "InvalidComponentError", {
+	enumerable: true,
+	get: function() {
+		return InvalidComponentError;
+	}
+});
+Object.defineProperty(exports, "InvalidConfigurationError", {
+	enumerable: true,
+	get: function() {
+		return InvalidConfigurationError;
+	}
+});
+Object.defineProperty(exports, "InvalidEventError", {
+	enumerable: true,
+	get: function() {
+		return InvalidEventError;
+	}
+});
+Object.defineProperty(exports, "InvalidExitError", {
+	enumerable: true,
+	get: function() {
+		return InvalidExitError;
+	}
+});
+Object.defineProperty(exports, "InvalidMessageError", {
+	enumerable: true,
+	get: function() {
+		return InvalidMessageError;
+	}
+});
+Object.defineProperty(exports, "InvalidObjectError", {
+	enumerable: true,
+	get: function() {
+		return InvalidObjectError;
+	}
+});
+Object.defineProperty(exports, "InvalidSessionError", {
+	enumerable: true,
+	get: function() {
+		return InvalidSessionError;
+	}
+});
+Object.defineProperty(exports, "InvalidToolError", {
+	enumerable: true,
+	get: function() {
+		return InvalidToolError;
+	}
+});
+Object.defineProperty(exports, "LLMzError", {
+	enumerable: true,
+	get: function() {
+		return LLMzError;
+	}
+});
+Object.defineProperty(exports, "LoopExceededError", {
+	enumerable: true,
+	get: function() {
+		return LoopExceededError;
+	}
+});
+Object.defineProperty(exports, "MemoryCapacityError", {
+	enumerable: true,
+	get: function() {
+		return MemoryCapacityError;
+	}
+});
+Object.defineProperty(exports, "MemoryValueError", {
+	enumerable: true,
+	get: function() {
+		return MemoryValueError;
+	}
+});
+Object.defineProperty(exports, "MissingChatResponseError", {
+	enumerable: true,
+	get: function() {
+		return MissingChatResponseError;
+	}
+});
+Object.defineProperty(exports, "NativeProtocolError", {
+	enumerable: true,
+	get: function() {
+		return NativeProtocolError;
+	}
+});
+Object.defineProperty(exports, "ObjectPropertyError", {
+	enumerable: true,
+	get: function() {
+		return ObjectPropertyError;
+	}
+});
+Object.defineProperty(exports, "ReservedIdentifierError", {
+	enumerable: true,
+	get: function() {
+		return ReservedIdentifierError;
+	}
+});
+Object.defineProperty(exports, "SessionStateError", {
+	enumerable: true,
+	get: function() {
+		return SessionStateError;
+	}
+});
+Object.defineProperty(exports, "Signals", {
+	enumerable: true,
+	get: function() {
+		return Signals;
+	}
+});
+Object.defineProperty(exports, "ThinkSignal", {
+	enumerable: true,
+	get: function() {
+		return ThinkSignal;
+	}
+});
+Object.defineProperty(exports, "TokenOverflowError", {
+	enumerable: true,
+	get: function() {
+		return TokenOverflowError;
+	}
+});
+Object.defineProperty(exports, "ToolExecutionError", {
+	enumerable: true,
+	get: function() {
+		return ToolExecutionError;
+	}
+});
+Object.defineProperty(exports, "ToolInputError", {
+	enumerable: true,
+	get: function() {
+		return ToolInputError;
+	}
+});
+Object.defineProperty(exports, "UnknownComponentError", {
+	enumerable: true,
+	get: function() {
+		return UnknownComponentError;
+	}
+});
+Object.defineProperty(exports, "UnknownExitError", {
+	enumerable: true,
+	get: function() {
+		return UnknownExitError;
+	}
+});
+Object.defineProperty(exports, "UnknownToolError", {
+	enumerable: true,
+	get: function() {
+		return UnknownToolError;
+	}
+});
+Object.defineProperty(exports, "VMSignal", {
+	enumerable: true,
+	get: function() {
+		return VMSignal;
+	}
+});
+Object.defineProperty(exports, "cleanStackTrace", {
+	enumerable: true,
+	get: function() {
+		return cleanStackTrace;
+	}
+});
+Object.defineProperty(exports, "describeError", {
+	enumerable: true,
+	get: function() {
+		return describeError;
+	}
+});
+Object.defineProperty(exports, "isCriticalError", {
+	enumerable: true,
+	get: function() {
+		return isCriticalError;
+	}
+});
+Object.defineProperty(exports, "isLLMzError", {
+	enumerable: true,
+	get: function() {
+		return isLLMzError;
+	}
+});