llmz 0.0.11 → 0.0.13

package/dist/chunk-JGVAZO4X.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 _chunk276Q6EWPcjs = require('./chunk-276Q6EWP.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 = _chunk276Q6EWPcjs.getTokenizer.call(void 0, );
+  const parts = [];
+  for (const msg of messages) {
+    const current = [];
+    const content = typeof msg.content === "string" ? 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: typeof msg.content === "string" ? removeRedundantWrappers(
+        p.map((part) => {
+          if (part.truncatable) {
+            return part.content;
+          }
+          return part.content;
+        }).join("")
+      ) : msg.content
+    };
+  });
+}
+
+
+
+
+exports.wrapContent = wrapContent; exports.truncateWrappedContent = truncateWrappedContent;

package/dist/chunk-JKVVQN2P.js

@@ -0,0 +1,161 @@
+import {
+  cleanStackTrace
+} from "./chunk-JQBT7UWN.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-JMSZKB4T.js

@@ -0,0 +1,105 @@
+import {
+  isJsonSchema,
+  isValidIdentifier,
+  isZuiSchema
+} from "./chunk-4MNIJGK6.js";
+import {
+  uniq_default
+} from "./chunk-7WRN4E42.js";
+
+// src/exit.ts
+import { transforms } from "@bpinternal/zui";
+var Exit = class _Exit {
+  name;
+  aliases = [];
+  description;
+  metadata;
+  schema;
+  get zSchema() {
+    return this.schema ? transforms.fromJSONSchemaLegacy(this.schema) : void 0;
+  }
+  rename(name) {
+    const before = this.name;
+    if (!isValidIdentifier(name)) {
+      throw new Error(
+        `Invalid name for exit ${name}. An exit 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() {
+    return new _Exit({
+      name: this.name,
+      aliases: [...this.aliases],
+      description: this.description,
+      metadata: JSON.parse(JSON.stringify(this.metadata)),
+      schema: this.zSchema
+    });
+  }
+  is(exit) {
+    return this.name === exit.name;
+  }
+  match(result) {
+    return result.exit instanceof _Exit && this.name === result.exit.name;
+  }
+  constructor(props) {
+    if (!isValidIdentifier(props.name)) {
+      throw new Error(
+        `Invalid name for exit ${props.name}. A exit name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`
+      );
+    }
+    if (typeof props.description !== "string" || props.description.trim().length === 0) {
+      throw new Error(
+        `Invalid description for exit ${props.name}. Expected a non-empty string, but got type "${typeof props.description}"`
+      );
+    }
+    if (props.metadata !== void 0 && typeof props.metadata !== "object") {
+      throw new Error(
+        `Invalid metadata for exit ${props.name}. Expected an object, but got type "${typeof props.metadata}"`
+      );
+    }
+    if (props.aliases !== void 0 && !Array.isArray(props.aliases)) {
+      throw new Error(
+        `Invalid aliases for exit ${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 exit ${props.name}. Expected an array of valid identifiers.`);
+    }
+    if (typeof props.schema !== "undefined") {
+      if (isZuiSchema(props.schema)) {
+        this.schema = transforms.toJSONSchemaLegacy(props.schema);
+      } else if (isJsonSchema(props.schema)) {
+        this.schema = props.schema;
+      } else {
+        throw new Error(
+          `Invalid input schema for exit ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.schema}"`
+        );
+      }
+    }
+    this.name = props.name;
+    this.aliases = uniq_default([props.name, ...props.aliases ?? []]);
+    this.description = props.description;
+    this.metadata = props.metadata ?? {};
+  }
+  static withUniqueNames = (exits) => {
+    const names = /* @__PURE__ */ new Set();
+    return exits.map((exit) => {
+      if (exits.filter((t) => t.name === exit.name).length === 1) {
+        return exit;
+      }
+      let counter = 1;
+      let exitName = exit.name + counter;
+      while (names.has(exitName)) {
+        exitName = `${exit.name}${++counter}`;
+      }
+      return exit.rename(exitName);
+    });
+  };
+};
+
+export {
+  Exit
+};

package/dist/chunk-JQBT7UWN.js

@@ -0,0 +1,28 @@
+// 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");
+}
+
+export {
+  cleanStackTrace
+};