llmz 0.0.2

package/dist/chunk-RJHDQL4C.js

@@ -0,0 +1,161 @@
+import {
+  cleanStackTrace
+} from "./chunk-MSTBEKOQ.js";
+
+// src/errors.ts
+var errorClasses = {};
+function registerErrorClass(name, errorClass) {
+  errorClasses[name] = errorClass;
+}
+var tryParseMessage = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch {
+    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: cleanStackTrace(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 : (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 = cleanStackTrace((error == null ? void 0 : error.stack) ?? "");
+        Object.assign(errorInstance, properties);
+        if (isWrappedError(errorInstance)) {
+          return maybeDeserializeError(errorInstance);
+        }
+        return errorInstance;
+      }
+    } catch {
+    }
+    return error;
+  }
+  Signals2.maybeDeserializeError = maybeDeserializeError;
+})(Signals || (Signals = {}));
+var VMSignal = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = message;
+    this.message = Signals.serializeError(this);
+  }
+  /**
+   * The code that was executed by the VM up to the point of the signal
+   */
+  truncatedCode = "";
+  /** The current tool call, if any */
+  toolCall;
+  /**
+   * Contains all the declared and executed variables during the VM execution
+   * See file plugins/variable-extraction.ts for more details
+   */
+  variables = {};
+};
+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);
+
+export {
+  Signals,
+  VMSignal,
+  SnapshotSignal,
+  ThinkSignal,
+  CodeExecutionError,
+  InvalidCodeError,
+  LoopExceededError,
+  CodeFormattingError,
+  AssignmentError
+};

package/dist/chunk-UG2GCPHF.js

@@ -0,0 +1,91 @@
+import {
+  extractType,
+  inspect
+} from "./chunk-Q4DEJGXD.js";
+
+// src/snapshots.ts
+import { ulid } from "ulid";
+var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
+var Snapshot = class _Snapshot {
+  id;
+  reason;
+  stack;
+  variables;
+  toolCall;
+  #status;
+  get status() {
+    return Object.freeze({ ...this.#status });
+  }
+  constructor(props) {
+    this.id = props.id;
+    this.stack = props.stack;
+    this.reason = props.reason;
+    this.variables = props.variables;
+    this.toolCall = props.toolCall;
+    this.#status = props.status;
+  }
+  static fromSignal(signal) {
+    const variables = Object.entries(signal.variables).map(([name, value]) => {
+      const type = extractType(value);
+      const bytes = JSON.stringify(value || "").length;
+      const truncated = bytes > MAX_SNAPSHOT_SIZE_BYTES;
+      return truncated ? { name, type, bytes, truncated: true, preview: inspect(value, name) ?? "N/A" } : { name, type, bytes, truncated: false, value };
+    });
+    return new _Snapshot({
+      id: "snapshot_" + ulid(),
+      reason: signal.message,
+      stack: signal.truncatedCode,
+      variables,
+      toolCall: signal.toolCall,
+      status: { type: "pending" }
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall
+    };
+  }
+  static fromJSON(json) {
+    return new _Snapshot({
+      id: json.id,
+      reason: json.reason,
+      stack: json.stack,
+      variables: json.variables,
+      toolCall: json.toolCall,
+      status: json.status
+    });
+  }
+  clone() {
+    return new _Snapshot({
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall,
+      status: this.#status
+    });
+  }
+  reset() {
+    this.#status = { type: "pending" };
+  }
+  resolve(value) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot resolve snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "resolved", value };
+  }
+  reject(error) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot reject snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "rejected", error };
+  }
+};
+
+export {
+  Snapshot
+};

package/dist/chunk-UVSOAH2H.js

