llmz 0.9.0 → 1.0.2

package/dist/errors-Crk5P8jo.js

@@ -0,0 +1,636 @@
+//#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
+export { MemoryValueError as A, UnknownExitError as B, InvalidMessageError as C, LLMzError as D, InvalidToolError as E, SessionStateError as F, isCriticalError as H, TokenOverflowError as I, ToolExecutionError as L, NativeProtocolError as M, ObjectPropertyError as N, LoopExceededError as O, ReservedIdentifierError as P, ToolInputError as R, InvalidExitError as S, InvalidSessionError as T, isLLMzError as U, UnknownToolError as V, InternalError as _, cleanStackTrace as a, InvalidConfigurationError as b, CodeFormattingError as c, ComponentInputError as d, DeliveryError as f, HostOperationError as g, HookError as h, describeError as i, MissingChatResponseError as j, MemoryCapacityError as k, CognitiveError as l, ExitInputError as m, ThinkSignal as n, AssignmentError as o, ExecutionAbortedError as p, VMSignal as r, CodeExecutionError as s, Signals as t, CompactionError as u, InvalidCodeError as v, InvalidObjectError as w, InvalidEventError as x, InvalidComponentError as y, UnknownComponentError as z };