llmz 0.0.11 → 0.0.13

package/dist/chunk-IH2WQFO5.js

@@ -0,0 +1,283 @@
+import {
+  CodeFormattingError
+} from "./chunk-JKVVQN2P.js";
+import {
+  escapeString,
+  getMultilineComment,
+  toPropertyKey
+} from "./chunk-4MNIJGK6.js";
+
+// src/typings.ts
+import { z } from "@bpinternal/zui";
+
+// src/formatting.ts
+import { LRUCache } from "lru-cache";
+import babel from "prettier/plugins/babel";
+import estree from "prettier/plugins/estree";
+import typescript from "prettier/plugins/typescript";
+import { format } from "prettier/standalone";
+var cache = new LRUCache({ max: 1e3 });
+async function formatTypings(typings, options) {
+  if (cache.has(typings)) {
+    return cache.get(typings);
+  }
+  try {
+    options ??= {};
+    options.throwOnError ??= true;
+    const result = (await format(typings, {
+      singleAttributePerLine: true,
+      bracketSameLine: true,
+      semi: false,
+      ...options,
+      embeddedLanguageFormatting: "off",
+      plugins: [estree, babel, typescript],
+      parser: "typescript",
+      filepath: "tools.d.ts"
+    })).trim();
+    cache.set(typings, result);
+    return result;
+  } catch (err) {
+    if (options == null ? void 0 : options.throwOnError) {
+      throw new CodeFormattingError(err instanceof Error ? err.message : (err == null ? void 0 : err.toString()) ?? "Unknown Error", typings);
+    }
+    return typings;
+  }
+}
+
+// src/typings.ts
+var Primitives = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "void",
+  "any",
+  "null",
+  "undefined",
+  "never",
+  "bigint",
+  "symbol",
+  "object"
+];
+var LARGE_DECLARATION_LINES = 5;
+var isPrimitive = (type) => Primitives.includes(type);
+var isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
+var stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
+var KeyValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var FnParameters = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var FnReturn = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var Declaration = class {
+  constructor(schema, identifier) {
+    this.schema = schema;
+    this.identifier = identifier;
+  }
+};
+async function getTypings(schema, options) {
+  options ??= {};
+  options.declaration ??= false;
+  let wrappedSchema = schema;
+  if ((options == null ? void 0 : options.declaration) && schema instanceof z.Schema) {
+    const title = "title" in schema.ui ? schema.ui.title : null;
+    if (!title) {
+      throw new Error('Only schemas with "title" Zui property can be declared.');
+    }
+    wrappedSchema = new Declaration(schema, title);
+  }
+  let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
+  dts = await formatTypings(dts, { throwOnError: false });
+  return dts;
+}
+async function sUnwrapZodRecursive(schema, options) {
+  return sUnwrapZod(schema, options);
+}
+async function sUnwrapZod(schema, options) {
+  var _a, _b;
+  const newOptions = {
+    ...options,
+    declaration: false,
+    parent: schema
+  };
+  if (schema instanceof Declaration) {
+    const description = getMultilineComment(schema.schema.description);
+    const withoutDesc = schema.schema.describe("");
+    const typings = await sUnwrapZodRecursive(withoutDesc, { ...newOptions, declaration: true });
+    const isLargeDeclaration = typings.split("\n").length >= LARGE_DECLARATION_LINES;
+    const closingTag = isLargeDeclaration ? `// end of ${schema.identifier}` : "";
+    if (schema.schema instanceof z.ZodFunction) {
+      return stripSpaces(`${description}
+declare function ${schema.identifier}${typings};${closingTag}`);
+    }
+    return stripSpaces(`${description}
+declare const ${schema.identifier}: ${typings};${closingTag}`);
+  }
+  if (schema instanceof KeyValue) {
+    if (schema.value instanceof z.ZodOptional) {
+      let innerType = schema.value._def.innerType;
+      if (innerType instanceof z.Schema && !innerType.description && schema.value.description) {
+        innerType = innerType == null ? void 0 : innerType.describe(schema.value.description);
+      }
+      const optionalToken = schema.key.endsWith("?") ? "" : "?";
+      return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
+    }
+    const description = getMultilineComment(schema.value._def.description || schema.value.description);
+    const delimiter = (description == null ? void 0 : description.trim().length) > 0 ? "\n" : "";
+    const withoutDesc = schema.value.describe("");
+    return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
+  }
+  if (schema instanceof FnParameters) {
+    if (schema.schema instanceof z.ZodTuple) {
+      let args = "";
+      for (let i = 0; i < schema.schema.items.length; i++) {
+        const argName = ((_b = (_a = schema.schema.items[i]) == null ? void 0 : _a.ui) == null ? void 0 : _b.title) ?? `arg${i}`;
+        const item = schema.schema.items[i];
+        args += `${await sUnwrapZodRecursive(new KeyValue(toPropertyKey(argName), item), newOptions)}, `;
+      }
+      return args;
+    }
+    const isLiteral = schema.schema.naked() instanceof z.ZodLiteral;
+    const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
+    const startsWithPairs = typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings);
+    if (startsWithPairs || isLiteral) {
+      return `args: ${typings}`;
+    } else {
+      return typings;
+    }
+  }
+  if (schema instanceof FnReturn) {
+    if (schema.schema instanceof z.ZodOptional) {
+      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+    }
+    return sUnwrapZodRecursive(schema.schema, newOptions);
+  }
+  if (schema instanceof z.ZodDefault) {
+    return sUnwrapZodRecursive(schema._def.innerType, options);
+  }
+  if (schema instanceof z.ZodVoid) {
+    return "void";
+  }
+  if (schema instanceof z.ZodUnknown) {
+    return "unknown";
+  }
+  if (schema instanceof z.ZodAny) {
+    return "any";
+  }
+  if (schema instanceof z.ZodPromise) {
+    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+  }
+  if (schema instanceof z.ZodFunction) {
+    const description = getMultilineComment(schema._def.description);
+    const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
+    const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
+    if (options == null ? void 0 : options.declaration) {
+      return `${description}
+(${input}): ${output}`;
+    }
+    return `${description}
+(${input}) => ${output}`;
+  }
+  if (schema instanceof z.ZodArray) {
+    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+    if (isPrimitive(item)) {
+      return `${item}[]`;
+    }
+    return `Array<${item}>`;
+  }
+  if (schema instanceof z.ZodEnum) {
+    const values = schema._def.values.map(escapeString);
+    return values.join(" | ");
+  }
+  if (schema instanceof z.ZodTuple) {
+    if (schema.items.length === 0) {
+      return "[]";
+    }
+    const items = await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)));
+    return `[${items.join(", ")}]`;
+  }
+  if (schema instanceof z.ZodNullable) {
+    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+  }
+  if (schema instanceof z.ZodOptional) {
+    if ((options == null ? void 0 : options.declaration) || (options == null ? void 0 : options.parent) instanceof z.ZodRecord) {
+      return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
+    }
+    const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
+    const val = `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
+    return val;
+  }
+  if (schema instanceof z.ZodObject) {
+    const props = await Promise.all(
+      Object.entries(schema.shape).map(async ([key, value]) => {
+        if (value instanceof z.Schema) {
+          return sUnwrapZodRecursive(new KeyValue(toPropertyKey(key), value), newOptions);
+        }
+        return `${key}: unknown`;
+      })
+    );
+    return `{ ${props.join("; ")} }`;
+  }
+  if (schema instanceof z.ZodString) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} string`.trim();
+  }
+  if (schema instanceof z.ZodUnion) {
+    const description = getMultilineComment(schema._def.description);
+    const options2 = await Promise.all(
+      schema.options.map(async (option) => {
+        return sUnwrapZodRecursive(option, newOptions);
+      })
+    );
+    return `${description}
+${options2.join(" | ")}`;
+  }
+  if (schema instanceof z.ZodLiteral) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description}
+${typeof schema.value === "string" ? escapeString(schema.value) : schema.value}`.trim();
+  }
+  if (schema instanceof z.ZodNumber) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} number`.trim();
+  }
+  if (schema instanceof z.ZodBoolean) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} boolean`.trim();
+  }
+  if (schema instanceof z.ZodCatch) {
+    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+  }
+  if (schema instanceof z.ZodLazy) {
+    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+  }
+  if (schema instanceof z.ZodRecord) {
+    const description = getMultilineComment(schema._def.description);
+    const keyType = await sUnwrapZodRecursive(schema._def.keyType, newOptions);
+    const valueType = await sUnwrapZodRecursive(schema._def.valueType, newOptions);
+    return `${description} { [key: (${keyType})]: (${valueType}) }`;
+  }
+  try {
+    let typings = schema == null ? void 0 : schema.toTypescriptType();
+    typings ??= "unknown";
+    return stripSpaces(typings);
+  } catch (error) {
+    console.error("Error in sUnwrapZod", { error, schema, parent: options == null ? void 0 : options.parent });
+    return "unknown";
+  }
+}
+
+export {
+  formatTypings,
+  getTypings
+};

package/dist/chunk-IKSIOIIP.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/stack-traces.ts
+var isInternalLine = (line) => {
+  return line.includes("/llmz/") || line.includes("\\llmz\\src\\") || line.includes("node_modules");
+};
+function cleanStackTrace(stack, cleanInternal = true) {
+  const lines = stack.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let llmzIndex = line.indexOf("/llmz/");
+    if (llmzIndex === -1) {
+      llmzIndex = line.indexOf("\\llmz\\");
+    }
+    if (llmzIndex === -1) {
+      continue;
+    }
+    let lastSpaceIndex = line.lastIndexOf(" ", llmzIndex);
+    if (lastSpaceIndex === -1) {
+      lastSpaceIndex = 0;
+    }
+    const maybeParen = line[lastSpaceIndex + 1] === "(" ? "(" : "";
+    lines[i] = line.slice(0, lastSpaceIndex + 1) + maybeParen + line.slice(llmzIndex);
+  }
+  return lines.filter((x) => !cleanInternal || !isInternalLine(x)).join("\n");
+}
+
+
+
+exports.cleanStackTrace = cleanStackTrace;

package/dist/chunk-JAGB2AOU.js

@@ -0,0 +1,212 @@
+import {
+  getTypings
+} from "./chunk-IH2WQFO5.js";
+import {
+  convertObjectToZuiLiterals,
+  isJsonSchema,
+  isValidIdentifier,
+  isZuiSchema
+} from "./chunk-4MNIJGK6.js";
+import {
+  isEmpty_default,
+  uniq_default
+} from "./chunk-7WRN4E42.js";
+
+// src/tool.ts
+import { z, transforms, ZodObject, ZodType } from "@bpinternal/zui";
+var Tool = class _Tool {
+  _staticInputValues;
+  name;
+  aliases = [];
+  description;
+  metadata;
+  input;
+  output;
+  retry;
+  MAX_RETRIES = 1e3;
+  setStaticInputValues(values) {
+    if (values === null || values === void 0) {
+      this._staticInputValues = void 0;
+      return this;
+    }
+    const input = this.input ? transforms.fromJSONSchemaLegacy(this.input) : z.any();
+    if (input instanceof z.ZodObject && typeof values !== "object") {
+      throw new Error(
+        `Invalid static input values for tool ${this.name}. Expected an object, but got type "${typeof values}"`
+      );
+    }
+    if (input instanceof z.ZodArray && !Array.isArray(values)) {
+      throw new Error(
+        `Invalid static input values for tool ${this.name}. Expected an array, but got type "${typeof values}"`
+      );
+    }
+    this._staticInputValues = values;
+    return this;
+  }
+  get zInput() {
+    let input = this.input ? transforms.fromJSONSchemaLegacy(this.input) : z.any();
+    if (!isEmpty_default(this._staticInputValues)) {
+      const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
+      if (input instanceof z.ZodObject) {
+        input = input.extend(inputExtensions);
+      } else if (input instanceof z.ZodArray) {
+        input = z.array(input.element.extend(inputExtensions));
+      } else {
+        input = inputExtensions;
+      }
+    }
+    return input;
+  }
+  get zOutput() {
+    return this.output ? transforms.fromJSONSchemaLegacy(this.output) : z.void();
+  }
+  rename(name) {
+    const before = this.name;
+    if (!isValidIdentifier(name)) {
+      throw new Error(
+        `Invalid name for tool ${name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`
+      );
+    }
+    this.name = name;
+    this.aliases = uniq_default([name, ...this.aliases.map((alias) => alias === before ? name : alias)]);
+    return this;
+  }
+  clone(props = {}) {
+    var _a, _b;
+    try {
+      const zInput = this.input ? transforms.fromJSONSchemaLegacy(this.input) : void 0;
+      const zOutput = this.output ? transforms.fromJSONSchemaLegacy(this.output) : void 0;
+      return new _Tool({
+        name: props.name ?? this.name,
+        aliases: props.aliases ?? [...this.aliases],
+        description: props.description ?? this.description,
+        metadata: JSON.parse(JSON.stringify(props.metadata ?? this.metadata)),
+        input: typeof props.input === "function" ? (_a = props.input) == null ? void 0 : _a.call(props, zInput) : props.input instanceof ZodType ? props.input : zInput,
+        output: typeof props.output === "function" ? (_b = props.output) == null ? void 0 : _b.call(props, zOutput) : props.output instanceof ZodType ? props.output : zOutput,
+        handler: props.handler ?? this._handler,
+        retry: props.retry ?? this.retry
+      }).setStaticInputValues(props.staticInputValues ?? this._staticInputValues);
+    } catch (e) {
+      throw new Error(`Failed to clone tool "${this.name}": ${e}`);
+    }
+  }
+  _handler;
+  constructor(props) {
+    if (!isValidIdentifier(props.name)) {
+      throw new Error(
+        `Invalid name for tool ${props.name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`
+      );
+    }
+    if (props.description !== void 0 && typeof props.description !== "string") {
+      throw new Error(
+        `Invalid description for tool ${props.name}. Expected a string, but got type "${typeof props.description}"`
+      );
+    }
+    if (props.metadata !== void 0 && typeof props.metadata !== "object") {
+      throw new Error(
+        `Invalid metadata for tool ${props.name}. Expected an object, but got type "${typeof props.metadata}"`
+      );
+    }
+    if (typeof props.handler !== "function") {
+      throw new Error(
+        `Invalid handler for tool ${props.name}. Expected a function, but got type "${typeof props.handler}"`
+      );
+    }
+    if (props.aliases !== void 0 && !Array.isArray(props.aliases)) {
+      throw new Error(
+        `Invalid aliases for tool ${props.name}. Expected an array, but got type "${typeof props.aliases}"`
+      );
+    }
+    if (props.aliases && props.aliases.some((alias) => !isValidIdentifier(alias))) {
+      throw new Error(`Invalid aliases for tool ${props.name}. Expected an array of valid identifiers.`);
+    }
+    if (typeof props.input !== "undefined") {
+      if (isZuiSchema(props.input)) {
+        this.input = transforms.toJSONSchemaLegacy(props.input);
+      } else if (isJsonSchema(props.input)) {
+        this.input = props.input;
+      } else {
+        throw new Error(
+          `Invalid input schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.input}"`
+        );
+      }
+    }
+    if (typeof props.output !== "undefined") {
+      if (isZuiSchema(props.output)) {
+        this.output = transforms.toJSONSchemaLegacy(props.output);
+      } else if (isJsonSchema(props.output)) {
+        this.output = props.output;
+      } else {
+        throw new Error(
+          `Invalid output schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.output}"`
+        );
+      }
+    }
+    this.name = props.name;
+    this.aliases = uniq_default([props.name, ...props.aliases ?? []]);
+    this.description = props.description;
+    this.metadata = props.metadata ?? {};
+    this._handler = props.handler;
+    this.setStaticInputValues(props.staticInputValues);
+    this.retry = props.retry;
+  }
+  async execute(input, ctx) {
+    var _a;
+    const pInput = this.zInput.safeParse(input);
+    if (!pInput.success) {
+      throw new Error(`Tool "${this.name}" received invalid input: ${pInput.error.message}`);
+    }
+    let attempt = 0;
+    while (attempt < this.MAX_RETRIES) {
+      try {
+        const result = await this._handler(pInput.data, ctx);
+        const pOutput = this.zOutput.safeParse(result);
+        return pOutput.success ? pOutput.data : result;
+      } catch (err) {
+        const shouldRetry = await ((_a = this.retry) == null ? void 0 : _a.call(this, {
+          input: pInput.data,
+          attempt: ++attempt,
+          error: err
+        }));
+        if (!shouldRetry) {
+          throw err;
+        }
+      }
+    }
+    throw new Error(
+      `Tool "${this.name}" failed after ${this.MAX_RETRIES} attempts. Last error: ${JSON.stringify(input)}`
+    );
+  }
+  async getTypings() {
+    let input = this.input ? transforms.fromJSONSchemaLegacy(this.input) : void 0;
+    const output = this.output ? transforms.fromJSONSchemaLegacy(this.output) : z.void();
+    if ((input == null ? void 0 : input.naked()) instanceof ZodObject && typeof this._staticInputValues === "object" && !isEmpty_default(this._staticInputValues)) {
+      const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
+      input = input.extend(inputExtensions);
+    } else if (this._staticInputValues !== void 0) {
+      input = convertObjectToZuiLiterals(this._staticInputValues);
+    }
+    const fnType = z.function(input, z.promise(output)).title(this.name).describe(this.description ?? "");
+    return getTypings(fnType, {
+      declaration: true
+    });
+  }
+  static withUniqueNames = (tools) => {
+    const names = /* @__PURE__ */ new Set();
+    return tools.map((tool) => {
+      if (tools.filter((t) => t.name === tool.name).length === 1) {
+        return tool;
+      }
+      let counter = 1;
+      let toolName = tool.name + counter;
+      while (names.has(toolName)) {
+        toolName = `${tool.name}${++counter}`;
+      }
+      return tool.rename(toolName);
+    });
+  };
+};
+
+export {
+  Tool
+};