@@ -0,0 +1,152 @@
+import {
+  getTokenizer
+} from "./chunk-DFZ6GX5C.js";
+
+// src/truncator.ts
+var DEFAULT_REMOVE_CHUNK = 250;
+var WRAP_OPEN_TAG_1 = "\u3010TRUNCATE";
+var WRAP_OPEN_TAG_2 = "\u3011";
+var WRAP_CLOSE_TAG = "\u3010/TRUNCATE\u3011";
+var getRegex = () => new RegExp(`(${WRAP_OPEN_TAG_1}(?:\\s+[\\w:]+)*\\s*${WRAP_OPEN_TAG_2})([\\s\\S]*?)(${WRAP_CLOSE_TAG})`, "g");
+var DEFAULT_TRUNCATE_OPTIONS = {
+  preserve: "top",
+  flex: 1,
+  minTokens: 0
+};
+function wrapContent(content, options) {
+  const preserve = (options == null ? void 0 : options.preserve) ?? DEFAULT_TRUNCATE_OPTIONS.preserve;
+  const flex = (options == null ? void 0 : options.flex) ?? DEFAULT_TRUNCATE_OPTIONS.flex;
+  const minTokens = (options == null ? void 0 : options.minTokens) ?? DEFAULT_TRUNCATE_OPTIONS.minTokens;
+  return `${WRAP_OPEN_TAG_1} preserve:${preserve} flex:${flex} min:${minTokens} ${WRAP_OPEN_TAG_2}${content}${WRAP_CLOSE_TAG}`;
+}
+function truncateWrappedContent({
+  messages,
+  tokenLimit,
+  throwOnFailure = true
+}) {
+  var _a, _b, _c;
+  const tokenizer = getTokenizer();
+  const parts = [];
+  for (const msg of messages) {
+    const current = [];
+    const content = msg.content;
+    let match;
+    const regex = getRegex();
+    let lastIndex = 0;
+    while ((match = regex.exec(content)) !== null) {
+      const attributes = match[1].split(/\s+/).slice(1).filter((x) => x !== WRAP_OPEN_TAG_2).map((x) => x.split(":")).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+      if (match.index > lastIndex) {
+        const nonTruncatableContent = content.slice(lastIndex, match.index);
+        current.push({
+          content: nonTruncatableContent,
+          tokens: tokenizer.count(nonTruncatableContent),
+          truncatable: false
+        });
+      }
+      const wrappedContent = match[2];
+      current.push({
+        content: wrappedContent,
+        tokens: tokenizer.count(wrappedContent),
+        truncatable: true,
+        attributes: {
+          preserve: attributes.preserve,
+          flex: Number(attributes.flex) || DEFAULT_TRUNCATE_OPTIONS.flex,
+          minTokens: Number(attributes.min) || DEFAULT_TRUNCATE_OPTIONS.minTokens
+        }
+      });
+      lastIndex = regex.lastIndex;
+    }
+    if (lastIndex < content.length) {
+      const remainingContent = content.slice(lastIndex);
+      current.push({
+        content: remainingContent,
+        tokens: tokenizer.count(remainingContent),
+        truncatable: false
+      });
+    }
+    parts.push(current);
+  }
+  const getCount = () => parts.reduce((acc, x) => acc + x.reduce((acc2, y) => acc2 + y.tokens, 0), 0);
+  const getTwoBiggestTruncatables = () => {
+    var _a2, _b2;
+    let biggest = null;
+    let secondBiggest = null;
+    for (const part of parts.flat()) {
+      if (part.truncatable) {
+        const flex = ((_a2 = part.attributes) == null ? void 0 : _a2.flex) ?? DEFAULT_TRUNCATE_OPTIONS.flex;
+        const tokens = part.tokens * flex;
+        if (part.tokens <= (((_b2 = part.attributes) == null ? void 0 : _b2.minTokens) ?? 0)) {
+          continue;
+        }
+        if (!biggest || tokens > biggest.tokens) {
+          secondBiggest = biggest;
+          biggest = part;
+        } else if (!secondBiggest || tokens > secondBiggest.tokens) {
+          secondBiggest = part;
+        }
+      }
+    }
+    return { biggest, secondBiggest };
+  };
+  let currentCount = getCount();
+  while (currentCount > tokenLimit) {
+    const { biggest, secondBiggest } = getTwoBiggestTruncatables();
+    if (!biggest || !biggest.truncatable || biggest.tokens <= 0) {
+      if (throwOnFailure) {
+        throw new Error(`Cannot truncate further, current count: ${getCount()}`);
+      } else {
+        break;
+      }
+    }
+    const delta = Math.max(biggest.tokens - ((secondBiggest == null ? void 0 : secondBiggest.tokens) ?? 0), DEFAULT_REMOVE_CHUNK);
+    const room = Math.min(delta, biggest.tokens);
+    let toRemove = Math.min(room, currentCount - tokenLimit);
+    if (toRemove <= 0) {
+      if (throwOnFailure) {
+        throw new Error(`Cannot truncate further, current count: ${getCount()}`);
+      } else {
+        break;
+      }
+    }
+    if (biggest.tokens - toRemove < (((_a = biggest.attributes) == null ? void 0 : _a.minTokens) ?? 0)) {
+      toRemove = biggest.tokens - (((_b = biggest.attributes) == null ? void 0 : _b.minTokens) ?? 0);
+    }
+    const preserve = ((_c = biggest.attributes) == null ? void 0 : _c.preserve) ?? DEFAULT_TRUNCATE_OPTIONS.preserve;
+    const split = tokenizer.split(biggest.content);
+    if (preserve === "bottom") {
+      biggest.content = split.slice(toRemove).join("");
+    } else if (preserve === "top") {
+      biggest.content = split.slice(0, -toRemove).join("");
+    } else {
+      const anchor = Math.ceil(split.length / 2);
+      const radius = Math.ceil(toRemove / 2);
+      const left = anchor - radius;
+      const right = anchor + radius;
+      biggest.content = split.slice(0, left).join("") + split.slice(right).join("");
+    }
+    biggest.tokens -= toRemove;
+    currentCount -= toRemove;
+  }
+  const removeRedundantWrappers = (content) => {
+    return content.replace(getRegex(), "$2");
+  };
+  return messages.map((msg, i) => {
+    const p = parts[i];
+    return {
+      ...msg,
+      content: removeRedundantWrappers(
+        p.map((part) => {
+          if (part.truncatable) {
+            return part.content;
+          }
+          return part.content;
+        }).join("")
+      )
+    };
+  });
+}
+
+export {
+  wrapContent,
+  truncateWrappedContent
+};

