@isdk/ai-tool 0.0.2

package/dist/funcs.js

@@ -0,0 +1,5016 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/funcs/index.ts
+var funcs_exports = {};
+__export(funcs_exports, {
+  EventClient: () => EventClient,
+  EventServer: () => EventServer,
+  EventToolFunc: () => EventToolFunc,
+  _lrucache: () => _lrucache,
+  createLRUCache: () => createLRUCache,
+  event: () => event,
+  eventClient: () => eventClient,
+  eventServer: () => eventServer,
+  getDefaultSimilarPassingScore: () => getDefaultSimilarPassingScore,
+  isSimilar: () => isSimilar,
+  lrucache: () => lrucache,
+  mergeSegments: () => mergeSegments,
+  registerCoreTools: () => registerCoreTools,
+  segments: () => segments,
+  similarity: () => similarity,
+  splitSegments: () => splitSegments
+});
+module.exports = __toCommonJS(funcs_exports);
+
+// src/funcs/event.ts
+var import_events_ex = require("events-ex");
+
+// src/tool-func.ts
+var import_property_manager = require("property-manager");
+var import_util_ex = require("util-ex");
+
+// src/utils/base-error.ts
+var import_abstract_error = require("abstract-error");
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["OK"] = 200] = "OK";
+  ErrorCode2[ErrorCode2["BadRequest"] = 400] = "BadRequest";
+  ErrorCode2[ErrorCode2["InvalidArgument"] = 400] = "InvalidArgument";
+  ErrorCode2[ErrorCode2["Unauthorized"] = 401] = "Unauthorized";
+  ErrorCode2[ErrorCode2["PaymentRequired"] = 402] = "PaymentRequired";
+  ErrorCode2[ErrorCode2["Forbidden"] = 403] = "Forbidden";
+  ErrorCode2[ErrorCode2["NotFound"] = 404] = "NotFound";
+  ErrorCode2[ErrorCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  ErrorCode2[ErrorCode2["NotAcceptable"] = 406] = "NotAcceptable";
+  ErrorCode2[ErrorCode2["RequestTimeout"] = 408] = "RequestTimeout";
+  ErrorCode2[ErrorCode2["Conflict"] = 409] = "Conflict";
+  ErrorCode2[ErrorCode2["Corruption"] = 409] = "Corruption";
+  ErrorCode2[ErrorCode2["Aborted"] = 499] = "Aborted";
+  ErrorCode2[ErrorCode2["InternalError"] = 500] = "InternalError";
+  ErrorCode2[ErrorCode2["NotImplemented"] = 501] = "NotImplemented";
+  ErrorCode2[ErrorCode2["NotSupported"] = 501] = "NotSupported";
+  ErrorCode2[ErrorCode2["BadGateway"] = 502] = "BadGateway";
+  ErrorCode2[ErrorCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  ErrorCode2[ErrorCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  return ErrorCode2;
+})(ErrorCode || {});
+var InternalErrorCode = 500 /* InternalError */;
+var NotImplementedErrorCode = 501 /* NotImplemented */;
+var NotFoundErrorCode = 404 /* NotFound */;
+var AlreadyExistsErrorCode = 409 /* Conflict */;
+var AbortErrorCode = 499 /* Aborted */;
+var BaseError = class _BaseError extends import_abstract_error.AbstractError {
+  static createErrorClass(aType, aErrorCode, ParentErrorClass = _BaseError) {
+    return (0, import_abstract_error.createErrorClass)(aType, aErrorCode, ParentErrorClass);
+  }
+  /**
+   * Constructs a new BaseError instance.
+   *
+   * @param {string} message - The error message.
+   * @param {ErrorCodeType} [code] - The error code.
+   * @param {string|object} [name] - The error name or additional properties.
+   */
+  constructor(message, code, name) {
+    super(message, code);
+    const ctor = this.constructor;
+    if (code != null) {
+      this.code = code;
+    } else if (ctor.code) {
+      this.code = ctor.code;
+    } else {
+      this.code = ctor.name;
+    }
+    if (name) {
+      if (typeof name === "string") {
+        this.name = name;
+      } else {
+        Object.assign(this, name);
+      }
+    } else if (typeof this.code === "string") {
+      this.name = this.code;
+    } else {
+      this.name = ctor.name;
+    }
+  }
+  /**
+   * Returns a JSON representation of the error.
+   *
+   * @returns {object} A JSON representation of the error.
+   */
+  toJSON() {
+    const result = {
+      name: this.name,
+      code: this.code,
+      data: this.data,
+      caller: this.caller,
+      error: this.message,
+      stack: this.stack
+    };
+    Object.keys(result).forEach((key) => result[key] === void 0 && delete result[key]);
+    return result;
+  }
+  /**
+   * Creates a new BaseError instance from a JSON representation.
+   *
+   * @param {object} json - A JSON representation of the error.
+   * @returns {BaseError} A new BaseError instance.
+   */
+  fromJSON(json) {
+    const e = new _BaseError(json.message);
+    e.code = json.code;
+    e.data = json.data;
+    e.caller = json.caller;
+    e.message = json.error;
+    e.stack = json.stack;
+    return e;
+  }
+};
+var CommonError = class extends BaseError {
+  constructor(message, name, status = InternalErrorCode) {
+    super(message, status, name);
+  }
+};
+var NotImplementationError = class extends CommonError {
+  constructor(msg, name) {
+    if (!msg) {
+      msg = `Not Implementation.`;
+    }
+    super(msg, name, 501 /* NotImplemented */);
+  }
+};
+CommonError[NotImplementedErrorCode] = NotImplementationError;
+var NotFoundError = class extends CommonError {
+  static {
+    this.code = NotFoundErrorCode;
+  }
+  constructor(what, name) {
+    super(`Could not find ${what}.`, name, NotFoundErrorCode);
+    this.data = { what };
+  }
+};
+CommonError[NotFoundErrorCode] = NotFoundError;
+var AlreadyExistsError = class extends CommonError {
+  static {
+    this.code = AlreadyExistsErrorCode;
+  }
+  constructor(what, name) {
+    super(`The ${what} already exists.`, name, AlreadyExistsErrorCode);
+    this.data = { what };
+  }
+};
+CommonError[AlreadyExistsErrorCode] = AlreadyExistsError;
+var AbortError = class extends CommonError {
+  static {
+    this.code = AbortErrorCode;
+  }
+  constructor(what, name) {
+    const message = what ? `The operation was aborted for ${what}.` : `The operation was aborted.`;
+    super(message, name, AbortErrorCode);
+    if (what) {
+      this.data = { what };
+    }
+  }
+};
+CommonError[AbortErrorCode] = AbortError;
+function createError(message, name, status = InternalErrorCode) {
+  const ErrorClass = CommonError[status] || CommonError;
+  const error = new ErrorClass(message, name, status);
+  if (typeof error.code !== "number")
+    error.code = status;
+  return error;
+}
+function throwError2(message, name, status = InternalErrorCode) {
+  const error = createError(message, name, status);
+  throw error;
+}
+
+// src/tool-func.ts
+var ToolFunc = class _ToolFunc extends import_property_manager.AdvancePropertyManager {
+  static {
+    this.items = {};
+  }
+  static get(name) {
+    return this.items[name];
+  }
+  static list() {
+    return this.items;
+  }
+  static getByTag(tagName) {
+    let result;
+    for (const name in this.list()) {
+      const item = this.get(name);
+      let tags = item.tags;
+      if (typeof tags === "string") {
+        if (tags === tagName) {
+          result = item;
+          break;
+        }
+      } else if (Array.isArray(tags)) {
+        if (tags.indexOf(tagName) >= 0) {
+          result = item;
+          break;
+        }
+      }
+    }
+    return result;
+  }
+  static getAllByTag(tagName) {
+    let result = [];
+    for (const name in this.list()) {
+      const item = this.get(name);
+      let tags = item.tags;
+      if (typeof tags === "string") {
+        if (tags === tagName) {
+          result.push(item);
+        }
+      } else if (Array.isArray(tags)) {
+        if (tags.indexOf(tagName) >= 0) {
+          result.push(item);
+        }
+      }
+    }
+    return result;
+  }
+  static async run(name, params) {
+    const func = this.get(name);
+    if (func) {
+      return await func.run(params);
+    }
+    throw new NotFoundError(`${name} to run`, this.name);
+  }
+  static runSync(name, params) {
+    const func = this.get(name);
+    if (func) {
+      return func.runSync(params);
+    }
+    throw new NotFoundError(`${name} to run`, this.name);
+  }
+  static getFunc(name) {
+    const func = this.get(name);
+    return func?.getFunc();
+  }
+  static async runWithPos(name, ...params) {
+    const func = this.get(name);
+    if (func) {
+      return await func.runWithPos(...params);
+    }
+    throw new NotFoundError(`${name} to run`, this.name);
+  }
+  static runWithPosSync(name, ...params) {
+    const func = this.get(name);
+    if (func) {
+      return func.runWithPosSync(...params);
+    }
+    throw new NotFoundError(`${name} to run`, this.name);
+  }
+  static getFuncWithPos(name) {
+    const func = this.get(name);
+    return func?.getFuncWithPos();
+  }
+  static register(name, options = {}) {
+    switch (typeof name) {
+      case "string":
+        options.name = name;
+        break;
+      case "function":
+        options.func = name;
+        break;
+      case "object":
+        options = name;
+        break;
+    }
+    name = options.name;
+    let result = !!this.get(name);
+    if (!result) {
+      if (!(options instanceof _ToolFunc)) {
+        result = new this(options);
+        return result.register();
+      }
+      this.items[name] = options;
+      result = options;
+    } else {
+      result = false;
+    }
+    return result;
+  }
+  static unregister(name) {
+    const result = this.items[name];
+    if (result) {
+      delete this.items[name];
+    }
+    return result;
+  }
+  constructor(name, options = {}) {
+    super();
+    switch (typeof name) {
+      case "string":
+        options.name = name;
+        break;
+      case "function":
+        options.func = name;
+        break;
+      case "object":
+        options = name;
+        break;
+    }
+    this.name = name = options.name;
+    if (options.scope) {
+      this.scope = options.scope;
+    }
+    if (typeof options.setup === "function") {
+      options.setup.call(this, options);
+    }
+    this.initialize(options);
+  }
+  register() {
+    const Tools = this.constructor;
+    const depends = this.depends;
+    if (depends) {
+      const keys = Object.keys(depends);
+      for (const k of keys) {
+        const dep = depends[k];
+        if (dep instanceof _ToolFunc) {
+          dep.register();
+        }
+      }
+    }
+    return Tools.register(this);
+  }
+  unregister() {
+    return this.constructor.unregister(this.name);
+  }
+  arr2ObjParams(params) {
+    if (this.params && (params.length > 1 || Array.isArray(params[0]) || params[0] && typeof params[0] !== "object")) {
+      const _p = {};
+      const keys = Object.keys(this.params);
+      let len = Math.min(keys.length, params.length);
+      for (let i = 0; i < len; i++) {
+        _p[keys[i]] = params[i];
+      }
+      params = [_p];
+    }
+    return params;
+  }
+  obj2ArrParams(params) {
+    const result = [];
+    if (params && this.params && Array.isArray(this.params)) {
+      const keys = Object.keys(params);
+      let len = Math.min(keys.length, this.params.length);
+      for (let i = 0; i < len; i++) {
+        result.push(params[keys[i]]);
+      }
+    }
+    return result;
+  }
+  runSync(params) {
+    const isPosParams = this.params && Array.isArray(this.params);
+    if (Array.isArray(params)) {
+      if (isPosParams)
+        return this.func(...params);
+      throwError2("the function is not support array params, the params must be object!", this.name);
+    }
+    if (isPosParams) {
+      params = this.obj2ArrParams(params);
+      console.warn('Warning:Use runWithPos() instead of run() for the "' + this.name + '" is function with position params');
+      return this.func(...params);
+    }
+    return this.func(params);
+  }
+  async run(params) {
+    return await this.runSync(params);
+  }
+  async runAs(name, params) {
+    const result = await this.constructor.run(name, params);
+    return result;
+  }
+  runAsSync(name, params) {
+    const result = this.constructor.runSync(name, params);
+    return result;
+  }
+  getFunc(name) {
+    const result = name ? this.constructor.getFunc(name) : this.runSync.bind(this);
+    return result;
+  }
+  runWithPosSync(...params) {
+    if (this.params && !Array.isArray(this.params)) {
+      params = this.arr2ObjParams(params);
+    }
+    return this.func(...params);
+  }
+  runWithPosAsSync(name, ...params) {
+    return this.constructor.runWithPosSync(name, ...params);
+  }
+  async runWithPos(...params) {
+    const result = await this.runWithPosSync(...params);
+    return result;
+  }
+  async runWithPosAs(name, ...params) {
+    const result = await this.constructor.runWithPos(name, ...params);
+    return result;
+  }
+  getFuncWithPos(name) {
+    const result = name ? this.constructor.getFuncWithPos(name) : this.runWithPosSync.bind(this);
+    return result;
+  }
+};
+var ToolFuncSchema = {
+  name: { type: "string" },
+  description: { type: "string" },
+  func: {
+    type: "function",
+    assign(value, dest, src, name, options) {
+      let result = value;
+      const valueType = typeof value;
+      const isExported = options.isExported;
+      if (isExported) {
+        result = valueType === "function" ? value.toString() : value;
+      } else if (value) {
+        if (valueType !== "string") {
+          value = value.toString();
+        }
+        result = (0, import_util_ex._createFunction)(value, dest.scope);
+      }
+      return result;
+    }
+  },
+  params: { type: "object" },
+  result: { type: "any" },
+  setup: { type: "function" },
+  depends: { type: "object", exported: false },
+  tags: { type: ["array", "string"] }
+};
+ToolFunc.defineProperties(ToolFunc, ToolFuncSchema);
+
+// src/utils/event/event-ability.ts
+var import_custom_ability = require("custom-ability");
+var EventName = "event";
+var EventBusName = "event-bus";
+function getEventableClass(Backend) {
+  class BackendEventable {
+    static get emitter() {
+      if (!this._emitter) {
+        const emitter = this.get(EventBusName)?.emitter;
+        if (emitter) {
+          this._emitter = emitter;
+          this.prototype._events = emitter._events;
+        }
+      }
+      return this._emitter;
+    }
+    get emitter() {
+      const ctor = this.constructor;
+      return ctor._emitter;
+    }
+    on(eventName, listener) {
+      const emitter = Backend.emitter;
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      return emitter.on(eventName, listener);
+    }
+    once(eventName, listener) {
+      const emitter = Backend.emitter;
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      return emitter.once(eventName, listener);
+    }
+    off(type, listener) {
+      const emitter = Backend.emitter;
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      return emitter.off(type, listener);
+    }
+    emit(eventName, ...args) {
+      const emitter = Backend.emitter;
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      if (eventName === "error") {
+        return this.emitError.apply(this, args);
+      }
+      return emitter.emit.call(this, eventName, this.name, ...args);
+    }
+    emitError(err, ...args) {
+      const emitter = Backend.emitter;
+      const eventName = "error";
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      return emitter.emit.call(this, eventName, err, this.name, ...args);
+    }
+    async emitAsync(eventName, ...args) {
+      const emitter = Backend.emitter;
+      if (!emitter) {
+        throw new TypeError("EventBackend required");
+      }
+      return emitter.emitAsync.call(this, eventName, this.name, ...args);
+    }
+  }
+  return BackendEventable;
+}
+var backendEventable = (0, import_custom_ability.createAbilityInjector)(getEventableClass, true);
+
+// src/utils/event/sse-channel.ts
+function hasEventMatch(subscriptionList, eventName) {
+  return !subscriptionList || subscriptionList.some((pat) => pat instanceof RegExp ? pat.test(eventName) : pat === eventName);
+}
+var SSEChannelAlreadyClosedErrCode = 498;
+var SSEChannel = class {
+  get active() {
+    return this._active;
+  }
+  set active(v) {
+    if (v !== this._active) {
+      if (v) {
+        if (this.pingTimer) {
+          clearInterval(this.pingTimer);
+          this.pingTimer = void 0;
+        }
+        if (this.options.pingInterval > 0) {
+          this.pingTimer = setInterval(() => this.publish(), this.options.pingInterval);
+        }
+      } else {
+        if (this.clients.size) {
+          this.clearClients();
+        }
+        if (this.pingTimer) {
+          clearInterval(this.pingTimer);
+          this.pingTimer = void 0;
+        }
+      }
+      this._active = v;
+    }
+  }
+  /**
+   * Creates a new SSE channel.
+   * @param options - The options for the SSE channel.
+   */
+  constructor(options) {
+    this.options = Object.assign(
+      {},
+      {
+        pingInterval: 3e3,
+        maxStreamDuration: 3e4,
+        clientRetryInterval: 1e3,
+        startId: 1,
+        historySize: 100,
+        rewind: 0,
+        cors: false
+      },
+      options
+    );
+    this.nextID = this.options.startId;
+    this.clients = /* @__PURE__ */ new Set();
+    this.messages = [];
+    this.active = true;
+  }
+  /**
+   * Publishes a message to the SSE channel.
+   * @param {string | Record<string, any>} data - The data to send. It can be a string or an object.
+   * @param {string} eventName - The name of the event.
+   * @returns {number | undefined} - Returns the ID of the message.
+   * @throws Will throw an error if the channel is closed.
+   */
+  publish(data, eventName) {
+    if (!this.active)
+      throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
+    let output;
+    let id;
+    let _eventName = eventName;
+    if (!data && !eventName) {
+      if (!this.clients.size)
+        return;
+      output = "data: \n\n";
+    } else {
+      id = this.nextID++;
+      if (typeof data === "object") {
+        if (data.event) {
+          _eventName = data.event;
+          if (data.data !== void 0)
+            data = JSON.stringify(data.data);
+        } else {
+          data = JSON.stringify(data);
+        }
+      }
+      data = data ? data.split(/[\r\n]+/).map((str) => "data: " + str).join("\n") : "";
+      output = "id: " + id + "\n" + (eventName ? "event: " + eventName + "\n" : "") + (data || "data: ") + "\n\n";
+      this.messages.push({ id, _eventName, output });
+    }
+    ;
+    [...this.clients].filter((c) => !_eventName || hasEventMatch(c.events, _eventName)).forEach((c, i) => {
+      c.res.write(output);
+    });
+    while (this.messages.length > this.options.historySize) {
+      this.messages.shift();
+    }
+    return id;
+  }
+  /**
+   * Subscribes a client to the SSE channel.
+   * @param {IncomingMessage} req - The request object.
+   * @param {ServerResponse} res - The response object.
+   * @param {Events} events - The events to subscribe to.
+   * @returns {Client} - Returns the client object.
+   * @throws Will throw an error if the channel is closed.
+   */
+  subscribe(req, res, events) {
+    if (!this.active)
+      throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
+    const c = { req, res, events };
+    const maxStreamDuration = this.options.maxStreamDuration;
+    let cacheControl = "max-age=0, stale-while-revalidate=0, stale-if-error=0, no-transform";
+    if (maxStreamDuration > 0) {
+      cacheControl += ", s-maxage=" + (Math.floor(maxStreamDuration / 1e3) - 1);
+    }
+    const headers = {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": cacheControl,
+      "Connection": "keep-alive"
+    };
+    if (this.options.cors) {
+      headers["access-control-allow-origin"] = "*";
+    }
+    c.req.socket.setNoDelay(true);
+    c.res.writeHead(200, headers);
+    let body = "retry: " + this.options.clientRetryInterval + "\n\n";
+    const lastID = Number.parseInt(req.headers["last-event-id"], 10);
+    const rewind = !Number.isNaN(lastID) ? this.nextID - 1 - lastID : this.options.rewind;
+    if (rewind) {
+      this.messages.filter((m) => hasEventMatch(c.events, m.eventName)).slice(0 - rewind).forEach((m) => {
+        body += m.output;
+      });
+    }
+    c.res.write(body);
+    this.clients.add(c);
+    if (maxStreamDuration > 0) {
+      setTimeout(() => {
+        if (!c.res.writableEnded) {
+          this.unsubscribe(c);
+        }
+      }, maxStreamDuration);
+    }
+    c.res.on("close", () => this.unsubscribe(c));
+    return c;
+  }
+  /**
+   * Unsubscribes a client from the SSE channel.
+   * @param {Client} c - The client to unsubscribe.
+   */
+  unsubscribe(c) {
+    c.res.end();
+    this.clients.delete(c);
+  }
+  clearClients() {
+    this.clients.forEach((c) => c.res.end());
+    this.clients.clear();
+  }
+  /**
+   * Lists the clients connected to the SSE channel grouped by IP address.
+   * @returns - Returns an object where the keys are the IP addresses and the values are the number of clients connected from each IP.
+   */
+  listClients() {
+    const rollupByIP = {};
+    this.clients.forEach((c) => {
+      const ip = c.req.socket.remoteAddress ?? "";
+      if (!(ip in rollupByIP)) {
+        rollupByIP[ip] = 0;
+      }
+      rollupByIP[ip]++;
+    });
+    return rollupByIP;
+  }
+  /**
+   * Gets the number of clients subscribed to the SSE channel.
+   * @returns - Returns the number of clients.
+   */
+  getSubscriberCount() {
+    return this.clients.size;
+  }
+};
+
+// src/funcs/event.ts
+var EventToolFunc = class extends ToolFunc {
+  constructor() {
+    super(...arguments);
+    // static _emitter = wrapEventEmitter()
+    this._emitter = new import_events_ex.EventEmitter();
+    // wrapEventEmitter()
+    this.description = "Return event bus";
+    this.result = "event";
+  }
+  get emitter() {
+    return this._emitter;
+  }
+  func() {
+    return this.emitter;
+  }
+};
+var event = new EventToolFunc(EventBusName);
+
+// src/utils/consts.ts
+var PASSING_SCORE = 0.618;
+var ActionNames = ["get", "post", "put", "delete", "patch", "list", "res"];
+var RemoteToolFuncSchema = {
+  apiRoot: {
+    type: "string",
+    get() {
+      return this._apiRoot ?? this.constructor.apiRoot;
+    },
+    set(value) {
+      this._apiRoot = value;
+    }
+  },
+  action: {
+    type: "string",
+    assign(value, dest, src, name, options) {
+      return value || "post";
+    }
+  },
+  fetchOptions: { type: "object" },
+  allowExportFunc: { type: "boolean" },
+  stream: { type: "boolean" }
+};
+
+// src/server-tools.ts
+var ServerTools = class _ServerTools extends ToolFunc {
+  static get apiRoot() {
+    return _ServerTools._apiRoot;
+  }
+  static setApiRoot(v) {
+    _ServerTools._apiRoot = v;
+  }
+  // static get(name: string) {
+  //   return this.items[name] ?? ToolFunc.get(name)
+  // }
+  // static list() {
+  //   return {...ToolFunc.list(), ...this.items}
+  // }
+  // static items = ServerToolItems;
+  static toJSON() {
+    const result = {};
+    for (const name in this.items) {
+      let item = this.items[name];
+      if (item instanceof _ServerTools) {
+        if (!item.allowExportFunc) {
+          item = item.toJSON();
+          delete item.func;
+        }
+        result[name] = item;
+      }
+    }
+    return result;
+  }
+  isStream(params) {
+    return this.stream;
+  }
+  func({}) {
+  }
+};
+var ServerToolFuncSchema = { ...RemoteToolFuncSchema };
+ServerTools.defineProperties(ServerTools, ServerToolFuncSchema);
+
+// src/funcs/similarity.ts
+var import_transformers = require("@xenova/transformers");
+
+// src/funcs/lrucache.ts
+var import_secondary_cache = require("secondary-cache");
+function _lrucache({ key, value, options } = {}) {
+  if (key === void 0) {
+    if (options)
+      this.cache.setDefaultOptions(options);
+  } else if (value === null) {
+    return this.cache.del(key);
+  } else if (value !== void 0) {
+    return this.cache.set(key, value, options);
+  } else {
+    return this.cache.get(key);
+  }
+  return this.cache;
+}
+function createLRUCache(name, options) {
+  let result = ToolFunc.get(name);
+  if (!result) {
+    result = new ToolFunc(name, {
+      func: _lrucache,
+      description: "get/set LRU cache or return the LRUCache object",
+      params: {
+        key: { name: "key", type: "string", description: "the key is undefined means change the default cache options" },
+        value: { name: "value", type: "any", description: "the value to store, if value is null means remove the key" },
+        options: { name: "options", type: "object|number", description: "the optional cache options:{capacity,expires,cleanInterval} or expires" }
+      },
+      result: "any"
+    });
+    result.cache = new import_secondary_cache.Cache(options);
+  }
+  return result;
+}
+var lrucache = createLRUCache("lrucache");
+
+// src/funcs/similarity.ts
+var ModelsCache = createLRUCache("ModelsCache", { capacity: 2, expires: 6 * 60 * 1e3 });
+var cache = ModelsCache.runWithPosSync();
+function average(arr) {
+  if (arr.length === 0) {
+    throw new NotFoundError("Array must not be empty");
+  }
+  const sum = arr.reduce((a, b) => a + b, 0);
+  return sum / arr.length;
+}
+async function _similarity({ query, texts, model } = {}) {
+  if (!model) {
+    model = this.modelId;
+  }
+  let extractor = cache.get(model);
+  if (!extractor) {
+    extractor = await pipeline("feature-extraction", model);
+    cache.set(model, extractor);
+  }
+  if (texts && query) {
+    if (!Array.isArray(texts)) {
+      texts = [texts];
+    }
+    const embeddings = await extractor(texts, { pooling: "cls", normalize: true });
+    const query_embeddings = await extractor(query, { pooling: "cls", normalize: true });
+    const scores = embeddings.tolist().map(
+      (embedding, i) => cos_sim(query_embeddings.data, embedding)
+    );
+    const result = average(scores);
+    return result;
+  }
+}
+var similarity = new ServerTools("similarity", {
+  func: _similarity,
+  description: "Calculate the similarity between the query and the texts.",
+  params: {
+    query: { name: "query", type: "string", required: true },
+    texts: { name: "texts", type: ["string", "array"], required: true },
+    model: { name: "model", type: "string", description: "the embedding model name used" }
+    // {name: 'maxExtractors', type: 'number', description: 'the max cached embedding model count'},
+  },
+  result: "number",
+  scope: { env: import_transformers.env, pipeline: import_transformers.pipeline, cos_sim: import_transformers.cos_sim, average, cache },
+  depends: { ModelsCache },
+  setup() {
+    this.modelId = "Xenova/distiluse-base-multilingual-cased-v2";
+  }
+});
+
+// src/utils/trunc-to.ts
+function truncTo2(n, dec = 2, up = 0.5) {
+  const d = 10 ** dec;
+  return Math.trunc((n + Number.EPSILON + up / d) * d) / d;
+}
+
+// src/funcs/is-similar.ts
+function getDefaultSimilarPassingScore(modelId) {
+  const i = modelId.lastIndexOf("/");
+  let result = 0.618;
+  if (i > 0) {
+    modelId = modelId.substring(i + 1);
+  }
+  if (modelId.startsWith("stella-")) {
+    result = 0.818;
+  } else if (modelId.startsWith("Dmeta-")) {
+    result = 0.65;
+  }
+  return result;
+}
+async function _isSimilar({ query, texts, model, passingScore } = {}) {
+  if (passingScore == null && model) {
+    passingScore = this.getDefaultPassingScore(model);
+  }
+  const similarity2 = this.depends.similarity.getFuncWithPos();
+  const average_score = truncTo(await similarity2(query, texts, model || this.modelId));
+  if (passingScore == null) {
+    passingScore = this.passingScore;
+  }
+  return average_score >= passingScore;
+}
+var isSimilar = new ServerTools("isSimilar", {
+  func: _isSimilar,
+  description: "merge Segments in same topics simply",
+  params: {
+    query: { name: "query", type: "string", required: true },
+    texts: { name: "texts", type: ["string", "array"], required: true },
+    model: { name: "model", type: "string", description: "the embedding model name used" },
+    passingScore: { name: "passingScore", type: "number", description: "the min passing score" }
+  },
+  result: "boolean",
+  scope: { truncTo: truncTo2 },
+  depends: { similarity },
+  setup() {
+    this.getDefaultPassingScore = getDefaultSimilarPassingScore;
+    Object.defineProperty(this, "modelId", {
+      get() {
+        return this._modelId;
+      },
+      set(value) {
+        if (value != this.modelId) {
+          this._modelId = value;
+          this.passingScore = this.getDefaultPassingScore(value);
+        }
+      }
+    });
+    this.modelId = "Xenova/distiluse-base-multilingual-cased-v2";
+  }
+});
+
+// src/funcs/merge-segments.ts
+async function _mergeSegments({ segments: segments2, model } = {}) {
+  if (!model) {
+    model = this.modelId;
+  }
+  if (!segments2 || segments2.length === 0) {
+    return [];
+  }
+  const isSimilar2 = this.depends.isSimilar.getFuncWithPos();
+  let i = 0;
+  const result = [];
+  while (i < segments2.length) {
+    const item = segments2[i++];
+    if (item.length === 1 && i < segments2.length) {
+      const query = item[0];
+      const segment = segments2[i++];
+      if (await isSimilar2(query, segment, model)) {
+        segment.unshift(query);
+        result.push(segment);
+      } else {
+        result.push(item);
+        result.push(segment);
+      }
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+var mergeSegments = new ServerTools("mergeSegments", {
+  func: _mergeSegments,
+  description: "merge Segments in same topics simply",
+  params: {
+    segments: { name: "segments", type: "array", required: true, description: "the segments to merge" },
+    model: { name: "model", type: "string", description: "the embedding model name used" }
+  },
+  result: "array",
+  depends: { isSimilar },
+  setup() {
+    this.modelId = "Xenova/distiluse-base-multilingual-cased-v2";
+  }
+});
+
+// src/utils/split-sentence.ts
+var SEPARATOR = "@";
+var RE_SENTENCE = /(\S.+?[.!?])(?=\s+|$)|(\S.+?)(?=[\n]|$)/g;
+var AB_SENIOR = /([A-Z][a-z]{1,2}\.)\s(\w)/g;
+var AB_ACRONYM = /(\.[a-zA-Z]\.)\s(\w)/g;
+var UNDO_AB_SENIOR = new RegExp("([A-Z][a-z]{1,2}\\.)" + SEPARATOR + "(\\w)", "g");
+var UNDO_AB_ACRONYM = new RegExp("(\\.[a-zA-Z]\\.)" + SEPARATOR + "(\\w)", "g");
+function replaceWithSeparator(text, separator, regexs) {
+  const replacement = "$1" + separator + "$2";
+  let result = text;
+  for (let i = 0; i < regexs.length; i++) {
+    result = result.replace(regexs[i], replacement);
+  }
+  return result;
+}
+function splitSentence2(text, best = true) {
+  text = text.replace(/([。！？?])([^”’])/g, "$1\n$2");
+  text = text.replace(/(\.{6})([^”’])/g, "$1\n$2");
+  text = text.replace(/(…{2})([^”’])/g, "$1\n$2");
+  text = text.replace(/([。！？?][”’])([^，。！？?])/g, "$1\n$2");
+  const chunks = text.split("\n");
+  let result = [];
+  for (let i = 0; i < chunks.length; i++) {
+    let chunk = chunks[i].trim();
+    if (!chunk) {
+      continue;
+    }
+    if (!best) {
+      result.push(chunk);
+      continue;
+    }
+    let processed = replaceWithSeparator(chunk, SEPARATOR, [AB_SENIOR, AB_ACRONYM]);
+    let sents = Array.from(processed.matchAll(RE_SENTENCE));
+    if (!sents.length) {
+      result.push(chunk);
+      continue;
+    }
+    for (let j = 0; j < sents.length; j++) {
+      let sentence = replaceWithSeparator(sents[j][0], " ", [UNDO_AB_SENIOR, UNDO_AB_ACRONYM]);
+      result.push(sentence);
+    }
+  }
+  return result;
+}
+
+// src/funcs/split-segments.ts
+async function _splitSegments({ texts, model } = {}) {
+  if (typeof texts === "string") {
+    texts = splitSentence(texts);
+  } else if (!Array.isArray(texts)) {
+    throwError("the texts parameter should be a string or string[]", "segments");
+  }
+  if (!model) {
+    model = this.modelId;
+  }
+  const isSimilar2 = this.depends.isSimilar.getFuncWithPos();
+  const segment = [];
+  const segments2 = [];
+  let i = 0;
+  while (i < texts.length) {
+    segment.push(texts[i++]);
+    if (i >= texts.length) {
+      break;
+    }
+    const query = texts[i];
+    if (query) {
+      if (!await isSimilar2(query, segment, model || this.modelId)) {
+        segments2.push([...segment]);
+        segment.length = 0;
+      }
+    }
+  }
+  if (segment.length)
+    segments2.push([...segment]);
+  return segments2;
+}
+var splitSegments = new ServerTools("splitSegments", {
+  func: _splitSegments,
+  description: "Segmenting the text according to the topics simply",
+  params: {
+    texts: { name: "texts", type: ["string", "array"], required: true, description: "the texts to segment" },
+    model: { name: "model", type: "string", description: "the embedding model name used" }
+  },
+  result: "array",
+  scope: { splitSentence: splitSentence2, throwError: throwError2 },
+  depends: { isSimilar },
+  setup() {
+    this.modelId = "Xenova/distiluse-base-multilingual-cased-v2";
+  }
+});
+
+// src/funcs/segments.ts
+async function _segments({ texts, model = "Xenova/distiluse-base-multilingual-cased-v2" } = {}) {
+  const splitSegments2 = this.depends.splitSegments.getFuncWithPos();
+  const mergeSegments2 = this.depends.mergeSegments.getFuncWithPos();
+  const segments2 = await mergeSegments2(await splitSegments2(texts, model), model);
+  return segments2;
+}
+var segments = new ServerTools("segments", {
+  func: _segments,
+  description: "Segmenting the text according to the topics",
+  params: {
+    texts: { name: "texts", type: ["string", "array"], required: true },
+    model: { name: "model", type: "string", description: "the embedding model name used" }
+  },
+  depends: { splitSegments, mergeSegments },
+  result: "array"
+});
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  AIChatRoles: () => AIChatRoles,
+  AIMessageTypes: () => AIMessageTypes,
+  AIStream: () => AIStream,
+  AITextGenerationFinishReasons: () => AITextGenerationFinishReasons,
+  AbortError: () => AbortError,
+  AbortErrorCode: () => AbortErrorCode,
+  ActionNames: () => ActionNames,
+  AlreadyExistsError: () => AlreadyExistsError,
+  AlreadyExistsErrorCode: () => AlreadyExistsErrorCode,
+  BaseError: () => BaseError,
+  CommonError: () => CommonError,
+  ConfigFile: () => import_load_config_file.Config,
+  ErrorCode: () => ErrorCode,
+  EventBusName: () => EventBusName,
+  EventName: () => EventName,
+  FStringPromptTemplate: () => FStringPromptTemplate,
+  FewShotPromptTemplate: () => FewShotPromptTemplate,
+  FilenameReservedRegex: () => FilenameReservedRegex,
+  GolangPromptTemplate: () => GolangPromptTemplate,
+  HFBuiltins: () => builtins,
+  HFEnvironment: () => EnvironmentEx,
+  HFInterpreter: () => Interpreter,
+  HFTemplate: () => Template,
+  HfPromptTemplate: () => HfPromptTemplate,
+  InternalErrorCode: () => InternalErrorCode,
+  NotFoundError: () => NotFoundError,
+  NotFoundErrorCode: () => NotFoundErrorCode,
+  NotImplementationError: () => NotImplementationError,
+  NotImplementedErrorCode: () => NotImplementedErrorCode,
+  PASSING_SCORE: () => PASSING_SCORE,
+  PromptExampleSelector: () => PromptExampleSelector,
+  PromptTemplate: () => PromptTemplate,
+  PromptTemplateTypes: () => PromptTemplateTypes,
+  PromptTypes: () => PromptTypes,
+  RStreamErrCode: () => RStreamErrCode,
+  ReadableStreamError: () => ReadableStreamError,
+  RemoteToolFuncSchema: () => RemoteToolFuncSchema,
+  ResponseRStreamErrCode: () => ResponseRStreamErrCode,
+  SSEChannel: () => SSEChannel,
+  SSEChannelAlreadyClosedErrCode: () => SSEChannelAlreadyClosedErrCode,
+  WindowsReservedNameRegex: () => WindowsReservedNameRegex,
+  XXHashAlgorithm: () => XXHashAlgorithm,
+  backendEventable: () => backendEventable,
+  base32768: () => base327682,
+  createCallbacksTransformer: () => createCallbacksTransformer,
+  createEmptyReadableStream: () => createEmptyReadableStream,
+  createEndWithRepetitionDetector: () => createEndWithRepetitionDetector,
+  createError: () => createError,
+  createEventStreamTransformer: () => createEventStreamTransformer,
+  createHfValueFunc: () => createHfValueFunc,
+  defaultTemplateFormat: () => defaultTemplateFormat,
+  expandEnv: () => expandEnv,
+  expandObjEnv: () => expandObjEnv,
+  extNameLevel: () => extNameLevel,
+  filenameReservedRegex: () => filenameReservedRegex,
+  getAllEnumKeys: () => getAllEnumKeys,
+  getConfigFileNames: () => getConfigFileNames,
+  getConfigs: () => getConfigs,
+  getKeysPath: () => getKeysPath,
+  getMultiLevelExtname: () => getMultiLevelExtname,
+  getResponseErrorReadableStream: () => getResponseErrorReadableStream,
+  hfParse: () => parse,
+  hfTokenize: () => tokenize,
+  interpolateEnv: () => interpolateEnv,
+  interpolateFString: () => interpolateFString,
+  interpolateGolangTemplate: () => interpolateGolangTemplate,
+  isModelNameMatched: () => isModelNameMatched,
+  isValidFilename: () => isValidFilename,
+  isValidFilepath: () => isValidFilepath,
+  jsonFilterToWhere: () => jsonFilterToWhere,
+  loadFileFromPaths: () => loadFileFromPaths,
+  loadTextFromPaths: () => loadTextFromPaths,
+  mimeType: () => import_with_db.mimeType,
+  parseFString: () => parseFString,
+  parseJsJson: () => parseJsJson,
+  parseYaml: () => parseYaml,
+  reControlCharsRegex: () => reControlCharsRegex,
+  readableFromAsyncIterable: () => readableFromAsyncIterable,
+  registerYamlTag: () => registerYamlTag,
+  sanitizeFilename: () => sanitizeFilename,
+  sanitizeFilepath: () => sanitizeFilepath,
+  saveConfigFile: () => saveConfigFile,
+  sortedValues: () => sortedValues,
+  splitSentence: () => splitSentence2,
+  stringifyYaml: () => import_yaml2.stringify,
+  throwError: () => throwError2,
+  trimStartOfStreamHelper: () => trimStartOfStreamHelper,
+  truncTo: () => truncTo2,
+  uuid: () => uuid,
+  uuidNIL: () => import_uuid2.NIL,
+  uuidParse: () => import_uuid2.parse,
+  uuidStringify: () => import_uuid2.stringify,
+  uuidValidate: () => import_uuid2.validate,
+  uuidVersion: () => import_uuid2.version,
+  uuidv1: () => import_uuid2.v1,
+  uuidv4: () => import_uuid2.v4,
+  uuidv5: () => import_uuid2.v5,
+  wait: () => wait,
+  xxhash: () => xxhash,
+  xxhash32: () => xxhash32,
+  xxhash64: () => xxhash64,
+  xxhashAsStr: () => xxhashAsStr
+});
+
+// src/utils/chat.ts
+var AITextGenerationFinishReasons = [
+  "stop",
+  // model generated stop sequence
+  "length",
+  // model generated maximum number of tokens
+  "content-filter",
+  // content filter violation stopped the model
+  "tool-calls",
+  // model triggered tool calls
+  "abort",
+  // aborted by user or timeout for stream
+  "error",
+  // model stopped because of an error
+  "other",
+  null
+  // model stopped for other reasons
+];
+var AIMessageTypes = ["human", "ai", "generic", "system", "tool"];
+var AIChatRoles = ["user", "assistant", "system", "tool", "tool_calls"];
+
+// src/utils/prompt/consts.ts
+var PromptTypes = [
+  "chat",
+  "char",
+  "plan"
+];
+var PromptTemplateTypes = [
+  "internal",
+  "hf",
+  "fill"
+];
+
+// src/utils/prompt/prompt-template.ts
+var import_custom_factory = require("custom-factory");
+
+// src/utils/filterNullOrUndefined.ts
+function filterNullOrUndefined(obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    if (value != null) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+}
+
+// src/utils/prompt/prompt-template.ts
+var defaultTemplateFormat = "default";
+var PromptTemplate = class _PromptTemplate extends import_custom_factory.BaseFactory {
+  static from(template, options) {
+    return new this(template, options);
+  }
+  static async format(options) {
+    const template = new this(options);
+    return template.format();
+  }
+  /**
+   * If the given options.template is the template, perform formatting using that template.
+   * @param options - The options object to check for being a template and to format.
+   * @returns A Promise that resolves to the formatted result if options is a template; otherwise, no value is returned.
+   */
+  static async formatIf(options) {
+    if (this.isTemplate(options)) {
+      const template = new this(options);
+      return template.format();
+    }
+  }
+  static isTemplate(templateOpt) {
+    if (templateOpt?.template) {
+      const templateType = templateOpt.templateFormat || defaultTemplateFormat;
+      const Template2 = _PromptTemplate.get(templateType);
+      return Template2.isTemplate !== _PromptTemplate.isTemplate && Template2.isTemplate(templateOpt);
+    }
+  }
+  /**
+   * Validate/filter the data in inputVariables
+   * @param data
+   * @returns
+   */
+  filterData(data) {
+    if (Array.isArray(this.inputVariables)) {
+      data = Object.fromEntries(Object.entries(data).filter(([key]) => this.inputVariables.includes(key)));
+    }
+    return data;
+  }
+  constructor(template, options) {
+    if (typeof template === "string") {
+      if (!options) {
+        options = {};
+      }
+      options.template = template;
+    } else if (template) {
+      options = template;
+      template = options.template;
+    }
+    const { templateFormat: templateType } = options || {};
+    super(options);
+    if (this.constructor === _PromptTemplate) {
+      const TemplateClass = _PromptTemplate.get(templateType || defaultTemplateFormat);
+      if (TemplateClass) {
+        return Reflect.construct(TemplateClass, arguments);
+      } else {
+        throw new CommonError(`Prompt template type ${templateType} not found`, "PromptTemplate", 400 /* InvalidArgument */);
+      }
+    }
+  }
+  _initialize(options) {
+    throw new NotImplementationError("Not implemented", "PromptTemplate");
+  }
+  initialize(options) {
+    if (this.constructor !== _PromptTemplate) {
+      Object.assign(this, this.toJSON(options));
+      if (!options?.ignoreInitialize) {
+        this._initialize(options);
+      }
+    }
+  }
+  _format(data) {
+    throw new NotImplementationError("Not implemented", "PromptTemplate");
+  }
+  async format(data) {
+    const partialData = this.data;
+    data = { ...partialData, ...data };
+    if (partialData) {
+      for (const [key, value] of Object.entries(partialData)) {
+        if (data[key] === value && typeof value === "function") {
+          delete data[key];
+          data[key] = await value(data);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (value instanceof _PromptTemplate) {
+        delete data[key];
+        data[key] = await value.format(data);
+      }
+    }
+    return this._format(data);
+  }
+  /**
+   * it can make sense to "partial" a prompt template - eg pass in a subset of the required values, as to create a new prompt template which expects only the remaining subset of values.
+   * @param data the partial data
+   * @returns the new partial PromptTemplate instance
+   */
+  partial(data) {
+    data = { ...this.data, ...data };
+    const options = this.toJSON();
+    options.data = data;
+    options.ignoreInitialize = true;
+    return new this.constructor(options);
+  }
+  toJSON(options = this) {
+    let result = {
+      template: options.template,
+      data: options.data,
+      inputVariables: options.inputVariables,
+      compiledTemplate: options.compiledTemplate
+    };
+    if (options.templateFormat && _PromptTemplate.get(options.templateFormat) !== this.constructor) {
+      result.templateFormat = options.templateFormat;
+    }
+    result = filterNullOrUndefined(result);
+    return result;
+  }
+};
+
+// src/utils/iterator-wrap.ts
+async function* asyncFromSync(iterable) {
+  const it = iterable[Symbol.iterator]();
+  let needToClose;
+  try {
+    for (; ; ) {
+      needToClose = false;
+      const rec = it.next();
+      needToClose = true;
+      if (rec.done) {
+        needToClose = false;
+        return await rec.value;
+      }
+      yield await rec.value;
+    }
+  } finally {
+    if (needToClose) {
+      await it.return?.().value;
+    }
+  }
+}
+function asyncWrap(iterable) {
+  return isIterable(iterable) ? asyncFromSync(iterable) : iterable;
+}
+function isIterable(value) {
+  return !!value && typeof value[Symbol.iterator] === "function";
+}
+function iteratorWrap(iterable) {
+  return engineValid ? iterable : asyncWrap(iterable);
+}
+var engineValid = false;
+isEngineValid().then((valid) => {
+  engineValid = valid;
+});
+async function isEngineValid() {
+  let finallyCalled = false;
+  let catchCalled = false;
+  try {
+    for await (const _x of function* () {
+      try {
+        yield Promise.reject();
+      } finally {
+        finallyCalled = true;
+      }
+    }()) {
+      throw new Error("impossible");
+    }
+  } catch {
+    catchCalled = true;
+  }
+  return catchCalled && finallyCalled;
+}
+
+// src/utils/prompt/prompt-example-selector.ts
+var PromptExampleSelector = class {
+  /**
+   * Constructs a new `PromptExampleSelector` instance with the given examples and options.
+   * @param examples - The prompt examples to select from.
+   * @param options - An optional configuration object.
+   */
+  constructor(examples, options) {
+    this.initialize(examples, options);
+  }
+  /**
+   * Initializes the selector with examples and options.
+   * @param examples - The prompt examples to select from.
+   * @param options - An optional configuration object.
+   */
+  initialize(examples, options) {
+    const maxLength = options?.maxLength;
+    if (maxLength > 0) {
+      this.maxLength = maxLength;
+    }
+    if (options?.threshold !== void 0) {
+      if (options.threshold === true) {
+        this.threshold = 0.5;
+      } else if (options.threshold !== false) {
+        this.threshold = options.threshold;
+      }
+    }
+    this.examples = iteratorWrap(examples);
+  }
+  /**
+   * Select an example. Can overwrite this in subclasses.
+   * @param example - The example to potentially select.
+   * @param [threshold] - report the current probability [0-1) for the selecting example.
+   * @returns The selected example, or `undefined` if not selected.
+   */
+  selectExample(example, threshold) {
+    if (threshold === void 0 || threshold <= this.threshold) {
+      return example;
+    }
+  }
+  /**
+   * Asynchronously selects examples from the given examples, applying the configured threshold (if any).
+   * @param examples - The examples to select from. Defaults to the selector's examples if not provided.
+   * @returns An asynchronous iterator yielding selected examples.
+   */
+  async *selectExamples(examples = this.examples) {
+    let count = this.maxLength || Infinity;
+    for await (const example of examples) {
+      const threshold = typeof this.threshold === "number" ? Math.random() : void 0;
+      const ex = this.selectExample(example, threshold);
+      if (ex) {
+        if (--count < 0) {
+          break;
+        }
+        yield example;
+      }
+    }
+  }
+  /**
+   * Returns an asynchronous iterator for the selected examples.
+   * @returns An asynchronous iterator over the selected examples.
+   */
+  async *[Symbol.asyncIterator]() {
+    yield* this.selectExamples();
+  }
+};
+
+// src/utils/prompt/template/jinja/src/lexer.ts
+var TOKEN_TYPES = Object.freeze({
+  Text: "Text",
+  // The text between Jinja statements or expressions
+  NumericLiteral: "NumericLiteral",
+  // e.g., 123
+  BooleanLiteral: "BooleanLiteral",
+  // true or false
+  StringLiteral: "StringLiteral",
+  // 'string'
+  Identifier: "Identifier",
+  // Variables, functions, etc.
+  Equals: "Equals",
+  // =
+  OpenParen: "OpenParen",
+  // (
+  CloseParen: "CloseParen",
+  // )
+  OpenStatement: "OpenStatement",
+  // {%
+  CloseStatement: "CloseStatement",
+  // %}
+  OpenExpression: "OpenExpression",
+  // {{
+  CloseExpression: "CloseExpression",
+  // }}
+  OpenSquareBracket: "OpenSquareBracket",
+  // [
+  CloseSquareBracket: "CloseSquareBracket",
+  // ]
+  OpenCurlyBracket: "OpenCurlyBracket",
+  // {
+  CloseCurlyBracket: "CloseCurlyBracket",
+  // }
+  Comma: "Comma",
+  // ,
+  Dot: "Dot",
+  // .
+  Colon: "Colon",
+  // :
+  Pipe: "Pipe",
+  // |
+  CallOperator: "CallOperator",
+  // ()
+  AdditiveBinaryOperator: "AdditiveBinaryOperator",
+  // + -
+  MultiplicativeBinaryOperator: "MultiplicativeBinaryOperator",
+  // * / %
+  ComparisonBinaryOperator: "ComparisonBinaryOperator",
+  // < > <= >= == !=
+  UnaryOperator: "UnaryOperator",
+  // ! - +
+  // Keywords
+  Set: "Set",
+  If: "If",
+  For: "For",
+  In: "In",
+  Is: "Is",
+  NotIn: "NotIn",
+  Else: "Else",
+  EndIf: "EndIf",
+  ElseIf: "ElseIf",
+  EndFor: "EndFor",
+  And: "And",
+  Or: "Or",
+  Not: "UnaryOperator"
+});
+var KEYWORDS = Object.freeze({
+  set: TOKEN_TYPES.Set,
+  for: TOKEN_TYPES.For,
+  in: TOKEN_TYPES.In,
+  is: TOKEN_TYPES.Is,
+  if: TOKEN_TYPES.If,
+  else: TOKEN_TYPES.Else,
+  endif: TOKEN_TYPES.EndIf,
+  elif: TOKEN_TYPES.ElseIf,
+  endfor: TOKEN_TYPES.EndFor,
+  and: TOKEN_TYPES.And,
+  or: TOKEN_TYPES.Or,
+  not: TOKEN_TYPES.Not,
+  "not in": TOKEN_TYPES.NotIn,
+  // Literals
+  true: TOKEN_TYPES.BooleanLiteral,
+  false: TOKEN_TYPES.BooleanLiteral
+});
+var Token = class {
+  /**
+   * Constructs a new Token.
+   * @param {string} value The raw value as seen inside the source code.
+   * @param {TokenType} type The type of token.
+   */
+  constructor(value, type) {
+    this.value = value;
+    this.type = type;
+  }
+};
+function isWord(char) {
+  return /\w/.test(char);
+}
+function isInteger(char) {
+  return /[0-9]/.test(char);
+}
+var ORDERED_MAPPING_TABLE = [
+  // Control sequences
+  ["{%", TOKEN_TYPES.OpenStatement],
+  ["%}", TOKEN_TYPES.CloseStatement],
+  ["{{", TOKEN_TYPES.OpenExpression],
+  ["}}", TOKEN_TYPES.CloseExpression],
+  // Single character tokens
+  ["(", TOKEN_TYPES.OpenParen],
+  [")", TOKEN_TYPES.CloseParen],
+  ["{", TOKEN_TYPES.OpenCurlyBracket],
+  ["}", TOKEN_TYPES.CloseCurlyBracket],
+  ["[", TOKEN_TYPES.OpenSquareBracket],
+  ["]", TOKEN_TYPES.CloseSquareBracket],
+  [",", TOKEN_TYPES.Comma],
+  [".", TOKEN_TYPES.Dot],
+  [":", TOKEN_TYPES.Colon],
+  ["|", TOKEN_TYPES.Pipe],
+  // Comparison operators
+  ["<=", TOKEN_TYPES.ComparisonBinaryOperator],
+  [">=", TOKEN_TYPES.ComparisonBinaryOperator],
+  ["==", TOKEN_TYPES.ComparisonBinaryOperator],
+  ["!=", TOKEN_TYPES.ComparisonBinaryOperator],
+  ["<", TOKEN_TYPES.ComparisonBinaryOperator],
+  [">", TOKEN_TYPES.ComparisonBinaryOperator],
+  // Arithmetic operators
+  ["+", TOKEN_TYPES.AdditiveBinaryOperator],
+  ["-", TOKEN_TYPES.AdditiveBinaryOperator],
+  ["*", TOKEN_TYPES.MultiplicativeBinaryOperator],
+  ["/", TOKEN_TYPES.MultiplicativeBinaryOperator],
+  ["%", TOKEN_TYPES.MultiplicativeBinaryOperator],
+  // Assignment operator
+  ["=", TOKEN_TYPES.Equals]
+];
+var ESCAPE_CHARACTERS = /* @__PURE__ */ new Map([
+  ["n", "\n"],
+  // New line
+  ["t", "	"],
+  // Horizontal tab
+  ["r", "\r"],
+  // Carriage return
+  ["b", "\b"],
+  // Backspace
+  ["f", "\f"],
+  // Form feed
+  ["v", "\v"],
+  // Vertical tab
+  ["'", "'"],
+  // Single quote
+  ['"', '"'],
+  // Double quote
+  ["\\", "\\"]
+  // Backslash
+]);
+function preprocess(template, options = {}) {
+  if (template.endsWith("\n")) {
+    template = template.slice(0, -1);
+  }
+  template = template.replace(/{#.*?#}/gs, "{##}");
+  if (options.lstrip_blocks) {
+    template = template.replace(/^[ \t]*({[#%])/gm, "$1");
+  }
+  if (options.trim_blocks) {
+    template = template.replace(/([#%]})\n/g, "$1");
+  }
+  return template.replace(/{##}/g, "").replace(/-%}\s*/g, "%}").replace(/\s*{%-/g, "{%").replace(/-}}\s*/g, "}}").replace(/\s*{{-/g, "{{");
+}
+function tokenize(source, options = {}) {
+  const tokens = [];
+  const src = preprocess(source, options);
+  let cursorPosition = 0;
+  const consumeWhile = (predicate) => {
+    let str = "";
+    while (predicate(src[cursorPosition])) {
+      if (src[cursorPosition] === "\\") {
+        ++cursorPosition;
+        if (cursorPosition >= src.length)
+          throw new SyntaxError("Unexpected end of input");
+        const escaped = src[cursorPosition++];
+        const unescaped = ESCAPE_CHARACTERS.get(escaped);
+        if (unescaped === void 0) {
+          throw new SyntaxError(`Unexpected escaped character: ${escaped}`);
+        }
+        str += unescaped;
+        continue;
+      }
+      str += src[cursorPosition++];
+      if (cursorPosition >= src.length)
+        throw new SyntaxError("Unexpected end of input");
+    }
+    return str;
+  };
+  main:
+    while (cursorPosition < src.length) {
+      const lastTokenType = tokens.at(-1)?.type;
+      if (lastTokenType === void 0 || lastTokenType === TOKEN_TYPES.CloseStatement || lastTokenType === TOKEN_TYPES.CloseExpression) {
+        let text = "";
+        while (cursorPosition < src.length && // Keep going until we hit the next Jinja statement or expression
+        !(src[cursorPosition] === "{" && (src[cursorPosition + 1] === "%" || src[cursorPosition + 1] === "{"))) {
+          text += src[cursorPosition++];
+        }
+        if (text.length > 0) {
+          tokens.push(new Token(text, TOKEN_TYPES.Text));
+          continue;
+        }
+      }
+      consumeWhile((char2) => /\s/.test(char2));
+      const char = src[cursorPosition];
+      if (char === "-" || char === "+") {
+        const lastTokenType2 = tokens.at(-1)?.type;
+        if (lastTokenType2 === TOKEN_TYPES.Text || lastTokenType2 === void 0) {
+          throw new SyntaxError(`Unexpected character: ${char}`);
+        }
+        switch (lastTokenType2) {
+          case TOKEN_TYPES.Identifier:
+          case TOKEN_TYPES.NumericLiteral:
+          case TOKEN_TYPES.BooleanLiteral:
+          case TOKEN_TYPES.StringLiteral:
+          case TOKEN_TYPES.CloseParen:
+          case TOKEN_TYPES.CloseSquareBracket:
+            break;
+          default: {
+            ++cursorPosition;
+            const num = consumeWhile(isInteger);
+            tokens.push(
+              new Token(`${char}${num}`, num.length > 0 ? TOKEN_TYPES.NumericLiteral : TOKEN_TYPES.UnaryOperator)
+            );
+            continue;
+          }
+        }
+      }
+      for (const [char2, token] of ORDERED_MAPPING_TABLE) {
+        const slice2 = src.slice(cursorPosition, cursorPosition + char2.length);
+        if (slice2 === char2) {
+          tokens.push(new Token(char2, token));
+          cursorPosition += char2.length;
+          continue main;
+        }
+      }
+      if (char === "'" || char === '"') {
+        ++cursorPosition;
+        const str = consumeWhile((c) => c !== char);
+        tokens.push(new Token(str, TOKEN_TYPES.StringLiteral));
+        ++cursorPosition;
+        continue;
+      }
+      if (isInteger(char)) {
+        const num = consumeWhile(isInteger);
+        tokens.push(new Token(num, TOKEN_TYPES.NumericLiteral));
+        continue;
+      }
+      if (isWord(char)) {
+        const word = consumeWhile(isWord);
+        const type = Object.hasOwn(KEYWORDS, word) ? KEYWORDS[word] : TOKEN_TYPES.Identifier;
+        if (type === TOKEN_TYPES.In && tokens.at(-1)?.type === TOKEN_TYPES.Not) {
+          tokens.pop();
+          tokens.push(new Token("not in", TOKEN_TYPES.NotIn));
+        } else {
+          tokens.push(new Token(word, type));
+        }
+        continue;
+      }
+      throw new SyntaxError(`Unexpected character: ${char}`);
+    }
+  return tokens;
+}
+
+// src/utils/prompt/template/jinja/src/ast.ts
+var Statement = class {
+  constructor() {
+    this.type = "Statement";
+  }
+};
+var Program = class extends Statement {
+  constructor(body) {
+    super();
+    this.body = body;
+    this.type = "Program";
+  }
+};
+var If = class extends Statement {
+  constructor(test, body, alternate) {
+    super();
+    this.test = test;
+    this.body = body;
+    this.alternate = alternate;
+    this.type = "If";
+  }
+};
+var For = class extends Statement {
+  constructor(loopvar, iterable, body) {
+    super();
+    this.loopvar = loopvar;
+    this.iterable = iterable;
+    this.body = body;
+    this.type = "For";
+  }
+};
+var SetStatement = class extends Statement {
+  constructor(assignee, value) {
+    super();
+    this.assignee = assignee;
+    this.value = value;
+    this.type = "Set";
+  }
+};
+var Expression = class extends Statement {
+  constructor() {
+    super(...arguments);
+    this.type = "Expression";
+  }
+};
+var MemberExpression = class extends Expression {
+  constructor(object, property, computed) {
+    super();
+    this.object = object;
+    this.property = property;
+    this.computed = computed;
+    this.type = "MemberExpression";
+  }
+};
+var CallExpression = class extends Expression {
+  constructor(callee, args) {
+    super();
+    this.callee = callee;
+    this.args = args;
+    this.type = "CallExpression";
+  }
+};
+var Identifier = class extends Expression {
+  /**
+   * @param {string} value The name of the identifier
+   */
+  constructor(value) {
+    super();
+    this.value = value;
+    this.type = "Identifier";
+  }
+};
+var Literal = class extends Expression {
+  constructor(value) {
+    super();
+    this.value = value;
+    this.type = "Literal";
+  }
+};
+var NumericLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "NumericLiteral";
+  }
+};
+var StringLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "StringLiteral";
+  }
+};
+var BooleanLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "BooleanLiteral";
+  }
+};
+var ArrayLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "ArrayLiteral";
+  }
+};
+var TupleLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "TupleLiteral";
+  }
+};
+var ObjectLiteral = class extends Literal {
+  constructor() {
+    super(...arguments);
+    this.type = "ObjectLiteral";
+  }
+};
+var BinaryExpression = class extends Expression {
+  constructor(operator, left, right) {
+    super();
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+    this.type = "BinaryExpression";
+  }
+};
+var FilterExpression = class extends Expression {
+  constructor(operand, filter) {
+    super();
+    this.operand = operand;
+    this.filter = filter;
+    this.type = "FilterExpression";
+  }
+};
+var TestExpression = class extends Expression {
+  constructor(operand, negate, test) {
+    super();
+    this.operand = operand;
+    this.negate = negate;
+    this.test = test;
+    this.type = "TestExpression";
+  }
+};
+var UnaryExpression = class extends Expression {
+  constructor(operator, argument) {
+    super();
+    this.operator = operator;
+    this.argument = argument;
+    this.type = "UnaryExpression";
+  }
+};
+var SliceExpression = class extends Expression {
+  constructor(start = void 0, stop = void 0, step = void 0) {
+    super();
+    this.start = start;
+    this.stop = stop;
+    this.step = step;
+    this.type = "SliceExpression";
+  }
+};
+var KeywordArgumentExpression = class extends Expression {
+  constructor(key, value) {
+    super();
+    this.key = key;
+    this.value = value;
+    this.type = "KeywordArgumentExpression";
+  }
+};
+
+// src/utils/prompt/template/jinja/src/parser.ts
+function parse(tokens) {
+  const program = new Program([]);
+  let current = 0;
+  function expect(type, error) {
+    const prev = tokens[current++];
+    if (!prev || prev.type !== type) {
+      throw new Error(`Parser Error: ${error}. ${prev.type} !== ${type}.`);
+    }
+    return prev;
+  }
+  function parseAny() {
+    let result;
+    switch (tokens[current].type) {
+      case TOKEN_TYPES.Text:
+        result = parseText();
+        break;
+      case TOKEN_TYPES.OpenStatement:
+        result = parseJinjaStatement();
+        result.isStatement = true;
+        break;
+      case TOKEN_TYPES.OpenExpression:
+        result = parseJinjaExpression();
+        result.isStatement = true;
+        break;
+      default:
+        throw new SyntaxError(`Unexpected token type: ${tokens[current].type}`);
+    }
+    return result;
+  }
+  function not(...types) {
+    return current + types.length <= tokens.length && types.some((type, i) => type !== tokens[current + i].type);
+  }
+  function is(...types) {
+    return current + types.length <= tokens.length && types.every((type, i) => type === tokens[current + i].type);
+  }
+  function parseText() {
+    return new StringLiteral(expect(TOKEN_TYPES.Text, "Expected text token").value);
+  }
+  function parseJinjaStatement() {
+    expect(TOKEN_TYPES.OpenStatement, "Expected opening statement token");
+    let result;
+    switch (tokens[current].type) {
+      case TOKEN_TYPES.Set:
+        ++current;
+        result = parseSetStatement();
+        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+        break;
+      case TOKEN_TYPES.If:
+        ++current;
+        result = parseIfStatement();
+        expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
+        expect(TOKEN_TYPES.EndIf, "Expected endif token");
+        expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
+        break;
+      case TOKEN_TYPES.For:
+        ++current;
+        result = parseForStatement();
+        expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
+        expect(TOKEN_TYPES.EndFor, "Expected endfor token");
+        expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
+        break;
+      default:
+        throw new SyntaxError(`Unknown statement type: ${tokens[current].type}`);
+    }
+    return result;
+  }
+  function parseJinjaExpression() {
+    expect(TOKEN_TYPES.OpenExpression, "Expected opening expression token");
+    const result = parseExpression();
+    expect(TOKEN_TYPES.CloseExpression, "Expected closing expression token");
+    return result;
+  }
+  function parseSetStatement() {
+    const left = parseExpression();
+    if (is(TOKEN_TYPES.Equals)) {
+      ++current;
+      const value = parseSetStatement();
+      return new SetStatement(left, value);
+    }
+    return left;
+  }
+  function parseIfStatement() {
+    const test = parseExpression();
+    expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+    const body = [];
+    const alternate = [];
+    while (!(tokens[current]?.type === TOKEN_TYPES.OpenStatement && (tokens[current + 1]?.type === TOKEN_TYPES.ElseIf || tokens[current + 1]?.type === TOKEN_TYPES.Else || tokens[current + 1]?.type === TOKEN_TYPES.EndIf))) {
+      body.push(parseAny());
+    }
+    if (tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type !== TOKEN_TYPES.EndIf) {
+      ++current;
+      if (is(TOKEN_TYPES.ElseIf)) {
+        expect(TOKEN_TYPES.ElseIf, "Expected elseif token");
+        alternate.push(parseIfStatement());
+      } else {
+        expect(TOKEN_TYPES.Else, "Expected else token");
+        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+        while (!(tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type === TOKEN_TYPES.EndIf)) {
+          alternate.push(parseAny());
+        }
+      }
+    }
+    return new If(test, body, alternate);
+  }
+  function parseExpressionSequence(primary = false) {
+    const fn = primary ? parsePrimaryExpression : parseExpression;
+    const expressions = [fn()];
+    const isTuple = is(TOKEN_TYPES.Comma);
+    while (isTuple) {
+      ++current;
+      expressions.push(fn());
+      if (!is(TOKEN_TYPES.Comma)) {
+        break;
+      }
+    }
+    return isTuple ? new TupleLiteral(expressions) : expressions[0];
+  }
+  function parseForStatement() {
+    const loopVariable = parseExpressionSequence(true);
+    if (!(loopVariable instanceof Identifier || loopVariable instanceof TupleLiteral)) {
+      throw new SyntaxError(`Expected identifier/tuple for the loop variable, got ${loopVariable.type} instead`);
+    }
+    expect(TOKEN_TYPES.In, "Expected `in` keyword following loop variable");
+    const iterable = parseExpression();
+    expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+    const body = [];
+    while (not(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.EndFor)) {
+      body.push(parseAny());
+    }
+    return new For(loopVariable, iterable, body);
+  }
+  function parseExpression() {
+    return parseTernaryExpression();
+  }
+  function parseTernaryExpression() {
+    const a = parseLogicalOrExpression();
+    if (is(TOKEN_TYPES.If)) {
+      ++current;
+      const predicate = parseLogicalOrExpression();
+      expect(TOKEN_TYPES.Else, "Expected else token");
+      const b = parseLogicalOrExpression();
+      return new If(predicate, [a], [b]);
+    }
+    return a;
+  }
+  function parseLogicalOrExpression() {
+    let left = parseLogicalAndExpression();
+    while (is(TOKEN_TYPES.Or)) {
+      const operator = tokens[current];
+      ++current;
+      const right = parseLogicalAndExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parseLogicalAndExpression() {
+    let left = parseLogicalNegationExpression();
+    while (is(TOKEN_TYPES.And)) {
+      const operator = tokens[current];
+      ++current;
+      const right = parseLogicalNegationExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parseLogicalNegationExpression() {
+    let right;
+    while (is(TOKEN_TYPES.Not)) {
+      const operator = tokens[current];
+      ++current;
+      const arg = parseLogicalNegationExpression();
+      right = new UnaryExpression(operator, arg);
+    }
+    return right ?? parseComparisonExpression();
+  }
+  function parseComparisonExpression() {
+    let left = parseAdditiveExpression();
+    while (is(TOKEN_TYPES.ComparisonBinaryOperator) || is(TOKEN_TYPES.In) || is(TOKEN_TYPES.NotIn)) {
+      const operator = tokens[current];
+      ++current;
+      const right = parseAdditiveExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parseAdditiveExpression() {
+    let left = parseMultiplicativeExpression();
+    while (is(TOKEN_TYPES.AdditiveBinaryOperator)) {
+      const operator = tokens[current];
+      ++current;
+      const right = parseMultiplicativeExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parseCallMemberExpression() {
+    const member = parseMemberExpression();
+    if (is(TOKEN_TYPES.OpenParen)) {
+      return parseCallExpression(member);
+    }
+    return member;
+  }
+  function parseCallExpression(callee) {
+    let callExpression = new CallExpression(callee, parseArgs());
+    if (is(TOKEN_TYPES.OpenParen)) {
+      callExpression = parseCallExpression(callExpression);
+    }
+    return callExpression;
+  }
+  function parseArgs() {
+    expect(TOKEN_TYPES.OpenParen, "Expected opening parenthesis for arguments list");
+    const args = parseArgumentsList();
+    expect(TOKEN_TYPES.CloseParen, "Expected closing parenthesis for arguments list");
+    return args;
+  }
+  function parseArgumentsList() {
+    const args = [];
+    while (!is(TOKEN_TYPES.CloseParen)) {
+      let argument = parseExpression();
+      if (is(TOKEN_TYPES.Equals)) {
+        ++current;
+        if (!(argument instanceof Identifier)) {
+          throw new SyntaxError(`Expected identifier for keyword argument`);
+        }
+        const value = parseExpression();
+        argument = new KeywordArgumentExpression(argument, value);
+      }
+      args.push(argument);
+      if (is(TOKEN_TYPES.Comma)) {
+        ++current;
+      }
+    }
+    return args;
+  }
+  function parseMemberExpressionArgumentsList() {
+    const slices = [];
+    let isSlice = false;
+    while (!is(TOKEN_TYPES.CloseSquareBracket)) {
+      if (is(TOKEN_TYPES.Colon)) {
+        slices.push(void 0);
+        ++current;
+        isSlice = true;
+      } else {
+        slices.push(parseExpression());
+        if (is(TOKEN_TYPES.Colon)) {
+          ++current;
+          isSlice = true;
+        }
+      }
+    }
+    if (slices.length === 0) {
+      throw new SyntaxError(`Expected at least one argument for member/slice expression`);
+    }
+    if (isSlice) {
+      if (slices.length > 3) {
+        throw new SyntaxError(`Expected 0-3 arguments for slice expression`);
+      }
+      return new SliceExpression(...slices);
+    }
+    return slices[0];
+  }
+  function parseMemberExpression() {
+    let object = parsePrimaryExpression();
+    while (is(TOKEN_TYPES.Dot) || is(TOKEN_TYPES.OpenSquareBracket)) {
+      const operator = tokens[current];
+      ++current;
+      let property;
+      const computed = operator.type !== TOKEN_TYPES.Dot;
+      if (computed) {
+        property = parseMemberExpressionArgumentsList();
+        expect(TOKEN_TYPES.CloseSquareBracket, "Expected closing square bracket");
+      } else {
+        property = parsePrimaryExpression();
+        if (property.type !== "Identifier") {
+          throw new SyntaxError(`Expected identifier following dot operator`);
+        }
+      }
+      object = new MemberExpression(object, property, computed);
+    }
+    return object;
+  }
+  function parseMultiplicativeExpression() {
+    let left = parseTestExpression();
+    while (is(TOKEN_TYPES.MultiplicativeBinaryOperator)) {
+      const operator = tokens[current];
+      ++current;
+      const right = parseTestExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parseTestExpression() {
+    let operand = parseFilterExpression();
+    while (is(TOKEN_TYPES.Is)) {
+      ++current;
+      const negate = is(TOKEN_TYPES.Not);
+      if (negate) {
+        ++current;
+      }
+      let filter = parsePrimaryExpression();
+      if (filter instanceof BooleanLiteral) {
+        filter = new Identifier(filter.value.toString());
+      }
+      if (!(filter instanceof Identifier)) {
+        throw new SyntaxError(`Expected identifier for the test`);
+      }
+      operand = new TestExpression(operand, negate, filter);
+    }
+    return operand;
+  }
+  function parseFilterExpression() {
+    let operand = parseCallMemberExpression();
+    while (is(TOKEN_TYPES.Pipe)) {
+      ++current;
+      let filter = parsePrimaryExpression();
+      if (!(filter instanceof Identifier)) {
+        throw new SyntaxError(`Expected identifier for the filter`);
+      }
+      if (is(TOKEN_TYPES.OpenParen)) {
+        filter = parseCallExpression(filter);
+      }
+      operand = new FilterExpression(operand, filter);
+    }
+    return operand;
+  }
+  function parsePrimaryExpression() {
+    const token = tokens[current];
+    switch (token.type) {
+      case TOKEN_TYPES.NumericLiteral:
+        ++current;
+        return new NumericLiteral(Number(token.value));
+      case TOKEN_TYPES.StringLiteral:
+        ++current;
+        return new StringLiteral(token.value);
+      case TOKEN_TYPES.BooleanLiteral:
+        ++current;
+        return new BooleanLiteral(token.value === "true");
+      case TOKEN_TYPES.Identifier:
+        ++current;
+        return new Identifier(token.value);
+      case TOKEN_TYPES.OpenParen: {
+        ++current;
+        const expression = parseExpressionSequence();
+        if (tokens[current].type !== TOKEN_TYPES.CloseParen) {
+          throw new SyntaxError(`Expected closing parenthesis, got ${tokens[current].type} instead`);
+        }
+        ++current;
+        return expression;
+      }
+      case TOKEN_TYPES.OpenSquareBracket: {
+        ++current;
+        const values = [];
+        while (!is(TOKEN_TYPES.CloseSquareBracket)) {
+          values.push(parseExpression());
+          if (is(TOKEN_TYPES.Comma)) {
+            ++current;
+          }
+        }
+        ++current;
+        return new ArrayLiteral(values);
+      }
+      case TOKEN_TYPES.OpenCurlyBracket: {
+        ++current;
+        const values = /* @__PURE__ */ new Map();
+        while (!is(TOKEN_TYPES.CloseCurlyBracket)) {
+          const key = parseExpression();
+          expect(TOKEN_TYPES.Colon, "Expected colon between key and value in object literal");
+          const value = parseExpression();
+          values.set(key, value);
+          if (is(TOKEN_TYPES.Comma)) {
+            ++current;
+          }
+        }
+        ++current;
+        return new ObjectLiteral(values);
+      }
+      default:
+        throw new SyntaxError(`Unexpected token: ${token.type}`);
+    }
+  }
+  while (current < tokens.length) {
+    program.body.push(parseAny());
+  }
+  return program;
+}
+
+// src/utils/prompt/template/jinja/src/utils.ts
+function range(start, stop, step = 1) {
+  if (stop === void 0) {
+    stop = start;
+    start = 0;
+  }
+  const result = [];
+  for (let i = start; i < stop; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+function slice(array, start, stop, step = 1) {
+  const direction = Math.sign(step);
+  if (direction >= 0) {
+    start = (start ??= 0) < 0 ? Math.max(array.length + start, 0) : Math.min(start, array.length);
+    stop = (stop ??= array.length) < 0 ? Math.max(array.length + stop, 0) : Math.min(stop, array.length);
+  } else {
+    start = (start ??= array.length - 1) < 0 ? Math.max(array.length + start, -1) : Math.min(start, array.length - 1);
+    stop = (stop ??= -1) < -1 ? Math.max(array.length + stop, -1) : Math.min(stop, array.length - 1);
+  }
+  const result = [];
+  for (let i = start; direction * i < direction * stop; i += step) {
+    result.push(array[i]);
+  }
+  return result;
+}
+function titleCase(value) {
+  return value.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// src/utils/prompt/template/jinja/src/runtime.ts
+var RuntimeValue = class {
+  /**
+   * Creates a new RuntimeValue.
+   */
+  constructor(value = void 0) {
+    this.type = "RuntimeValue";
+    /**
+     * A collection of built-in functions for this type.
+     */
+    this.builtins = /* @__PURE__ */ new Map();
+    this.value = value;
+  }
+  /**
+   * Determines truthiness or falsiness of the runtime value.
+   * This function should be overridden by subclasses if it has custom truthiness criteria.
+   * @returns {BooleanValue} BooleanValue(true) if the value is truthy, BooleanValue(false) otherwise.
+   */
+  __bool__() {
+    return new BooleanValue(!!this.value);
+  }
+  toString() {
+    return "" + this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+};
+var NumericValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "NumericValue";
+  }
+};
+var StringValue = class _StringValue extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "StringValue";
+    this.builtins = /* @__PURE__ */ new Map([
+      [
+        "upper",
+        new FunctionValue(() => {
+          return new _StringValue(this.value.toUpperCase());
+        })
+      ],
+      [
+        "lower",
+        new FunctionValue(() => {
+          return new _StringValue(this.value.toLowerCase());
+        })
+      ],
+      [
+        "strip",
+        new FunctionValue(() => {
+          return new _StringValue(this.value.trim());
+        })
+      ],
+      [
+        "title",
+        new FunctionValue(() => {
+          return new _StringValue(titleCase(this.value));
+        })
+      ],
+      ["length", new NumericValue(this.value.length)],
+      [
+        "rstrip",
+        new FunctionValue(() => {
+          return new _StringValue(this.value.trimEnd());
+        })
+      ],
+      [
+        "lstrip",
+        new FunctionValue(() => {
+          return new _StringValue(this.value.trimStart());
+        })
+      ]
+    ]);
+  }
+};
+var BooleanValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "BooleanValue";
+  }
+};
+var ObjectValue = class extends RuntimeValue {
+  constructor(value, orgValue) {
+    super(value);
+    this.orgValue = orgValue;
+    this.type = "ObjectValue";
+    this.builtins = /* @__PURE__ */ new Map([
+      [
+        "get",
+        new FunctionValue(([key, defaultValue]) => {
+          if (!(key instanceof StringValue)) {
+            throw new Error(`Object key must be a string: got ${key.type}`);
+          }
+          return this.value.get(key.value) ?? defaultValue ?? new NullValue();
+        })
+      ],
+      [
+        "items",
+        new FunctionValue(() => {
+          return new ArrayValue(
+            Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value]))
+          );
+        })
+      ]
+    ]);
+  }
+  toString() {
+    let result;
+    if (this.orgValue && this.orgValue.toString !== Object.prototype.toString) {
+      result = this.orgValue.toString();
+    } else {
+      result = JSON.stringify(Object.fromEntries(this.value.entries()));
+    }
+    return result;
+  }
+  toJSON() {
+    if (this.orgValue) {
+      return this.orgValue;
+    }
+    return Object.fromEntries(this.value.entries());
+  }
+  /**
+   * NOTE: necessary to override since all JavaScript arrays are considered truthy,
+   * while only non-empty Python arrays are consider truthy.
+   *
+   * e.g.,
+   *  - JavaScript:  {} && 5 -> 5
+   *  - Python:      {} and 5 -> {}
+   */
+  __bool__() {
+    return new BooleanValue(this.value.size > 0);
+  }
+};
+var ArrayValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "ArrayValue";
+    this.builtins = /* @__PURE__ */ new Map([["length", new NumericValue(this.value.length)]]);
+  }
+  /**
+   * NOTE: necessary to override since all JavaScript arrays are considered truthy,
+   * while only non-empty Python arrays are consider truthy.
+   *
+   * e.g.,
+   *  - JavaScript:  [] && 5 -> 5
+   *  - Python:      [] and 5 -> []
+   */
+  __bool__() {
+    return new BooleanValue(this.value.length > 0);
+  }
+};
+var TupleValue = class extends ArrayValue {
+  constructor() {
+    super(...arguments);
+    this.type = "TupleValue";
+  }
+};
+var FunctionValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "FunctionValue";
+  }
+};
+var NullValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "NullValue";
+  }
+};
+var UndefinedValue = class extends RuntimeValue {
+  constructor() {
+    super(...arguments);
+    this.type = "UndefinedValue";
+  }
+};
+var Environment = class {
+  constructor(parent) {
+    this.parent = parent;
+    /**
+     * The variables declared in this environment.
+     */
+    this.variables = /* @__PURE__ */ new Map([
+      [
+        "namespace",
+        new FunctionValue((args) => {
+          if (args.length === 0) {
+            return new ObjectValue(/* @__PURE__ */ new Map());
+          }
+          if (args.length !== 1 || !(args[0] instanceof ObjectValue)) {
+            throw new Error("`namespace` expects either zero arguments or a single object argument");
+          }
+          return args[0];
+        })
+      ]
+    ]);
+    /**
+     * The tests available in this environment.
+     */
+    this.tests = /* @__PURE__ */ new Map([
+      ["boolean", (operand) => operand.type === "BooleanValue"],
+      ["callable", (operand) => operand instanceof FunctionValue],
+      [
+        "odd",
+        (operand) => {
+          if (operand.type !== "NumericValue") {
+            throw new Error(`Cannot apply test "odd" to type: ${operand.type}`);
+          }
+          return operand.value % 2 !== 0;
+        }
+      ],
+      [
+        "even",
+        (operand) => {
+          if (operand.type !== "NumericValue") {
+            throw new Error(`Cannot apply test "even" to type: ${operand.type}`);
+          }
+          return operand.value % 2 === 0;
+        }
+      ],
+      ["false", (operand) => operand.type === "BooleanValue" && !operand.value],
+      ["true", (operand) => operand.type === "BooleanValue" && operand.value],
+      ["number", (operand) => operand.type === "NumericValue"],
+      ["integer", (operand) => operand.type === "NumericValue" && Number.isInteger(operand.value)],
+      ["iterable", (operand) => operand instanceof ArrayValue || operand instanceof StringValue],
+      [
+        "lower",
+        (operand) => {
+          const str = operand.value;
+          return operand.type === "StringValue" && str === str.toLowerCase();
+        }
+      ],
+      [
+        "upper",
+        (operand) => {
+          const str = operand.value;
+          return operand.type === "StringValue" && str === str.toUpperCase();
+        }
+      ],
+      ["none", (operand) => operand.type === "NullValue"],
+      ["defined", (operand) => operand.type !== "UndefinedValue"],
+      ["undefined", (operand) => operand.type === "UndefinedValue"],
+      ["equalto", (a, b) => a.value === b.value]
+    ]);
+  }
+  /**
+   * Set the value of a variable in the current environment.
+   */
+  set(name, value) {
+    return this.declareVariable(name, convertToRuntimeValues(value));
+  }
+  declareVariable(name, value) {
+    if (this.variables.has(name)) {
+      throw new SyntaxError(`Variable already declared: ${name}`);
+    }
+    this.variables.set(name, value);
+    return value;
+  }
+  // private assignVariable(name: string, value: AnyRuntimeValue): AnyRuntimeValue {
+  // 	const env = this.resolve(name);
+  // 	env.variables.set(name, value);
+  // 	return value;
+  // }
+  /**
+   * Set variable in the current scope.
+   * See https://jinja.palletsprojects.com/en/3.0.x/templates/#assignments for more information.
+   */
+  setVariable(name, value) {
+    this.variables.set(name, value);
+    return value;
+  }
+  /**
+   * Resolve the environment in which the variable is declared.
+   * @param {string} name The name of the variable.
+   * @returns {Environment} The environment in which the variable is declared.
+   */
+  resolve(name) {
+    if (this.variables.has(name)) {
+      return this;
+    }
+    if (this.parent) {
+      return this.parent.resolve(name);
+    }
+    throw new Error(`Unknown variable: ${name}`);
+  }
+  lookupVariable(name) {
+    try {
+      return this.resolve(name).variables.get(name) ?? new UndefinedValue();
+    } catch {
+      return new UndefinedValue();
+    }
+  }
+};
+var Interpreter = class {
+  constructor(env) {
+    this.global = env ?? new Environment();
+  }
+  /**
+   * Run the program.
+   */
+  run(program) {
+    return this.evaluate(program, this.global);
+  }
+  /**
+   * Evaluates expressions following the binary operation type.
+   */
+  evaluateBinaryExpression(node, environment) {
+    const left = this.evaluate(node.left, environment);
+    switch (node.operator.value) {
+      case "and":
+        return left.__bool__().value ? this.evaluate(node.right, environment) : left;
+      case "or":
+        return left.__bool__().value ? left : this.evaluate(node.right, environment);
+    }
+    const right = this.evaluate(node.right, environment);
+    switch (node.operator.value) {
+      case "==":
+        return new BooleanValue(left.value == right.value);
+      case "!=":
+        return new BooleanValue(left.value != right.value);
+    }
+    if (left instanceof UndefinedValue || right instanceof UndefinedValue) {
+      throw new Error("Cannot perform operation on undefined values");
+    } else if (left instanceof NullValue || right instanceof NullValue) {
+      throw new Error("Cannot perform operation on null values");
+    } else if (left instanceof NumericValue && right instanceof NumericValue) {
+      switch (node.operator.value) {
+        case "+":
+          return new NumericValue(left.value + right.value);
+        case "-":
+          return new NumericValue(left.value - right.value);
+        case "*":
+          return new NumericValue(left.value * right.value);
+        case "/":
+          return new NumericValue(left.value / right.value);
+        case "%":
+          return new NumericValue(left.value % right.value);
+        case "<":
+          return new BooleanValue(left.value < right.value);
+        case ">":
+          return new BooleanValue(left.value > right.value);
+        case ">=":
+          return new BooleanValue(left.value >= right.value);
+        case "<=":
+          return new BooleanValue(left.value <= right.value);
+      }
+    } else if (left instanceof ArrayValue && right instanceof ArrayValue) {
+      switch (node.operator.value) {
+        case "+":
+          return new ArrayValue(left.value.concat(right.value));
+      }
+    } else if (right instanceof ArrayValue) {
+      const member = right.value.find((x) => x.value === left.value) !== void 0;
+      switch (node.operator.value) {
+        case "in":
+          return new BooleanValue(member);
+        case "not in":
+          return new BooleanValue(!member);
+      }
+    }
+    if (left instanceof StringValue || right instanceof StringValue) {
+      switch (node.operator.value) {
+        case "+":
+          return new StringValue(left.toString() + right.toString());
+      }
+    }
+    if (left instanceof StringValue && right instanceof StringValue) {
+      switch (node.operator.value) {
+        case "in":
+          return new BooleanValue(right.value.includes(left.value));
+        case "not in":
+          return new BooleanValue(!right.value.includes(left.value));
+      }
+    }
+    if (left instanceof StringValue && right instanceof ObjectValue) {
+      switch (node.operator.value) {
+        case "in":
+          return new BooleanValue(right.value.has(left.value));
+        case "not in":
+          return new BooleanValue(!right.value.has(left.value));
+      }
+    }
+    throw new SyntaxError(`Unknown operator "${node.operator.value}" between ${left.type} and ${right.type}`);
+  }
+  /**
+   * Evaluates expressions following the filter operation type.
+   */
+  evaluateFilterExpression(node, environment) {
+    const operand = this.evaluate(node.operand, environment);
+    if (node.filter.type === "Identifier") {
+      const filter = node.filter;
+      if (operand instanceof ArrayValue) {
+        switch (filter.value) {
+          case "list":
+            return operand;
+          case "first":
+            return operand.value[0];
+          case "last":
+            return operand.value[operand.value.length - 1];
+          case "length":
+            return new NumericValue(operand.value.length);
+          case "reverse":
+            return new ArrayValue(operand.value.reverse());
+          case "sort":
+            return new ArrayValue(
+              operand.value.sort((a, b) => {
+                if (a.type !== b.type) {
+                  throw new Error(`Cannot compare different types: ${a.type} and ${b.type}`);
+                }
+                switch (a.type) {
+                  case "NumericValue":
+                    return a.value - b.value;
+                  case "StringValue":
+                    return a.value.localeCompare(b.value);
+                  default:
+                    throw new Error(`Cannot compare type: ${a.type}`);
+                }
+              })
+            );
+          case "tojson":
+            return new StringValue(JSON.stringify(operand.value));
+          default:
+            throw new Error(`Unknown ArrayValue filter: ${filter.value}`);
+        }
+      } else if (operand instanceof StringValue) {
+        switch (filter.value) {
+          case "length":
+            return new NumericValue(operand.value.length);
+          case "upper":
+            return new StringValue(operand.value.toUpperCase());
+          case "lower":
+            return new StringValue(operand.value.toLowerCase());
+          case "title":
+            return new StringValue(titleCase(operand.value));
+          case "capitalize":
+            return new StringValue(operand.value.charAt(0).toUpperCase() + operand.value.slice(1));
+          case "trim":
+            return new StringValue(operand.value.trim());
+          case "trimStart":
+            return new StringValue(operand.value.trimStart());
+          case "trimEnd":
+            return new StringValue(operand.value.trimEnd());
+          default:
+            throw new Error(`Unknown StringValue filter: ${filter.value}`);
+        }
+      } else if (operand instanceof NumericValue) {
+        switch (filter.value) {
+          case "abs":
+            return new NumericValue(Math.abs(operand.value));
+          default:
+            throw new Error(`Unknown NumericValue filter: ${filter.value}`);
+        }
+      } else if (operand instanceof ObjectValue) {
+        switch (filter.value) {
+          case "items":
+            return new ArrayValue(
+              Array.from(operand.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value]))
+            );
+          case "length":
+            return new NumericValue(operand.value.size);
+          case "tojson":
+            return new StringValue(JSON.stringify(operand));
+          case "string":
+            return new StringValue(operand.toString());
+          default:
+            throw new Error(`Unknown ObjectValue filter: ${filter.value}`);
+        }
+      }
+      throw new Error(`Cannot apply filter "${filter.value}" to type: ${operand.type}`);
+    } else if (node.filter.type === "CallExpression") {
+      const filter = node.filter;
+      if (filter.callee.type !== "Identifier") {
+        throw new Error(`Unknown filter: ${filter.callee.type}`);
+      }
+      const filterName = filter.callee.value;
+      const filterFn = environment.lookupVariable(filterName);
+      if (filterFn instanceof FunctionValue) {
+        return filterFn.value([operand, ...filter.args.map((x) => this.evaluate(x, environment))], environment);
+      }
+      if (operand instanceof ArrayValue) {
+        switch (filterName) {
+          case "selectattr": {
+            if (operand.value.some((x) => !(x instanceof ObjectValue))) {
+              throw new Error("`selectattr` can only be applied to array of objects");
+            }
+            if (filter.args.some((x) => x.type !== "StringLiteral")) {
+              throw new Error("arguments of `selectattr` must be strings");
+            }
+            const [attr, testName, value] = filter.args.map((x) => this.evaluate(x, environment));
+            let testFunction;
+            if (testName) {
+              const test = environment.tests.get(testName.value);
+              if (!test) {
+                throw new Error(`Unknown test: ${testName.value}`);
+              }
+              testFunction = test;
+            } else {
+              testFunction = (...x) => x[0].__bool__().value;
+            }
+            const filtered = operand.value.filter((item) => {
+              const a = item.value.get(attr.value);
+              if (a) {
+                return testFunction(a, value);
+              }
+              return false;
+            });
+            return new ArrayValue(filtered);
+          }
+        }
+        throw new Error(`Unknown ArrayValue filter: ${filterName}`);
+      } else {
+        throw new Error(`Cannot apply filter "${filterName}" to type: ${operand.type}`);
+      }
+    }
+    throw new Error(`Unknown filter: ${node.filter.type}`);
+  }
+  /**
+   * Evaluates expressions following the test operation type.
+   */
+  evaluateTestExpression(node, environment) {
+    const operand = this.evaluate(node.operand, environment);
+    const test = environment.tests.get(node.test.value);
+    if (!test) {
+      throw new Error(`Unknown test: ${node.test.value}`);
+    }
+    const result = test(operand);
+    return new BooleanValue(node.negate ? !result : result);
+  }
+  /**
+   * Evaluates expressions following the unary operation type.
+   */
+  evaluateUnaryExpression(node, environment) {
+    const argument = this.evaluate(node.argument, environment);
+    switch (node.operator.value) {
+      case "not":
+        return new BooleanValue(!argument.value);
+      default:
+        throw new SyntaxError(`Unknown operator: ${node.operator.value}`);
+    }
+  }
+  evalProgram(program, environment) {
+    return this.evaluateBlock(program.body, environment);
+  }
+  evaluateBlock(statements, environment) {
+    let result = "";
+    for (const statement of statements) {
+      const lastEvaluated = this.evaluate(statement, environment);
+      if (lastEvaluated.type !== "NullValue" && lastEvaluated.type !== "UndefinedValue") {
+        result += lastEvaluated;
+      }
+    }
+    return new StringValue(result);
+  }
+  evaluateIdentifier(node, environment) {
+    return environment.lookupVariable(node.value);
+  }
+  evaluateCallExpression(expr, environment) {
+    const args = [];
+    const kwargs = /* @__PURE__ */ new Map();
+    for (const argument of expr.args) {
+      if (argument.type === "KeywordArgumentExpression") {
+        const kwarg = argument;
+        kwargs.set(kwarg.key.value, this.evaluate(kwarg.value, environment));
+      } else {
+        args.push(this.evaluate(argument, environment));
+      }
+    }
+    if (kwargs.size > 0) {
+      args.push(new ObjectValue(kwargs));
+    }
+    const fn = this.evaluate(expr.callee, environment);
+    if (fn.type !== "FunctionValue") {
+      throw new Error(`Cannot call something that is not a function: got ${fn.type}`);
+    }
+    return fn.value(args, environment);
+  }
+  evaluateSliceExpression(object, expr, environment) {
+    if (!(object instanceof ArrayValue || object instanceof StringValue)) {
+      throw new Error("Slice object must be an array or string");
+    }
+    const start = this.evaluate(expr.start, environment);
+    const stop = this.evaluate(expr.stop, environment);
+    const step = this.evaluate(expr.step, environment);
+    if (!(start instanceof NumericValue || start instanceof UndefinedValue)) {
+      throw new Error("Slice start must be numeric or undefined");
+    }
+    if (!(stop instanceof NumericValue || stop instanceof UndefinedValue)) {
+      throw new Error("Slice stop must be numeric or undefined");
+    }
+    if (!(step instanceof NumericValue || step instanceof UndefinedValue)) {
+      throw new Error("Slice step must be numeric or undefined");
+    }
+    if (object instanceof ArrayValue) {
+      return new ArrayValue(slice(object.value, start.value, stop.value, step.value));
+    } else {
+      return new StringValue(slice(Array.from(object.value), start.value, stop.value, step.value).join(""));
+    }
+  }
+  evaluateMemberExpression(expr, environment) {
+    const object = this.evaluate(expr.object, environment);
+    let property;
+    if (expr.computed) {
+      if (expr.property.type === "SliceExpression") {
+        return this.evaluateSliceExpression(object, expr.property, environment);
+      } else {
+        property = this.evaluate(expr.property, environment);
+      }
+    } else {
+      property = new StringValue(expr.property.value);
+    }
+    let value;
+    if (object instanceof ObjectValue) {
+      if (!(property instanceof StringValue)) {
+        throw new Error(`Cannot access property with non-string: got ${property.type}`);
+      }
+      value = object.value.get(property.value) ?? object.builtins.get(property.value);
+    } else if (object instanceof ArrayValue || object instanceof StringValue) {
+      if (property instanceof NumericValue) {
+        value = object.value.at(property.value);
+        if (object instanceof StringValue) {
+          value = new StringValue(object.value.at(property.value));
+        }
+      } else if (property instanceof StringValue) {
+        value = object.builtins.get(property.value);
+      } else {
+        throw new Error(`Cannot access property with non-string/non-number: got ${property.type}`);
+      }
+    } else {
+      if (!(property instanceof StringValue)) {
+        throw new Error(`Cannot access property with non-string: got ${property.type}`);
+      }
+      value = object.builtins.get(property.value);
+    }
+    return value instanceof RuntimeValue ? value : new UndefinedValue();
+  }
+  evaluateSet(node, environment) {
+    const rhs = this.evaluate(node.value, environment);
+    if (node.assignee.type === "Identifier") {
+      const variableName = node.assignee.value;
+      environment.setVariable(variableName, rhs);
+    } else if (node.assignee.type === "MemberExpression") {
+      const member = node.assignee;
+      const object = this.evaluate(member.object, environment);
+      if (!(object instanceof ObjectValue)) {
+        throw new Error("Cannot assign to member of non-object");
+      }
+      if (member.property.type !== "Identifier") {
+        throw new Error("Cannot assign to member with non-identifier property");
+      }
+      object.value.set(member.property.value, rhs);
+    } else {
+      throw new Error(`Invalid LHS inside assignment expression: ${JSON.stringify(node.assignee)}`);
+    }
+    return new NullValue();
+  }
+  evaluateIf(node, environment) {
+    const test = this.evaluate(node.test, environment);
+    return this.evaluateBlock(test.__bool__().value ? node.body : node.alternate, environment);
+  }
+  evaluateFor(node, environment) {
+    const scope = new Environment(environment);
+    const iterable = this.evaluate(node.iterable, scope);
+    if (!(iterable instanceof ArrayValue)) {
+      throw new Error(`Expected iterable type in for loop: got ${iterable.type}`);
+    }
+    let result = "";
+    for (let i = 0; i < iterable.value.length; ++i) {
+      const loop = /* @__PURE__ */ new Map([
+        ["index", new NumericValue(i + 1)],
+        ["index0", new NumericValue(i)],
+        ["revindex", new NumericValue(iterable.value.length - i)],
+        ["revindex0", new NumericValue(iterable.value.length - i - 1)],
+        ["first", new BooleanValue(i === 0)],
+        ["last", new BooleanValue(i === iterable.value.length - 1)],
+        ["length", new NumericValue(iterable.value.length)],
+        ["previtem", i > 0 ? iterable.value[i - 1] : new UndefinedValue()],
+        ["nextitem", i < iterable.value.length - 1 ? iterable.value[i + 1] : new UndefinedValue()]
+      ]);
+      scope.setVariable("loop", new ObjectValue(loop));
+      const current = iterable.value[i];
+      if (node.loopvar.type === "Identifier") {
+        scope.setVariable(node.loopvar.value, current);
+      } else if (node.loopvar.type === "TupleLiteral") {
+        const loopvar = node.loopvar;
+        if (current.type !== "ArrayValue") {
+          throw new Error(`Cannot unpack non-iterable type: ${current.type}`);
+        }
+        const c = current;
+        if (loopvar.value.length !== c.value.length) {
+          throw new Error(`Too ${loopvar.value.length > c.value.length ? "few" : "many"} items to unpack`);
+        }
+        for (let j = 0; j < loopvar.value.length; ++j) {
+          if (loopvar.value[j].type !== "Identifier") {
+            throw new Error(`Cannot unpack non-identifier type: ${loopvar.value[j].type}`);
+          }
+          scope.setVariable(loopvar.value[j].value, c.value[j]);
+        }
+      }
+      const evaluated = this.evaluateBlock(node.body, scope);
+      result += evaluated.value;
+    }
+    return new StringValue(result);
+  }
+  evaluate(statement, environment) {
+    if (statement === void 0)
+      return new UndefinedValue();
+    switch (statement.type) {
+      case "Program":
+        return this.evalProgram(statement, environment);
+      case "Set":
+        return this.evaluateSet(statement, environment);
+      case "If":
+        return this.evaluateIf(statement, environment);
+      case "For":
+        return this.evaluateFor(statement, environment);
+      case "NumericLiteral":
+        return new NumericValue(Number(statement.value));
+      case "StringLiteral":
+        return new StringValue(statement.value);
+      case "BooleanLiteral":
+        return new BooleanValue(statement.value);
+      case "ArrayLiteral":
+        return new ArrayValue(statement.value.map((x) => this.evaluate(x, environment)));
+      case "TupleLiteral":
+        return new TupleValue(statement.value.map((x) => this.evaluate(x, environment)));
+      case "ObjectLiteral": {
+        const mapping = /* @__PURE__ */ new Map();
+        for (const [key, value] of statement.value) {
+          const evaluatedKey = this.evaluate(key, environment);
+          if (!(evaluatedKey instanceof StringValue)) {
+            throw new Error(`Object keys must be strings: got ${evaluatedKey.type}`);
+          }
+          mapping.set(evaluatedKey.value, this.evaluate(value, environment));
+        }
+        return new ObjectValue(mapping, statement.value);
+      }
+      case "Identifier":
+        return this.evaluateIdentifier(statement, environment);
+      case "CallExpression":
+        return this.evaluateCallExpression(statement, environment);
+      case "MemberExpression":
+        return this.evaluateMemberExpression(statement, environment);
+      case "UnaryExpression":
+        return this.evaluateUnaryExpression(statement, environment);
+      case "BinaryExpression":
+        return this.evaluateBinaryExpression(statement, environment);
+      case "FilterExpression":
+        return this.evaluateFilterExpression(statement, environment);
+      case "TestExpression":
+        return this.evaluateTestExpression(statement, environment);
+      default:
+        throw new SyntaxError(`Unknown node type: ${statement.type}`);
+    }
+  }
+};
+function convertToRuntimeValues(input) {
+  switch (typeof input) {
+    case "number":
+      return new NumericValue(input);
+    case "string":
+      return new StringValue(input);
+    case "boolean":
+      return new BooleanValue(input);
+    case "object":
+      if (input === null) {
+        return new NullValue();
+      } else if (Array.isArray(input)) {
+        return new ArrayValue(input.map(convertToRuntimeValues));
+      } else {
+        return new ObjectValue(
+          new Map(Object.entries(input).map(([key, value]) => [key, convertToRuntimeValues(value)])),
+          input
+        );
+      }
+    case "function":
+      return new FunctionValue((args, _scope) => {
+        const _args = args.map((arg) => {
+          return parseRuntimeValue(arg);
+        });
+        const result = input(..._args) ?? null;
+        return convertToRuntimeValues(result);
+      });
+    default:
+      throw new Error(`Cannot convert to runtime value: ${input}`);
+  }
+}
+function parseRuntimeValue(arg) {
+  let result = arg;
+  if (Array.isArray(arg)) {
+    result = arg.map((item) => parseRuntimeValue(item));
+  } else if (arg instanceof Map) {
+    result = {};
+    arg.forEach((item, key) => {
+      result[key] = parseRuntimeValue(item);
+    });
+  } else if (arg.type === "ObjectValue") {
+    if (arg.orgValue) {
+      result = arg.orgValue;
+    } else {
+      result = {};
+      arg.forEach((item, key) => {
+        result[key] = parseRuntimeValue(item);
+      });
+    }
+  } else if (arg.type === "ArrayValue") {
+    result = arg.value.map((item) => parseRuntimeValue(item));
+  } else if (arg.type) {
+    result = arg.value;
+  }
+  return result;
+}
+
+// src/utils/prompt/template/jinja/src/builtins.ts
+function randomInt(to, from = 0) {
+  return Math.floor(Math.random() * (to - from + 1)) + from;
+}
+function select(obj, index) {
+  if (Array.isArray(obj) || typeof obj === "string") {
+    if (index === void 0) {
+      index = randomInt(obj.length - 1);
+    } else if (typeof index === "string") {
+      index = parseInt(index);
+    }
+    if (index < 0) {
+      index = obj.length + index;
+    }
+    return obj[index];
+  } else if (obj && typeof obj === "object") {
+    if (index === void 0) {
+      const keys = Object.keys(obj);
+      index = keys[randomInt(keys.length - 1)];
+    }
+    return obj[index];
+  }
+}
+var builtins = {
+  randomInt,
+  select
+};
+
+// src/utils/prompt/template/jinja/src/index.ts
+var EnvironmentEx = class extends Environment {
+  constructor(parent) {
+    super(parent);
+    this.parent = parent;
+  }
+  assign(items) {
+    for (const [key, value] of Object.entries(items)) {
+      this.set(key, value);
+    }
+  }
+  clear() {
+    this.variables.clear();
+  }
+};
+var Template = class _Template {
+  static {
+    this.global = new EnvironmentEx();
+  }
+  /**
+   * @param {string} template The template string
+   */
+  constructor(template, options = {}) {
+    options = {
+      lstrip_blocks: true,
+      trim_blocks: true,
+      ...options
+    };
+    const tokens = tokenize(template, options);
+    this.parsed = parse(tokens);
+  }
+  render(items) {
+    const env = new Environment(_Template.global);
+    env.set("false", false);
+    env.set("true", true);
+    env.set("raise_exception", (args) => {
+      throw new Error(args);
+    });
+    env.set("range", range);
+    for (const [key, value] of Object.entries(items)) {
+      env.set(key, value);
+    }
+    const interpreter = new Interpreter(env);
+    const result = interpreter.run(this.parsed);
+    return result.toString();
+  }
+};
+Template.global.assign(builtins);
+
+// src/utils/prompt/hf-prompt-template.ts
+function getVariable(statement, internalVars) {
+  let result;
+  switch (statement.type) {
+    case "Identifier": {
+      result = statement.value;
+      break;
+    }
+    case "MemberExpression": {
+      result = getVariable(statement.object, internalVars);
+      break;
+    }
+    case "FilterExpression": {
+      result = getVariable(statement.operand, internalVars);
+      break;
+    }
+    case "Set": {
+      if (!internalVars) {
+        internalVars = [];
+      }
+      const assignee = getVariable(statement.assignee);
+      if (assignee) {
+        internalVars.push(assignee);
+      }
+      result = getVariable(statement.value, internalVars);
+      break;
+    }
+  }
+  if (result && internalVars?.includes(result)) {
+    result = void 0;
+  }
+  return result;
+}
+function isTemplate(statement) {
+  let result;
+  switch (statement.type) {
+    case "Program": {
+      result = statement.body.some((item) => isTemplate(item));
+      break;
+    }
+    default: {
+      result = statement.isStatement;
+    }
+  }
+  return result;
+}
+function getVariables(statement, internalVars) {
+  let result = [];
+  if (Array.isArray(statement)) {
+    result = statement.map((item) => getVariables(item, internalVars)).filter(Boolean).flat();
+  } else {
+    switch (statement.type) {
+      case "Program": {
+        result = statement.body.map((item) => getVariables(item, internalVars)).filter(Boolean).flat();
+        break;
+      }
+      case "If": {
+        result = [getVariable(statement.test, internalVars), ...getVariables(statement.body, internalVars), ...getVariables(statement.alternate, internalVars)].filter(Boolean);
+        break;
+      }
+      case "BinaryExpression": {
+        result = [getVariable(statement.left, internalVars), getVariable(statement.right, internalVars)].filter(Boolean);
+        break;
+      }
+      case "For": {
+        const loopVar = getVariable(statement.loopvar);
+        if (loopVar) {
+          if (!internalVars) {
+            internalVars = [];
+          }
+          internalVars.push(loopVar);
+        }
+        result = [getVariable(statement.iterable, internalVars), ...getVariables(statement.body, internalVars)].filter(Boolean);
+        break;
+      }
+      case "CallExpression": {
+        result = [getVariable(statement.callee, internalVars), ...getVariables(statement.args, internalVars)].filter(Boolean);
+        break;
+      }
+      default: {
+        result = [getVariable(statement, internalVars)].filter(Boolean);
+      }
+    }
+  }
+  return result;
+}
+var HfPromptTemplate = class extends PromptTemplate {
+  static isTemplate(templateOpt) {
+    let compiledTemplate;
+    let template;
+    let result = false;
+    if (typeof templateOpt === "object") {
+      template = templateOpt.template;
+      compiledTemplate = templateOpt.compiledTemplate;
+    } else {
+      template = templateOpt;
+    }
+    if (!compiledTemplate && template) {
+      try {
+        compiledTemplate = new Template(template);
+      } catch (error) {
+      }
+    }
+    if (compiledTemplate) {
+      result = isTemplate(compiledTemplate.parsed);
+    }
+    return result;
+  }
+  getVariables(template = this.compiledTemplate) {
+    const internalVars = [];
+    const result = getVariables(template.parsed, internalVars).filter((item, index, self) => self.indexOf(item) === index);
+    return result;
+  }
+  _initialize(options) {
+    const template = options?.template;
+    if (typeof template !== "string") {
+      throw new CommonError("Prompt template must be a string", "PromptTemplate", 400 /* InvalidArgument */);
+    }
+    this.compiledTemplate = new Template(template);
+    this.inputVariables = Array.isArray(options?.inputVariables) ? options.inputVariables : this.getVariables();
+  }
+  _format(data) {
+    return this.compiledTemplate.render(data);
+  }
+};
+PromptTemplate.register(HfPromptTemplate, { name: "hf", aliases: ["huggingface", "internal", "default"] });
+function createHfValueFunc(fn) {
+  return function(_data) {
+    return fn;
+  };
+}
+
+// src/utils/prompt/template/python.ts
+function parseFString(template) {
+  const chars = template.split("");
+  const nodes = [];
+  const nextBracket = (bracket, start) => {
+    for (let i2 = start; i2 < chars.length; i2 += 1) {
+      if (bracket.includes(chars[i2])) {
+        return i2;
+      }
+    }
+    return -1;
+  };
+  let i = 0;
+  while (i < chars.length) {
+    if (chars[i] === "{" && i + 1 < chars.length && chars[i + 1] === "{") {
+      nodes.push({ type: "literal", text: "{" });
+      i += 2;
+    } else if (chars[i] === "}" && i + 1 < chars.length && chars[i + 1] === "}") {
+      nodes.push({ type: "literal", text: "}" });
+      i += 2;
+    } else if (chars[i] === "{") {
+      const j = nextBracket("}", i);
+      if (j < 0) {
+        throw new Error("Unclosed '{' in template.");
+      }
+      nodes.push({
+        type: "variable",
+        name: chars.slice(i + 1, j).join("")
+      });
+      i = j + 1;
+    } else if (chars[i] === "}") {
+      throw new Error("Single '}' in template.");
+    } else {
+      const next = nextBracket("{}", i);
+      const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join("");
+      nodes.push({ type: "literal", text });
+      i = next < 0 ? chars.length : next;
+    }
+  }
+  return nodes;
+}
+function interpolateFString(nodes, values) {
+  return nodes.reduce((res, node) => {
+    let result;
+    if (node.type === "variable") {
+      if (node.name in values) {
+        result = res + values[node.name];
+      } else {
+        result = res;
+      }
+    } else {
+      result = res + node.text;
+    }
+    return result;
+  }, "");
+}
+
+// src/utils/prompt/f-string-prompt-template.ts
+function getVariables2(template) {
+  const result = /* @__PURE__ */ new Set();
+  template.forEach((node) => {
+    if (node.type === "variable") {
+      result.add(node.name);
+    }
+  });
+  return [...result];
+}
+var FStringPromptTemplate = class extends PromptTemplate {
+  static isTemplate(templateOpt) {
+    let compiledTemplate;
+    let template;
+    let result = false;
+    if (typeof templateOpt === "object") {
+      template = templateOpt.template;
+      compiledTemplate = templateOpt.compiledTemplate;
+    } else {
+      template = templateOpt;
+    }
+    if (!compiledTemplate && template) {
+      try {
+        compiledTemplate = parseFString(template);
+      } catch (_err) {
+      }
+    }
+    if (compiledTemplate) {
+      const vars = getVariables2(compiledTemplate);
+      result = vars.length > 0;
+    }
+    return result;
+  }
+  getVariables(template = this.compiledTemplate) {
+    return getVariables2(template);
+  }
+  _initialize(options) {
+    const template = options?.template;
+    if (typeof template !== "string") {
+      throw new CommonError("Prompt template must be a string", "PromptTemplate", 400 /* InvalidArgument */);
+    }
+    this.compiledTemplate = parseFString(template);
+    this.inputVariables = Array.isArray(options?.inputVariables) ? options.inputVariables : this.getVariables();
+  }
+  _format(data) {
+    return interpolateFString(this.compiledTemplate, data);
+  }
+};
+PromptTemplate.register(FStringPromptTemplate, { name: "fstring", aliases: ["python", "f-string", "langchain"] });
+
+// src/utils/prompt/template/util.ts
+function getValueByPath(object, path4) {
+  if (typeof path4 === "string") {
+    path4 = path4.split(".").filter((key) => key.length);
+  }
+  return path4.reduce((dive, key) => dive?.[key], object);
+}
+
+// src/utils/prompt/template/golang.ts
+function reReplace(template, variables, initVars) {
+  const regex = /{{\s*re_replace\s+\.(.+?)\s+(["'])([^\2]*?)\2\s+(["'])([^\4]*?)\4\s*}}/g;
+  return template.replace(regex, (match, prop, _regDelimiter, regexp2, _newValueDelimiter, newValue) => {
+    if (initVars) {
+      variables[prop] = null;
+      return match;
+    }
+    const replaceRegex = new RegExp(regexp2, "g");
+    const input = getValueByPath(variables, prop);
+    const expanded = input.replace(replaceRegex, newValue);
+    return expanded;
+  });
+}
+function joinReplace(template, variables, initVars) {
+  const regex = /{{\s*join\s+\.(.+?)\s+(["'])([^\2]*?)\2\s*}}/g;
+  return template.replace(regex, (match, prop, _quote, delimiter) => {
+    if (initVars) {
+      variables[prop] = null;
+      return match;
+    }
+    const input = getValueByPath(variables, prop);
+    const expanded = input.join(delimiter);
+    return expanded;
+  });
+}
+function ifElseReplace(template, variables, initVars) {
+  const regex = /{{\s*if\s*(\S+?)\s*}}([^{]*)({{\s*else\s*}}([^{]*))?{{\s*end\s*}}/g;
+  return template.replace(regex, (match, condition, onTrue, _elseMarker, onFalse) => {
+    if (initVars) {
+      if (condition.startsWith(".")) {
+        condition = condition.substring(1);
+      }
+      variables[condition] = null;
+      return match;
+    }
+    let conditionResult;
+    if (condition.startsWith(".")) {
+      const value = getValueByPath(variables, condition.substring(1));
+      if (value === null || value === void 0) {
+        conditionResult = onFalse ?? "";
+      } else if (typeof value === "string") {
+        conditionResult = value.length > 0 ? onTrue : onFalse ?? "";
+      } else if (Array.isArray(value)) {
+        conditionResult = value.length > 0 ? onTrue : onFalse ?? "";
+      } else if (typeof value === "boolean") {
+        conditionResult = value ? onTrue : onFalse ?? "";
+      } else {
+        throw new Error(`Unexpected type for variable ${condition}: ${typeof value}`);
+      }
+    } else {
+      throw new Error("Functionality not implemented");
+    }
+    return conditionResult;
+  });
+}
+function rangeReplace(template, variables, initVars) {
+  const regex = /{{\s*range\s*[.$]([^{}\s]+?)\s*}}([^{]*?){{\.}}([^{]*?){{\s*end\s*}}/g;
+  return template.replace(regex, (match, prop, prefix, postfix) => {
+    if (initVars) {
+      variables[prop] = null;
+      return match;
+    }
+    const arr = getValueByPath(variables, prop);
+    if (Array.isArray(arr)) {
+      let expanded = "";
+      for (const value of arr) {
+        expanded += `${prefix}${value}${postfix}`;
+      }
+      return expanded;
+    }
+    return match;
+  });
+}
+function variableReplace(template, variables, initVars) {
+  const regex = /{{\s*\.([^{}\s]+?)\s*}}/g;
+  return template.replace(regex, (match, key) => {
+    if (initVars) {
+      variables[key] = null;
+      return match;
+    }
+    return getValueByPath(variables, key) || "";
+  });
+}
+function indexReplace(template, variables, initVars) {
+  const regex = /{{\s*index\s*\.(.+?)\s+(.+?)\s*}}/g;
+  return template.replace(regex, (match, prop, index) => {
+    if (initVars) {
+      variables[prop] = null;
+      return match;
+    }
+    const top = getValueByPath(variables, prop);
+    let value;
+    if (!isNaN(index)) {
+      value = top[parseInt(index, 10)];
+    } else {
+      const quotedIndex = index.substring(1, index.length - 1);
+      value = top[quotedIndex];
+    }
+    return value || "";
+  });
+}
+function interpolateGolangTemplate(str, variables, initVars) {
+  let result = reReplace(str, variables, initVars);
+  result = joinReplace(result, variables, initVars);
+  result = ifElseReplace(result, variables, initVars);
+  result = rangeReplace(result, variables, initVars);
+  result = variableReplace(result, variables, initVars);
+  result = indexReplace(result, variables, initVars);
+  return result;
+}
+
+// src/utils/prompt/golang-prompt-template.ts
+var GolangPromptTemplate = class extends PromptTemplate {
+  static isTemplate(templateOpt) {
+    const template = typeof templateOpt === "string" ? templateOpt : templateOpt.template;
+    return template?.includes("{{") && template.includes("}}");
+  }
+  getVariables(template) {
+    const result = {};
+    interpolateGolangTemplate(template, result, true);
+    return [...Object.keys(result)];
+  }
+  _initialize(options) {
+    const template = options?.template;
+    if (typeof template !== "string") {
+      throw new CommonError("Prompt template must be a string", "PromptTemplate", 400 /* InvalidArgument */);
+    }
+    this.inputVariables = Array.isArray(options?.inputVariables) ? options.inputVariables : this.getVariables(template);
+  }
+  _format(data) {
+    return interpolateGolangTemplate(this.template, data);
+  }
+};
+PromptTemplate.register(GolangPromptTemplate, { name: "golang", aliases: ["localai", "ollama"] });
+
+// src/utils/prompt/few-shot-prompt-template.ts
+function sortedValues(values) {
+  return Object.keys(values).sort().map((key) => values[key]);
+}
+var FewShotPromptTemplate = class extends PromptTemplate {
+  static from(options) {
+    return new this(options);
+  }
+  constructor(options) {
+    super(options);
+  }
+  _initialize(options) {
+    if (options) {
+      if (options.suffix) {
+        this.suffix = options.suffix;
+      }
+      if (options.exampleSeparator) {
+        this.exampleSeparator = options.exampleSeparator;
+      }
+      if (options.prefix) {
+        this.prefix = options.prefix;
+      }
+      if (options.examplePrompt) {
+        this.examplePrompt = options.examplePrompt instanceof PromptTemplate ? options.examplePrompt : PromptTemplate.from(options.examplePrompt);
+      }
+      if (options.examples) {
+        this.examples = options.examples;
+      }
+    }
+    if (!this.prefix) {
+      this.prefix = "";
+    }
+    if (!this.exampleSeparator) {
+      this.exampleSeparator = "\n\n";
+    }
+    if (!this.suffix) {
+      this.suffix = "";
+    }
+  }
+  async _format(data) {
+    const exampleStrings = [];
+    for await (const example of this.examples) {
+      if (this.examplePrompt) {
+        const ex = await this.examplePrompt.format(example);
+        exampleStrings.push(ex);
+      } else {
+        if (typeof example === "string") {
+          exampleStrings.push(example);
+        } else if (example) {
+          const ex = sortedValues(example);
+          if (ex.length > 0) {
+            exampleStrings.push(...ex);
+          }
+        }
+      }
+    }
+    const template = [this.prefix, ...exampleStrings, this.suffix].join(
+      this.exampleSeparator
+    );
+    const templateFormat = this.templateFormat;
+    const result = await PromptTemplate.format({ template, data, templateFormat });
+    return result;
+  }
+  toJSON(options = this) {
+    const result = super.toJSON(options);
+    if (options.suffix) {
+      result.suffix = options.suffix;
+    }
+    if (options.exampleSeparator) {
+      result.exampleSeparator = options.exampleSeparator;
+    }
+    if (options.prefix) {
+      result.prefix = options.prefix;
+    }
+    if (options.examplePrompt) {
+      result.examplePrompt = options.examplePrompt;
+    }
+    if (options.examples) {
+      result.examples = options.examples;
+    }
+    return result;
+  }
+};
+PromptTemplate.register(FewShotPromptTemplate, { name: "fewshot", aliases: ["few_shot"] });
+
+// src/utils/prompt/template/env.ts
+var DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+function _resolveEscapeSequences(value) {
+  return value.replace(/\\\$/g, "$");
+}
+function interpolateEnv(value, processEnv, parsed) {
+  return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
+    if (escaped === "\\") {
+      return match.slice(1);
+    } else {
+      if (processEnv[key]) {
+        if (processEnv[key] === parsed[key]) {
+          return processEnv[key];
+        } else {
+          return interpolateEnv(processEnv[key], processEnv, parsed);
+        }
+      }
+      if (parsed[key]) {
+        if (parsed[key] === value) {
+          return parsed[key];
+        } else {
+          return interpolateEnv(parsed[key], processEnv, parsed);
+        }
+      }
+      if (defaultValue) {
+        if (defaultValue.startsWith("$")) {
+          return interpolateEnv(defaultValue, processEnv, parsed);
+        } else {
+          return defaultValue;
+        }
+      }
+      return "";
+    }
+  });
+}
+function expandEnv(options) {
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+  for (const key in options.parsed) {
+    let value = options.parsed[key];
+    if (!value) {
+      continue;
+    }
+    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key);
+    if (inProcessEnv) {
+      if (processEnv[key] === options.parsed[key]) {
+        value = interpolateEnv(value, processEnv, options.parsed);
+      } else {
+        value = processEnv[key];
+      }
+    } else {
+      value = interpolateEnv(value, processEnv, options.parsed);
+    }
+    options.parsed[key] = value ? _resolveEscapeSequences(value) : value;
+  }
+  for (const processKey in options.parsed) {
+    processEnv[processKey] = options.parsed[processKey];
+  }
+  return options;
+}
+function expandObjEnv(obj, options = {}, parsedObjs) {
+  if (!parsedObjs) {
+    parsedObjs = /* @__PURE__ */ new WeakSet();
+  }
+  if (!options.processEnv) {
+    options.processEnv = { ...process.env };
+  }
+  if (!options.parsed) {
+    options.parsed = options.processEnv;
+  }
+  switch (typeof obj) {
+    case "string": {
+      const processEnv = options.processEnv;
+      obj = interpolateEnv(obj, processEnv, options.parsed);
+      break;
+    }
+    case "object": {
+      if (parsedObjs.has(obj)) {
+        return obj;
+      }
+      parsedObjs.add(obj);
+      if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+          const value = obj[i];
+          if (typeof value === "string" || typeof value === "object") {
+            obj[i] = expandObjEnv(obj[i], options, parsedObjs);
+          }
+        }
+      } else {
+        for (const [key, value] of Object.entries(obj)) {
+          if (typeof value === "string" || typeof value === "object") {
+            obj[key] = expandObjEnv(value, options, parsedObjs);
+          }
+        }
+      }
+      break;
+    }
+  }
+  return obj;
+}
+
+// src/utils/wait.ts
+async function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/stream/error-readable-stream.ts
+var RStreamErrCode = 600;
+var ResponseRStreamErrCode = 601;
+var ReadableStreamError = class extends BaseError {
+  constructor(msg, code = RStreamErrCode) {
+    super(msg, 500);
+  }
+};
+function getResponseErrorReadableStream(body) {
+  if (body) {
+    const reader = body.getReader();
+    return new ReadableStream({
+      async start(controller) {
+        const { done, value } = await reader.read();
+        if (!done) {
+          const errorText = new TextDecoder().decode(value);
+          controller.error(new ReadableStreamError(`Response error: ${errorText}`, ResponseRStreamErrCode));
+        }
+      }
+    });
+  } else {
+    return new ReadableStream({
+      start(controller) {
+        controller.error(new ReadableStreamError("Response error: No response body", ResponseRStreamErrCode));
+      }
+    });
+  }
+}
+
+// src/utils/stream/create-empty-stream.ts
+function createEmptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+
+// src/utils/stream/ai-stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+function createEventStreamTransformer(customParser) {
+  const textDecoder = new TextDecoder();
+  let eventSourceParser;
+  return new TransformStream({
+    async start(controller) {
+      eventSourceParser = (0, import_eventsource_parser.createParser)(
+        (event2) => {
+          if ("data" in event2 && event2.type === "event" && event2.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
+          // @see https://replicate.com/docs/streaming
+          event2.event === "done") {
+            controller.terminate();
+            return;
+          }
+          if ("data" in event2) {
+            const parsedMessage = customParser ? customParser(event2.data, {
+              event: event2.event
+            }) : event2.data;
+            if (parsedMessage)
+              controller.enqueue(parsedMessage);
+          }
+        }
+      );
+    },
+    transform(chunk) {
+      eventSourceParser.feed(textDecoder.decode(chunk));
+    }
+  });
+}
+function createCallbacksTransformer(cb) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  const callbacks = cb || {};
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      const content = typeof message === "string" ? message : message.content;
+      controller.enqueue(textEncoder.encode(content));
+      aggregatedResponse += content;
+      if (callbacks.onToken)
+        await callbacks.onToken(content);
+      if (callbacks.onText && typeof message === "string") {
+        await callbacks.onText(message);
+      }
+    },
+    async flush() {
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+      if (callbacks.onFinal) {
+        await callbacks.onFinal(aggregatedResponse);
+      }
+    }
+  });
+}
+function trimStartOfStreamHelper() {
+  let isStreamStart = true;
+  return (text) => {
+    if (isStreamStart) {
+      text = text.trimStart();
+      if (text)
+        isStreamStart = false;
+    }
+    return text;
+  };
+}
+function AIStream(response, customParser) {
+  if (!response.ok) {
+    return getResponseErrorReadableStream(response.body);
+  }
+  let responseBodyStream = response.body || createEmptyReadableStream2();
+  if (!(responseBodyStream instanceof ReadableStream)) {
+    responseBodyStream = ReadableStream.from(responseBodyStream);
+  }
+  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser));
+}
+function createEmptyReadableStream2() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function readableFromAsyncIterable(iterable) {
+  let it = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await it.next();
+      if (done)
+        controller.close();
+      else
+        controller.enqueue(value);
+    },
+    async cancel(reason) {
+      await it.return?.(reason);
+    }
+  });
+}
+
+// src/utils/hash/index.ts
+var hash_exports = {};
+__export(hash_exports, {
+  XXHashAlgorithm: () => XXHashAlgorithm,
+  base32768: () => base327682,
+  uuid: () => uuid,
+  uuidNIL: () => import_uuid2.NIL,
+  uuidParse: () => import_uuid2.parse,
+  uuidStringify: () => import_uuid2.stringify,
+  uuidValidate: () => import_uuid2.validate,
+  uuidVersion: () => import_uuid2.version,
+  uuidv1: () => import_uuid2.v1,
+  uuidv4: () => import_uuid2.v4,
+  uuidv5: () => import_uuid2.v5,
+  xxhash: () => xxhash,
+  xxhash32: () => xxhash32,
+  xxhash64: () => xxhash64,
+  xxhashAsStr: () => xxhashAsStr
+});
+
+// src/utils/hash/uuid.ts
+var import_uuid = require("uuid");
+var base32768 = __toESM(require("base32768"));
+var import_uuid2 = require("uuid");
+var uuids = { 1: import_uuid.v1, 4: import_uuid.v4, 5: import_uuid.v5 };
+function uuid(ver = 1, encode3) {
+  const exec = uuids[ver];
+  return encode3 ? base32768.encode(exec(null, [])) : exec();
+}
+
+// src/utils/hash/xxhash.ts
+var xxhash_exports = {};
+__export(xxhash_exports, {
+  XXHashAlgorithm: () => XXHashAlgorithm,
+  base32768: () => base327682,
+  xxhash: () => xxhash,
+  xxhash32: () => xxhash32,
+  xxhash64: () => xxhash64,
+  xxhashAsStr: () => xxhashAsStr
+});
+var import_xxhashjs = __toESM(require("xxhashjs"));
+var _base32768 = __toESM(require("base32768"));
+var import_json_canonicalize = require("json-canonicalize");
+__reExport(xxhash_exports, require("json-canonicalize"));
+var base327682 = _base32768;
+var { h32, h64 } = import_xxhashjs.default;
+var SEED = 588213;
+function xxhash32(value, radix = 16) {
+  if (typeof value === "object") {
+    value = (0, import_json_canonicalize.canonicalize)(value);
+  }
+  return h32(value, SEED).toString(radix);
+}
+function xxhash64(value, radix = 16) {
+  if (typeof value === "object") {
+    value = (0, import_json_canonicalize.canonicalize)(value);
+  }
+  return h64(value, SEED).toString(radix);
+}
+var XXHashAlgorithm = /* @__PURE__ */ ((XXHashAlgorithm2) => {
+  XXHashAlgorithm2[XXHashAlgorithm2["xxhash64"] = 111] = "xxhash64";
+  XXHashAlgorithm2[XXHashAlgorithm2["xxhash32"] = 112] = "xxhash32";
+  return XXHashAlgorithm2;
+})(XXHashAlgorithm || {});
+function xxhash(value, hashAlgo = 111 /* xxhash64 */, seed = SEED) {
+  if (value.buffer)
+    value = value.buffer;
+  let result;
+  if (hashAlgo !== 112 /* xxhash32 */) {
+    result = h64(value, seed);
+    result = new Uint16Array([result._a00, result._a16, result._a32, result._a48]);
+    result = new Uint8Array(result.buffer);
+  } else {
+    result = h32(value, seed);
+    result = new Uint16Array([result._low, result._high]);
+    result = new Uint8Array(result.buffer);
+  }
+  return result;
+}
+function xxhashAsStr(value, hashAlgo = 111 /* xxhash64 */, seed = SEED) {
+  return _base32768.encode(xxhash(value, hashAlgo, seed));
+}
+
+// src/utils/hash/index.ts
+__reExport(hash_exports, xxhash_exports);
+
+// src/utils/index.ts
+__reExport(utils_exports, hash_exports);
+
+// src/utils/filename.ts
+var import_path = __toESM(require("path"));
+var FilenameReservedRegex = /[<>:"/\\|?*\u0000-\u001F]/;
+var WindowsReservedNameRegex = /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+var MAX_FILENAME_LENGTH = 100;
+var ReRelativePathRegex = /^\.+(\\|\/)|^\.+$/;
+var ReTrailingPeriodsRegex = /\.+$/;
+var ReControlCharsRegex = /[\u0000-\u001F\u0080-\u009F\u200E\u200F\u202A-\u202E\u2066-\u2069]/;
+function filenameReservedRegex() {
+  return new RegExp(FilenameReservedRegex.source, "g");
+}
+function reControlCharsRegex() {
+  return new RegExp(ReControlCharsRegex.source, "g");
+}
+function isValidFilename(filename) {
+  return filename && !(FilenameReservedRegex.test(filename) || reControlCharsRegex().test(filename) || ReRelativePathRegex.test(filename) || ReTrailingPeriodsRegex.test(filename));
+}
+function isValidFilepath(filepath) {
+  const parts = filepath.split(import_path.default.sep);
+  if (filepath[0] === "/" || parts[0] && import_path.default.dirname(parts[0]) === parts[0]) {
+    parts.shift();
+  }
+  return parts.every(isValidFilename);
+}
+function sanitizeFilename(filename, options = {}) {
+  const replacement = options.replacement || "!";
+  if (FilenameReservedRegex.test(replacement) || ReControlCharsRegex.test(replacement)) {
+    throwError2("Replacement string cannot contain reserved filename characters", "sanitizeFilename", 400 /* InvalidArgument */);
+  }
+  if (replacement.length > 0) {
+    const ReRepeatedReservedCharactersRegex = /([<>:"/\\|?*\u0000-\u001F]){2,}/;
+    filename = filename.replace(ReRepeatedReservedCharactersRegex, "$1");
+  }
+  filename = filename.normalize("NFD");
+  filename = filename.replace(ReRelativePathRegex, replacement);
+  filename = filename.replace(filenameReservedRegex(), replacement);
+  filename = filename.replace(reControlCharsRegex(), replacement);
+  filename = filename.replace(ReTrailingPeriodsRegex, "");
+  if (replacement.length > 0) {
+    const startedWithDot = filename[0] === ".";
+    if (!startedWithDot && filename[0] === ".") {
+      filename = replacement + filename;
+    }
+    if (filename[filename.length - 1] === ".") {
+      filename += replacement;
+    }
+  }
+  filename = WindowsReservedNameRegex.test(filename) ? filename + replacement : filename;
+  const allowedLength = typeof options.maxLength === "number" ? options.maxLength : MAX_FILENAME_LENGTH;
+  if (filename.length > allowedLength) {
+    const extensionIndex = filename.lastIndexOf(".");
+    if (extensionIndex === -1) {
+      filename = filename.slice(0, allowedLength);
+    } else {
+      const str = filename.slice(0, extensionIndex);
+      const extension = filename.slice(extensionIndex);
+      filename = str.slice(0, Math.max(1, allowedLength - extension.length)) + extension;
+    }
+  }
+  return filename;
+}
+function sanitizeFilepath(filepath, options = {}) {
+  const parts = filepath.split(import_path.default.sep);
+  let root;
+  if (filepath[0] === "/" || parts[0] && import_path.default.dirname(parts[0]) === parts[0]) {
+    root = parts.shift();
+  }
+  const result = parts.map((p) => sanitizeFilename(p, options));
+  if (root !== void 0) {
+    result.unshift(root);
+  }
+  return result.join(import_path.default.sep);
+}
+function getMultiLevelExtname(filename, level = 1) {
+  let result = "";
+  while (level--) {
+    const extname = import_path.default.extname(filename);
+    if (extname) {
+      result = extname + result;
+      filename = import_path.default.basename(filename, extname);
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function extNameLevel(extName) {
+  return extName.split(".").length - 1;
+}
+
+// src/utils/is-model-name-matched.ts
+var import_util_ex2 = require("util-ex");
+function isModelNameMatched(modelName, rule) {
+  if (typeof modelName !== "string") {
+    throw new CommonError("modelName must be a string", "isModelNameMatched", 400 /* InvalidArgument */);
+  }
+  switch (typeof rule) {
+    case "string":
+      if ((0, import_util_ex2.isRegExpStr)(rule)) {
+        rule = (0, import_util_ex2.toRegExp)(rule);
+        const match = rule.exec(modelName);
+        if (match) {
+          return match;
+        }
+      } else if (modelName.toLowerCase() === rule.toLowerCase()) {
+        return rule;
+      }
+      break;
+    case "object":
+      if (Array.isArray(rule)) {
+        for (const item of rule) {
+          if (typeof item === "string") {
+            if ((0, import_util_ex2.isRegExpStr)(item)) {
+              rule = (0, import_util_ex2.toRegExp)(item);
+              const match = rule.exec(modelName);
+              if (match) {
+                return match;
+              }
+            } else if (modelName.toLowerCase() === item.toLowerCase()) {
+              return item;
+            }
+          } else if (item instanceof RegExp) {
+            const match = item.exec(modelName);
+            if (match) {
+              return match;
+            }
+          } else if (typeof item === "function") {
+            const result2 = item.call(this, modelName);
+            if (result2) {
+              return result2;
+            }
+          }
+        }
+      } else if (rule instanceof RegExp) {
+        const match = rule.exec(modelName);
+        if (match) {
+          return match;
+        }
+      }
+      break;
+    case "function":
+      const result = rule.call(this, modelName);
+      if (result) {
+        return result;
+      }
+      break;
+  }
+}
+
+// src/utils/get-all-enum-keys.ts
+function getAllEnumKeys(enumType) {
+  return Object.keys(enumType).filter((k) => Number.isNaN(Number(k)));
+}
+
+// src/utils/parse-js-json.ts
+var import_util_ex3 = require("util-ex");
+function parseJsJson(input) {
+  const fn = (0, import_util_ex3.newFunction)("expression", [], `return ${input}`);
+  return fn();
+}
+
+// src/utils/get-keys-path.ts
+function isObject(value) {
+  return !!value && value.constructor === Object;
+}
+function getKeysPath(value) {
+  if (!value)
+    return [];
+  return getKeys(value, [], "");
+}
+function getKeys(obj, paths, dot = ".") {
+  if (Array.isArray(obj)) {
+    return obj.flatMap((item, i) => getKeys(item, [...paths, `[${i}]`]));
+  }
+  if (isObject(obj)) {
+    return Object.entries(obj).flatMap(
+      ([k, v]) => getKeys(v, [...paths, dot + k])
+    );
+  }
+  return [paths.join("")];
+}
+
+// src/utils/end-with-repeated-sequence.ts
+function createEndWithRepetitionDetector(repetitionThreshold) {
+  if (repetitionThreshold < 2) {
+    throw new CommonError("repetitionThreshold must be greater than 1", "createEndWithRepetitionDetector", 400 /* InvalidArgument */);
+  }
+  const regex = new RegExp(`([\\S\\s]+)(\\1{${repetitionThreshold - 1},})$`);
+  return function endWithRepeatedSequence(value) {
+    return regex.test(value);
+  };
+}
+
+// src/utils/load-file-from-paths.ts
+var import_path2 = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+function loadFileFromPaths(filename, searchPaths, extNames) {
+  let result;
+  if (import_path2.default.isAbsolute(filename)) {
+    if (fs.existsSync(filename)) {
+      result = filename;
+    }
+  } else {
+    if (!searchPaths) {
+      searchPaths = ["."];
+    }
+    let exts = extNames ? extNames.map((ext) => getMultiLevelExtname(filename, extNameLevel(ext))) : void 0;
+    for (const searchPath of searchPaths) {
+      const filePath = import_path2.default.resolve(searchPath, filename);
+      if (exts) {
+        for (let i = 0; i < exts.length; i++) {
+          const extName = exts[i] !== extNames[i] ? extNames[i] : "";
+          const filenameWithExt = filePath + extName;
+          if (fs.existsSync(filenameWithExt)) {
+            result = filenameWithExt;
+            break;
+          }
+        }
+      } else {
+        if (fs.existsSync(filePath)) {
+          result = filePath;
+          break;
+        }
+      }
+    }
+  }
+  if (result) {
+    result = fs.readFileSync(result);
+  } else {
+    throw new NotFoundError(filename, "loadFileFromPaths");
+  }
+  return result;
+}
+function loadTextFromPaths(filename, searchPaths, extNames, encoding = "utf8") {
+  const result = loadFileFromPaths(filename, searchPaths, extNames);
+  return result.toString(encoding);
+}
+
+// src/utils/config.ts
+var import_fs = require("fs");
+var import_path3 = __toESM(require("path"));
+var import_load_config_file = require("load-config-file");
+var import_yaml = require("yaml");
+var import_yaml_types = require("yaml-types");
+var import_with_db = require("mime-type/with-db");
+var import_yaml2 = require("yaml");
+var YamlTags = [import_yaml_types.regexp];
+function registerYamlTag(tags) {
+  if (!Array.isArray(tags)) {
+    tags = [tags];
+  }
+  for (const tag of tags) {
+    const result = YamlTags.indexOf(tag) === -1;
+    if (result) {
+      YamlTags.push(tag);
+    }
+  }
+}
+function parseYaml(content) {
+  return (0, import_yaml.parse)(content, { customTags: YamlTags });
+}
+function parseJson(content) {
+  return JSON.parse(content);
+}
+import_load_config_file.Config.register([".yml", ".yaml"], parseYaml);
+import_load_config_file.Config.register([".json"], parseJson);
+function traverseFolderSync(directoryPath, fileHandler) {
+  const files = (0, import_fs.readdirSync)(directoryPath, { withFileTypes: true, recursive: true });
+  for (const entry of files) {
+    const filePath = import_path3.default.join(directoryPath, entry.name);
+    if (entry.isFile()) {
+      fileHandler(filePath, entry);
+    }
+  }
+}
+function getConfigFileNames(directoryPath) {
+  const configFiles = [];
+  traverseFolderSync(directoryPath, (filePath) => {
+    const extname = import_path3.default.extname(filePath);
+    if (extname === ".yml" || extname === ".yaml" || extname === ".json") {
+      configFiles.push(filePath);
+    }
+  });
+  return configFiles;
+}
+function getConfigs(directoryPath) {
+  const files = getConfigFileNames(directoryPath);
+  return files.map((file) => import_load_config_file.Config.loadSync(file)).filter((config) => config !== void 0);
+}
+function saveConfigFile(filename, config, extLevel = 1) {
+  if (filename[0] === ".") {
+    extLevel++;
+  }
+  const extname = getMultiLevelExtname(filename, extLevel);
+  if (!extname || extname.split(".").length <= 1) {
+    filename += ".yaml";
+  }
+  const mime = import_with_db.mimeType.lookup(filename);
+  if (mime === "application/json")
+    config = JSON.stringify(config, null, 2);
+  else if (mime === "text/yaml") {
+    config = (0, import_yaml.stringify)(config);
+  } else {
+    throw new Error(`${filename} unsupported mime type: ${mime}`);
+  }
+  const dirname = import_path3.default.dirname(filename);
+  if (!(0, import_fs.existsSync)(dirname)) {
+    (0, import_fs.mkdirSync)(dirname, { recursive: true });
+  }
+  (0, import_fs.writeFileSync)(filename, config, { encoding: "utf8" });
+}
+
+// src/utils/json-filter.ts
+function quoteValueIfString(shouldQuote, value) {
+  if (shouldQuote) {
+    return `'${value}'`;
+  }
+  return String(value);
+}
+function generateAndClause(filters, wrapKey) {
+  return filters.map((block) => jsonFilterToWhere(block, wrapKey)).join(" AND ");
+}
+function generateOrClause(filters, wrapKey) {
+  return filters.map((block) => jsonFilterToWhere(block, wrapKey)).join(" OR ");
+}
+function generateCondition(dataKey, condition) {
+  const andQuery = [];
+  Object.keys(condition).forEach((key) => {
+    const value = condition[key];
+    let hasQuotes = typeof condition[key] === "string";
+    switch (key) {
+      case "$lt":
+      case "<":
+        andQuery.push(`${dataKey} < ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "<=":
+      case "$lte":
+        andQuery.push(`${dataKey} <= ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "$gt":
+      case ">":
+        andQuery.push(`${dataKey} > ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "$gte":
+      case ">=":
+        andQuery.push(`${dataKey} >= ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "$ne":
+      case "!=":
+        andQuery.push(`${dataKey} != ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "=":
+      case "$eq":
+        andQuery.push(`${dataKey} = ${quoteValueIfString(hasQuotes, value)}`);
+        break;
+      case "$in":
+        andQuery.push(`${dataKey} IN (${value.map((e) => quoteValueIfString(true, e)).join(", ")})`);
+        break;
+      case "$nin":
+        andQuery.push(`${dataKey} NOT IN (${value.map((e) => quoteValueIfString(true, e)).join(", ")})`);
+        break;
+      case "$regex":
+        andQuery.push(`${dataKey} REGEXP '${value.source}'`);
+        break;
+      case "$like":
+        andQuery.push(`${dataKey} LIKE '${value}'`);
+        break;
+      case "$nlike":
+        andQuery.push(`${dataKey} NOT LIKE '${value}'`);
+        break;
+      case "$glob":
+        andQuery.push(`${dataKey} GLOB '${value}'`);
+        break;
+      case "$nglob":
+        andQuery.push(`${dataKey} NOT GLOB '${value}'`);
+        break;
+      default:
+        throw new Error(`Unsupported condition operator: ${key}`);
+    }
+  });
+  return andQuery.join(" AND ");
+}
+function jsonFilterToWhere(filter, wrapKey) {
+  const andQuery = [];
+  if (typeof wrapKey !== "function") {
+    wrapKey = (k) => k;
+  }
+  if (Array.isArray(filter)) {
+    andQuery.push(generateAndClause(filter, wrapKey));
+  } else
+    for (const [key, value] of Object.entries(filter)) {
+      if (key === "$and") {
+        andQuery.push(`(${generateAndClause(filter[key], wrapKey)})`);
+      } else if (key === "$or") {
+        andQuery.push(`(${generateOrClause(filter[key], wrapKey)})`);
+      } else {
+        const tValue = typeof value;
+        if (value == null) {
+          andQuery.push(`${wrapKey(key)} IS NULL`);
+        } else if (tValue === "object" && !Array.isArray(value)) {
+          andQuery.push(generateCondition(wrapKey(key), value));
+        } else if (tValue === "string") {
+          andQuery.push(`${wrapKey(key)}='${value}'`);
+        } else if (tValue === "number" || tValue === "boolean") {
+          andQuery.push(`${wrapKey(key)}=${value}`);
+        } else {
+          throw new Error(`Unsupported value type for key ${key}`);
+        }
+      }
+    }
+  ;
+  return andQuery.length > 1 ? andQuery.join(" AND ") : andQuery[0];
+}
+
+// src/client-tools.ts
+var ClientTools = class _ClientTools extends ToolFunc {
+  static get apiRoot() {
+    return _ClientTools._apiRoot;
+  }
+  static setApiRoot(v) {
+    _ClientTools._apiRoot = v;
+  }
+  // static items = ClientToolItems;
+  static async loadFrom() {
+    if (this._apiRoot) {
+      const res = await fetch(this._apiRoot, { headers: {
+        "Content-Type": "application/json"
+      } });
+      const items = await res.json();
+      if (items)
+        this.loadFromSync(items);
+    } else {
+      throwError2("missing apiRoot to load tools", "ClientTools");
+    }
+  }
+  static loadFromSync(items) {
+    for (const name in items) {
+      const item = this.get(name);
+      const funcItem = items[name];
+      if (!item) {
+        this.register(funcItem);
+      } else if (item instanceof _ClientTools) {
+        item.assign(funcItem);
+      } else {
+        throwError2(`${name} already registered as ${item.constructor.name}`, "ClientTools");
+      }
+    }
+  }
+  static async fetch(name, objParam) {
+    const func = this.get(name);
+    if (func && func.fetch) {
+      return func.fetch(objParam);
+    }
+  }
+  getUrlParams(objParam) {
+    if (objParam !== void 0) {
+      const objParamStr = JSON.stringify(objParam);
+      if (objParamStr !== "{}" && objParamStr !== "[]" && objParamStr !== '""') {
+        return "?p=" + encodeURIComponent(objParamStr);
+      }
+    }
+    return "";
+  }
+  async fetch(objParam, act, subName) {
+    const fetchOptions = { ...this.fetchOptions };
+    if (!fetchOptions.headers || !fetchOptions.headers["Content-Type"]) {
+      fetchOptions.headers = {
+        "Content-Type": "application/json",
+        ...fetchOptions.headers
+      };
+    }
+    if (objParam?.stream && !fetchOptions.headers.Connection) {
+      fetchOptions.headers.Connection = "keep-alive";
+    }
+    if (!act) {
+      act = this.action || "post";
+    }
+    if (act === "res") {
+      act = "get";
+    }
+    if (subName) {
+      if (typeof subName !== "string") {
+        subName = JSON.stringify(subName);
+      }
+      subName = this.name + "/" + subName;
+    } else {
+      subName = this.name;
+    }
+    fetchOptions.method = act.toUpperCase();
+    let urlPart;
+    if (act === "get" || act === "delete") {
+      urlPart = subName + this.getUrlParams(objParam);
+    } else {
+      fetchOptions.body = JSON.stringify(objParam);
+      urlPart = subName;
+    }
+    const res = await fetch(`${this.apiRoot}/${urlPart}`, fetchOptions);
+    if (!res.ok) {
+      const err = await this.errorFrom(res);
+      throw err;
+    }
+    return res;
+  }
+  async errorFrom(res) {
+    let errCode = res.status;
+    let errMsg = res.statusText;
+    let name = this.name;
+    let data;
+    if (res.body) {
+      const text = await res.text();
+      try {
+        const body = JSON.parse(text);
+        if (body) {
+          if (body.error) {
+            errMsg = body.error;
+          }
+          if (body.name) {
+            name = body.name;
+          }
+          if (body.data) {
+            data = body.data;
+            data.name = name;
+            if (data.what) {
+              data.msg = errMsg;
+              errMsg = data.what;
+            }
+          }
+          if (body.message) {
+            errMsg = errMsg + ":" + body.message;
+          }
+        }
+      } catch (e) {
+        console.warn("\u{1F680} ~ parse error body to json:", e);
+      }
+    }
+    return createError(errMsg, name, errCode);
+  }
+  async func(objParam) {
+    const res = await this.fetch(objParam);
+    if (objParam?.stream) {
+      return res;
+    }
+    const result = await res.json();
+    return result;
+  }
+};
+var ClientToolFuncSchema = { ...RemoteToolFuncSchema };
+ClientTools.defineProperties(ClientTools, ClientToolFuncSchema);
+
+// src/res-client-tools.ts
+var ResClientTools = class extends ClientTools {
+  async fetch(options, action) {
+    if (!options) {
+      options = {};
+    }
+    if (action && this.action === "res") {
+      if (action === "get" || action === "delete") {
+        let id = options.id;
+        if (!id) {
+          throwError2("id is required");
+        }
+        if (typeof id === "string") {
+          id = encodeURIComponent(id);
+        }
+        delete options.id;
+        return super.fetch(options, action, id);
+      } else if (action === "list") {
+        action = "get";
+      } else if (action.startsWith("$")) {
+        options.act = action;
+        action = "post";
+      }
+    }
+    return await super.fetch(options, action);
+  }
+  async _func(action, options) {
+    const res = await this.fetch(options, action);
+    if (options?.stream) {
+      return res;
+    }
+    const result = await res.json();
+    return result;
+  }
+  async func(options) {
+    const action = options.action;
+    if (action) {
+      delete options.action;
+    }
+    return this._func(action, options);
+  }
+  assignMethods(methods) {
+    if (Array.isArray(methods)) {
+      for (const action of methods) {
+        const name = action.startsWith("$") ? action.slice(1) : action;
+        if (!this[name]) {
+          this[name] = ((act) => this._func.bind(this, act))(action);
+        }
+      }
+    }
+  }
+};
+var ResClientToolsSchema = {
+  methods: {
+    type: "array",
+    assign(value, dest, src, name, options) {
+      if (!options?.isExported) {
+        dest.assignMethods(value);
+      }
+    }
+  }
+};
+ResClientTools.defineProperties(ResClientTools, ResClientToolsSchema);
+
+// src/funcs/event-client.ts
+var EventClient = class extends ResClientTools {
+  constructor() {
+    super(...arguments);
+    // subscribed sse events
+    this._sseEvents = {};
+    this._forwardEvents = /* @__PURE__ */ new Set();
+    this.name = EventName;
+    this.description = "subscribe server sent event";
+    // pass event-bus event to server
+    this.ebListener = async function(...data) {
+      const event2 = this.type;
+      if (this.target.publish) {
+        await this.target.publish({ data, event: event2 });
+      }
+    };
+  }
+  get evtSource() {
+    let result = this._es;
+    if (!result || result.readyState === EventSource.CLOSED) {
+      result = this.initEventSource(this._esEvents);
+    }
+    return result;
+  }
+  get active() {
+    return !!this._es && this._es.readyState !== EventSource.CLOSED;
+  }
+  set active(v) {
+    if (v !== this.active) {
+      if (v) {
+        this.initEventSource(this._esEvents);
+      } else if (this._es) {
+        this._es.close();
+        this._es = void 0;
+      }
+    }
+  }
+  initEventSource(events) {
+    if (typeof events === "string") {
+      events = [events];
+    }
+    if (this._es && this._es.readyState !== EventSource.CLOSED) {
+      if (!this._esEvents || events && events.every((e) => this._esEvents.includes(e))) {
+        return this._es;
+      } else {
+        this._es.close();
+      }
+    }
+    const urlParams = events ? this.getUrlParams({ event: events }) : "";
+    const url = `${this.apiRoot}/${this.name}${urlParams}`;
+    const evtSource = this._es = new EventSource(url);
+    Object.entries(this._sseEvents).forEach(([event2, listener]) => {
+      evtSource.addEventListener(event2, listener);
+    });
+    this._esEvents = events;
+    return evtSource;
+  }
+  // pass server sent event to eventBus
+  esListener(event2) {
+    const data = event2.data ? JSON.parse(event2.data) : void 0;
+    const evtType = event2.type;
+    if (!this._forwardEvents.has(evtType)) {
+      const emitter = this.emitter;
+      if (emitter && data && evtType) {
+        if (Array.isArray(data)) {
+          emitter.emit(evtType, ...data);
+        } else {
+          emitter.emit(evtType, data);
+        }
+      }
+    }
+  }
+  /**
+   * subscribe server sent event(SSE)
+   * @param events
+   */
+  async subscribe(events) {
+    const result = await this.sub({ event: events });
+    if (typeof events === "string") {
+      events = [events];
+    }
+    const evtSource = this.evtSource;
+    for (const event2 of events) {
+      if (!this._sseEvents[event2]) {
+        const listener = this._sseEvents[event2] = this.esListener.bind(this);
+        evtSource.addEventListener(event2, listener);
+      }
+    }
+    return result;
+  }
+  /**
+   * unsubscribe server sent event(SSE)
+   * @param events
+   */
+  async unsubscribe(events) {
+    const result = await this.unsub({ event: events });
+    if (typeof events === "string") {
+      events = [events];
+    }
+    for (const event2 of events) {
+      const listener = this._sseEvents[event2];
+      if (listener) {
+        delete this._sseEvents[event2];
+        this.evtSource.removeEventListener(event2, listener);
+      }
+    }
+    return result;
+  }
+  /**
+   * forward local event(s) to server
+   *
+   * subscribe these local events to forward/publish to server
+   *
+   * Note: pls backendEventable(ClientTools or EventClient) first
+   * @param events
+   */
+  forwardEvent(events) {
+    if (typeof events === "string") {
+      events = [events];
+    }
+    for (const event2 of events) {
+      if (!this._forwardEvents.has(event2)) {
+        this._forwardEvents.add(event2);
+        if (this.on)
+          this.on(event2, this.ebListener);
+      }
+    }
+  }
+  /**
+   * unforward local event(s) to server
+   *
+   * unsubscribe these local events not to forward/publish to server
+   *
+   * Note: pls backendEventable(ClientTools or EventClient) first
+   * @param events
+   */
+  unforwardEvent(events) {
+    if (typeof events === "string") {
+      events = [events];
+    }
+    for (const event2 of events) {
+      if (this._forwardEvents.has(event2)) {
+        this._forwardEvents.delete(event2);
+        if (this.off)
+          this.off(event2, this.ebListener);
+      }
+    }
+  }
+  async init(events) {
+    this.active = false;
+    this.initEventSource(events);
+    if (events) {
+      return await this.subscribe(events);
+    }
+  }
+};
+var eventClient = new EventClient(EventName);
+
+// src/res-server-tools.ts
+var import_util_ex4 = require("util-ex");
+var ResServerTools = class extends ServerTools {
+  constructor(name, options = {}) {
+    super(name, options);
+    this.action = "res";
+    this.params = {
+      "id": { type: "string" },
+      "val": { type: "any" }
+    };
+    const methods = this.methods = [];
+    for (const action of ActionNames) {
+      if (typeof this[action] === "function") {
+        methods.push(action);
+      }
+    }
+    (0, import_util_ex4.getAllNames)(Object.getPrototypeOf(this)).filter((name2) => name2.startsWith("$") && typeof this[name2] === "function").forEach((name2) => {
+      methods.push(name2);
+      const n = name2.slice(1);
+      if (this[n] === void 0) {
+        this[n] = this[name2];
+      }
+    });
+  }
+  cast(key, value) {
+    let vType = this.params[key];
+    if (vType) {
+      if (typeof vType !== "string") {
+        vType = vType.type;
+      }
+      if (vType === "number") {
+        value = Number(value);
+      }
+    }
+    return value;
+  }
+  getMethodFromParams(params) {
+    let method = params?._req?.method?.toLowerCase();
+    if (method === "get" && params.id === void 0) {
+      method = "list";
+    }
+    if (method === "post" && params.act) {
+      method = params.act;
+    }
+    return method;
+  }
+  func(params) {
+    const method = this.getMethodFromParams(params);
+    if (method && typeof this[method] === "function") {
+      if (params.id !== void 0) {
+        params.id = this.cast("id", params.id);
+      }
+      return this[method](params);
+    } else {
+      throw new NotFoundError(method, this.name);
+    }
+  }
+};
+var ResServerToolsSchema = {
+  methods: {
+    type: "array"
+  }
+};
+ResServerTools.defineProperties(ResServerTools, ResServerToolsSchema);
+
+// src/funcs/event-server.ts
+var eventBus = event.runSync();
+var EventServer = class _EventServer extends ResServerTools {
+  constructor() {
+    super(...arguments);
+    this.name = EventName;
+    this.description = "subscribe server sent event";
+    this.result = "event";
+    this.depends = { [EventBusName]: event };
+  }
+  static get sse() {
+    if (!this._sse) {
+      this._sse = new SSEChannel();
+    }
+    return this._sse;
+  }
+  get sse() {
+    return this.constructor.sse;
+  }
+  static publish(data, event2) {
+    return _EventServer.sse.publish(data, event2);
+  }
+  static {
+    // the local event-bus listener to forward to SSE
+    this.ebListener = function ebListener(...data) {
+      _EventServer.sse.publish(data, this.type);
+    };
+  }
+  static subscribe(req, res, events) {
+    return _EventServer.sse.subscribe(req, res, events);
+  }
+  static alreadyForward(event2) {
+    const listeners = eventBus.listeners(event2);
+    for (const listener of listeners) {
+      if (listener === _EventServer.ebListener) {
+        return true;
+      }
+    }
+  }
+  publishSSE(data, event2) {
+    return this.constructor.publish(data, event2);
+  }
+  subscribeSSE(req, res, events) {
+    if (typeof events === "string") {
+      events = [events];
+    }
+    return this.constructor.subscribe(req, res, events);
+  }
+  // forward the events on the event-bus to client
+  forward(events) {
+    if (!Array.isArray(events)) {
+      events = [events];
+    }
+    for (const event2 of events) {
+      if (!_EventServer.alreadyForward(event2)) {
+        eventBus.on(event2, _EventServer.ebListener);
+      }
+    }
+  }
+  unforward(events) {
+    if (typeof events === "string") {
+      events = [events];
+    }
+    for (const event2 of events) {
+      eventBus.off(event2, _EventServer.ebListener);
+    }
+  }
+  list({ _req, _res, event: event2 }) {
+    if (_req && _res) {
+      this.subscribeSSE(_req, _res, event2);
+    }
+  }
+  $sub({ event: event2 }) {
+    if (event2) {
+      this.forward(event2);
+      return { event: event2 };
+    } else {
+      throwError2("event is required", "sub", 400 /* InvalidArgument */);
+    }
+  }
+  $unsub({ event: event2 }) {
+    if (event2) {
+      this.unforward(event2);
+      return { event: event2 };
+    } else {
+      throwError2("event is required", "unsub", 400 /* InvalidArgument */);
+    }
+  }
+  $publish({ event: events, data }) {
+    if (events && data) {
+      if (typeof events === "string") {
+        events = [events];
+      }
+      for (const event2 of events) {
+        this.publishSSE(data, event2);
+      }
+      return { event: events };
+    } else {
+      throwError2("event or data is required", "pub", 400 /* InvalidArgument */);
+    }
+  }
+  isStream(params) {
+    const method = this.getMethodFromParams(params);
+    return method === "list";
+  }
+};
+var eventServer = new EventServer(EventName);
+
+// src/funcs/index.ts
+function registerCoreTools() {
+  event.register();
+  lrucache.register();
+  similarity.register();
+  isSimilar.register();
+  splitSegments.register();
+  mergeSegments.register();
+  segments.register();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventClient,
+  EventServer,
+  EventToolFunc,
+  _lrucache,
+  createLRUCache,
+  event,
+  eventClient,
+  eventServer,
+  getDefaultSimilarPassingScore,
+  isSimilar,
+  lrucache,
+  mergeSegments,
+  registerCoreTools,
+  segments,
+  similarity,
+  splitSegments
+});