package/dist/chunk-JDABP4SD.cjs

@@ -0,0 +1,161 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkIKSIOIIPcjs = require('./chunk-IKSIOIIP.cjs');
+
+// src/errors.ts
+var errorClasses = {};
+function registerErrorClass(name, errorClass) {
+  errorClasses[name] = errorClass;
+}
+var tryParseMessage = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return str;
+  }
+};
+var Signals;
+((Signals2) => {
+  function isWrappedError(error) {
+    var _a, _b;
+    const isAlreadyWrapped = error.name === "Error" && ((_a = error == null ? void 0 : error.message) == null ? void 0 : _a.startsWith("{")) && ((_b = error == null ? void 0 : error.message) == null ? void 0 : _b.endsWith("}"));
+    return isAlreadyWrapped;
+  }
+  Signals2.isWrappedError = isWrappedError;
+  function serializeError(error) {
+    if (isWrappedError(error)) {
+      const msg = tryParseMessage(error.message);
+      return JSON.stringify({
+        ...typeof msg === "object" ? msg : { message: msg },
+        properties: { ...error }
+      });
+    }
+    return JSON.stringify({
+      name: error.constructor.name,
+      message: error.message,
+      stack: _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce(error.stack, () => ( ""))),
+      properties: { ...error }
+    });
+  }
+  Signals2.serializeError = serializeError;
+  function maybeDeserializeError(error) {
+    const errorIsAlreadyDeserialized = error instanceof Error && error.name in errorClasses;
+    if (errorIsAlreadyDeserialized) {
+      return error;
+    }
+    const serializedError = error instanceof Error ? error.message : typeof error === "string" ? error : _nullishCoalesce((error == null ? void 0 : error.toString()), () => ( ""));
+    try {
+      const parsed = JSON.parse(serializedError);
+      if (parsed && parsed.name && parsed.message) {
+        const { name, message, properties = {} } = parsed;
+        const ErrorClass = errorClasses[name] || Error;
+        const errorInstance = new ErrorClass(message);
+        errorInstance.message = message;
+        errorInstance.name = name;
+        errorInstance.stack = _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce((error == null ? void 0 : error.stack), () => ( "")));
+        Object.assign(errorInstance, properties);
+        if (isWrappedError(errorInstance)) {
+          return maybeDeserializeError(errorInstance);
+        }
+        return errorInstance;
+      }
+    } catch (e2) {
+    }
+    return error;
+  }
+  Signals2.maybeDeserializeError = maybeDeserializeError;
+})(Signals || (Signals = exports.Signals = {}));
+var VMSignal = (_class = class extends Error {
+  constructor(message) {
+    super(message);_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.message = message;
+    this.message = Signals.serializeError(this);
+  }
+  /**
+   * The code that was executed by the VM up to the point of the signal
+   */
+  __init() {this.truncatedCode = ""}
+  /** The current tool call, if any */
+  
+  /**
+   * Contains all the declared and executed variables during the VM execution
+   * See file plugins/variable-extraction.ts for more details
+   */
+  __init2() {this.variables = {}}
+}, _class);
+var SnapshotSignal = class extends VMSignal {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+var VMLoopSignal = class extends VMSignal {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+var ThinkSignal = class extends VMLoopSignal {
+  constructor(reason, context) {
+    super("Think signal received: " + reason);
+    this.reason = reason;
+    this.context = context;
+    this.message = Signals.serializeError(this);
+  }
+  toString() {
+    return Signals.serializeError(this);
+  }
+};
+var CodeExecutionError = class extends Error {
+  constructor(message, code, stacktrace) {
+    super(message);
+    this.code = code;
+    this.stacktrace = stacktrace;
+    this.message = Signals.serializeError(this);
+  }
+};
+var InvalidCodeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.message = Signals.serializeError(this);
+  }
+};
+var LoopExceededError = class extends Error {
+  constructor() {
+    super("Loop exceeded error");
+    this.message = Signals.serializeError(this);
+  }
+};
+var CodeFormattingError = class extends Error {
+  constructor(message, code) {
+    super(message, {
+      cause: "Code formatting error"
+    });
+    this.code = code;
+  }
+};
+var AssignmentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+registerErrorClass("VMSignal", VMSignal);
+registerErrorClass("SnapshotSignal", SnapshotSignal);
+registerErrorClass("VMLoopSignal", VMLoopSignal);
+registerErrorClass("ThinkSignal", ThinkSignal);
+registerErrorClass("CodeExecutionError", CodeExecutionError);
+registerErrorClass("AssignmentError", AssignmentError);
+
+
+
+
+
+
+
+
+
+
+
+exports.Signals = Signals; exports.VMSignal = VMSignal; exports.SnapshotSignal = SnapshotSignal; exports.ThinkSignal = ThinkSignal; exports.CodeExecutionError = CodeExecutionError; exports.InvalidCodeError = InvalidCodeError; exports.LoopExceededError = LoopExceededError; exports.CodeFormattingError = CodeFormattingError; exports.AssignmentError = AssignmentError;