package/dist/chunk-VP6WWAE2.cjs

@@ -0,0 +1,152 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkENFB45AIcjs = require('./chunk-ENFB45AI.cjs');
+
+// src/truncator.ts
+var DEFAULT_REMOVE_CHUNK = 250;
+var WRAP_OPEN_TAG_1 = "\u3010TRUNCATE";
+var WRAP_OPEN_TAG_2 = "\u3011";
+var WRAP_CLOSE_TAG = "\u3010/TRUNCATE\u3011";
+var getRegex = () => new RegExp(`(${WRAP_OPEN_TAG_1}(?:\\s+[\\w:]+)*\\s*${WRAP_OPEN_TAG_2})([\\s\\S]*?)(${WRAP_CLOSE_TAG})`, "g");
+var DEFAULT_TRUNCATE_OPTIONS = {
+  preserve: "top",
+  flex: 1,
+  minTokens: 0
+};
+function wrapContent(content, options) {
+  const preserve = _nullishCoalesce((options == null ? void 0 : options.preserve), () => ( DEFAULT_TRUNCATE_OPTIONS.preserve));
+  const flex = _nullishCoalesce((options == null ? void 0 : options.flex), () => ( DEFAULT_TRUNCATE_OPTIONS.flex));
+  const minTokens = _nullishCoalesce((options == null ? void 0 : options.minTokens), () => ( DEFAULT_TRUNCATE_OPTIONS.minTokens));
+  return `${WRAP_OPEN_TAG_1} preserve:${preserve} flex:${flex} min:${minTokens} ${WRAP_OPEN_TAG_2}${content}${WRAP_CLOSE_TAG}`;
+}
+function truncateWrappedContent({
+  messages,
+  tokenLimit,
+  throwOnFailure = true
+}) {
+  var _a, _b, _c;
+  const tokenizer = _chunkENFB45AIcjs.getTokenizer.call(void 0, );
+  const parts = [];
+  for (const msg of messages) {
+    const current = [];
+    const content = msg.content;
+    let match;
+    const regex = getRegex();
+    let lastIndex = 0;
+    while ((match = regex.exec(content)) !== null) {
+      const attributes = match[1].split(/\s+/).slice(1).filter((x) => x !== WRAP_OPEN_TAG_2).map((x) => x.split(":")).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+      if (match.index > lastIndex) {
+        const nonTruncatableContent = content.slice(lastIndex, match.index);
+        current.push({
+          content: nonTruncatableContent,
+          tokens: tokenizer.count(nonTruncatableContent),
+          truncatable: false
+        });
+      }
+      const wrappedContent = match[2];
+      current.push({
+        content: wrappedContent,
+        tokens: tokenizer.count(wrappedContent),
+        truncatable: true,
+        attributes: {
+          preserve: attributes.preserve,
+          flex: Number(attributes.flex) || DEFAULT_TRUNCATE_OPTIONS.flex,
+          minTokens: Number(attributes.min) || DEFAULT_TRUNCATE_OPTIONS.minTokens
+        }
+      });
+      lastIndex = regex.lastIndex;
+    }
+    if (lastIndex < content.length) {
+      const remainingContent = content.slice(lastIndex);
+      current.push({
+        content: remainingContent,
+        tokens: tokenizer.count(remainingContent),
+        truncatable: false
+      });
+    }
+    parts.push(current);
+  }
+  const getCount = () => parts.reduce((acc, x) => acc + x.reduce((acc2, y) => acc2 + y.tokens, 0), 0);
+  const getTwoBiggestTruncatables = () => {
+    var _a2, _b2;
+    let biggest = null;
+    let secondBiggest = null;
+    for (const part of parts.flat()) {
+      if (part.truncatable) {
+        const flex = _nullishCoalesce(((_a2 = part.attributes) == null ? void 0 : _a2.flex), () => ( DEFAULT_TRUNCATE_OPTIONS.flex));
+        const tokens = part.tokens * flex;
+        if (part.tokens <= (_nullishCoalesce(((_b2 = part.attributes) == null ? void 0 : _b2.minTokens), () => ( 0)))) {
+          continue;
+        }
+        if (!biggest || tokens > biggest.tokens) {
+          secondBiggest = biggest;
+          biggest = part;
+        } else if (!secondBiggest || tokens > secondBiggest.tokens) {
+          secondBiggest = part;
+        }
+      }
+    }
+    return { biggest, secondBiggest };
+  };
+  let currentCount = getCount();
+  while (currentCount > tokenLimit) {
+    const { biggest, secondBiggest } = getTwoBiggestTruncatables();
+    if (!biggest || !biggest.truncatable || biggest.tokens <= 0) {
+      if (throwOnFailure) {
+        throw new Error(`Cannot truncate further, current count: ${getCount()}`);
+      } else {
+        break;
+      }
+    }
+    const delta = Math.max(biggest.tokens - (_nullishCoalesce((secondBiggest == null ? void 0 : secondBiggest.tokens), () => ( 0))), DEFAULT_REMOVE_CHUNK);
+    const room = Math.min(delta, biggest.tokens);
+    let toRemove = Math.min(room, currentCount - tokenLimit);
+    if (toRemove <= 0) {
+      if (throwOnFailure) {
+        throw new Error(`Cannot truncate further, current count: ${getCount()}`);
+      } else {
+        break;
+      }
+    }
+    if (biggest.tokens - toRemove < (_nullishCoalesce(((_a = biggest.attributes) == null ? void 0 : _a.minTokens), () => ( 0)))) {
+      toRemove = biggest.tokens - (_nullishCoalesce(((_b = biggest.attributes) == null ? void 0 : _b.minTokens), () => ( 0)));
+    }
+    const preserve = _nullishCoalesce(((_c = biggest.attributes) == null ? void 0 : _c.preserve), () => ( DEFAULT_TRUNCATE_OPTIONS.preserve));
+    const split = tokenizer.split(biggest.content);
+    if (preserve === "bottom") {
+      biggest.content = split.slice(toRemove).join("");
+    } else if (preserve === "top") {
+      biggest.content = split.slice(0, -toRemove).join("");
+    } else {
+      const anchor = Math.ceil(split.length / 2);
+      const radius = Math.ceil(toRemove / 2);
+      const left = anchor - radius;
+      const right = anchor + radius;
+      biggest.content = split.slice(0, left).join("") + split.slice(right).join("");
+    }
+    biggest.tokens -= toRemove;
+    currentCount -= toRemove;
+  }
+  const removeRedundantWrappers = (content) => {
+    return content.replace(getRegex(), "$2");
+  };
+  return messages.map((msg, i) => {
+    const p = parts[i];
+    return {
+      ...msg,
+      content: removeRedundantWrappers(
+        p.map((part) => {
+          if (part.truncatable) {
+            return part.content;
+          }
+          return part.content;
+        }).join("")
+      )
+    };
+  });
+}
+
+
+
+
+exports.wrapContent = wrapContent; exports.truncateWrappedContent = truncateWrappedContent;