@exulu/backend 1.28.1 → 1.29.0

package/dist/index.js

@@ -711,17 +711,6 @@ var requestValidators = {
 // src/registry/utils/graphql.ts
 import bcrypt3 from "bcryptjs";
 
-// types/enums/jobs.ts
-var JOB_STATUS_ENUM = {
-  completed: "completed",
-  failed: "failed",
-  delayed: "delayed",
-  active: "active",
-  waiting: "waiting",
-  paused: "paused",
-  stuck: "stuck"
-};
-
 // src/postgres/core-schema.ts
 var agentMessagesSchema = {
   type: "agent_messages",
@@ -930,6 +919,14 @@ var agentsSchema = {
     {
       name: "tools",
       type: "json"
+    },
+    {
+      name: "animation_idle",
+      type: "text"
+    },
+    {
+      name: "animation_responding",
+      type: "text"
     }
   ]
 };
@@ -1631,6 +1628,19 @@ var generateApiKey = async (name, email) => {
 
 // src/registry/utils/graphql.ts
 import { v4 as uuidv42 } from "uuid";
+
+// types/enums/jobs.ts
+var JOB_STATUS_ENUM = {
+  completed: "completed",
+  failed: "failed",
+  delayed: "delayed",
+  active: "active",
+  waiting: "waiting",
+  paused: "paused",
+  stuck: "stuck"
+};
+
+// src/registry/utils/graphql.ts
 var GraphQLDate = new GraphQLScalarType({
   name: "Date",
   description: "Date custom scalar type",
@@ -4280,7 +4290,7 @@ var createUppyRoutes = async (app, config) => {
     const client2 = getS3Client(config);
     const command = new ListObjectsV2Command({
       Bucket: config.fileUploads.s3Bucket,
-      Prefix: `test/${authenticationResult.user.id}`,
+      Prefix: `${config.fileUploads.s3prefix ? config.fileUploads.s3prefix.replace(/\/$/, "") + "/" : ""}${authenticationResult.user.id}`,
       MaxKeys: 9,
       ...req.query.continuationToken && { ContinuationToken: req.query.continuationToken }
     });
@@ -7685,6 +7695,80 @@ var outputsContext = new ExuluContext({
 import winston2 from "winston";
 import util from "util";
 
+// src/bullmq/queues.ts
+import { Queue as Queue3 } from "bullmq";
+import { BullMQOtel } from "bullmq-otel";
+var ExuluQueues = class {
+  queues;
+  constructor() {
+    this.queues = [];
+  }
+  list = /* @__PURE__ */ new Map();
+  // list of queue names
+  queue(name) {
+    return this.queues.find((x) => x.queue?.name === name);
+  }
+  // name: string
+  // concurrency: global concurrency for the queue
+  // ratelimit: maximum number of jobs per second
+  // Rate limit is set on workers (see workers.ts), even global rate limits,
+  // that is a bit counter-intuitive. Since queues are registered using .user
+  // method of ExuluQueues we need to store the desired rate limit on the queue
+  // here so we can use the value when creating workers for the queue instance
+  // as there is no way to store a rate limit value natively on a bullm queue.
+  register = (name, concurrency = 1, ratelimit = 1) => {
+    const use = async () => {
+      const existing = this.queues.find((x) => x.queue?.name === name);
+      if (existing) {
+        const globalConcurrency = await existing.queue.getGlobalConcurrency();
+        if (globalConcurrency !== concurrency) {
+          await existing.queue.setGlobalConcurrency(concurrency);
+        }
+        return {
+          queue: existing.queue,
+          ratelimit,
+          concurrency
+        };
+      }
+      if (!redisServer.host?.length || !redisServer.port?.length) {
+        console.error(`[EXULU] no redis server configured, but you are trying to use a queue ( ${name}), likely in an agent or embedder (look for ExuluQueues.register().use() ).`);
+        throw new Error(`[EXULU] no redis server configured.`);
+      }
+      const newQueue = new Queue3(
+        `${name}`,
+        {
+          connection: {
+            ...redisServer,
+            enableOfflineQueue: false
+          },
+          telemetry: new BullMQOtel("simple-guide")
+        }
+      );
+      await newQueue.setGlobalConcurrency(concurrency);
+      this.queues.push({
+        queue: newQueue,
+        ratelimit,
+        concurrency
+      });
+      return {
+        queue: newQueue,
+        ratelimit,
+        concurrency
+      };
+    };
+    this.list.set(name, {
+      name,
+      concurrency,
+      ratelimit,
+      use
+    });
+    return {
+      use
+    };
+  };
+};
+var queues = new ExuluQueues();
+
 // src/templates/evals/index.ts
 import { z as z3 } from "zod";
 var llmAsJudgeEval = new ExuluEval2({
@@ -7732,6 +7816,594 @@ var llmAsJudgeEval = new ExuluEval2({
   llm: true
 });
 
+// src/templates/tools/math.ts
+import { z as z4 } from "zod";
+
+// src/templates/tools/utils/arithmetic.ts
+var Arithmetic = class {
+  /**
+   * Add two numbers together
+   * @param firstNumber - The first number 
+   * @param secondNumber - The second number
+   * @returns sum
+   */
+  static add(firstNumber, secondNumber) {
+    const sum = firstNumber + secondNumber;
+    return sum;
+  }
+  /**
+   * Subtract one number from another
+   * @param minuend - The number to subtract from
+   * @param subtrahend - The number to subtract
+   * @returns difference
+   */
+  static subtract(minuend, subtrahend) {
+    const difference = minuend - subtrahend;
+    return difference;
+  }
+  /**
+   * Multiply two numbers together
+   * @param firstNumber - The first number
+   * @param secondNumber - The second number
+   * @returns product
+   */
+  static multiply(firstNumber, secondNumber) {
+    const product = firstNumber * secondNumber;
+    return product;
+  }
+  /**
+   * Divide one number by another
+   * @param numerator - The number to be divided
+   * @param denominator - The number to divide by
+   * @returns quotient
+   */
+  static division(numerator, denominator) {
+    const quotient = numerator / denominator;
+    return quotient;
+  }
+  /**
+   * Calculate the sum of an array of numbers
+   * @param numbers - Array of numbers to sum
+   * @returns sum of all numbers in the array
+   */
+  static sum(numbers) {
+    const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    return sum;
+  }
+  /**
+   * Calculate the floor of a number
+   * @param number - Number to find the floor of
+   * @returns floor of the number
+   */
+  static floor(number) {
+    const floor = Math.floor(number);
+    return floor;
+  }
+  /**
+   * Calculate the ceil of a number
+   * @param number - Number to find the ceil of
+   * @returns ceil of the number
+   */
+  static ceil(number) {
+    const ceil = Math.ceil(number);
+    return ceil;
+  }
+  /**
+   * Calculate the round of a number
+   * @param number - Number to find the round of
+   * @returns round of the number
+   */
+  static round(number) {
+    const round = Math.round(number);
+    return round;
+  }
+  /**
+   * Get the remainder of a division equation.
+   * Ex: modulo(5,2) = 1
+   * @param numerator - The number to be divided
+   * @param denominator - The number to divide by
+   * @returns remainder of division
+   */
+  static modulo(numerator, denominator) {
+    const remainder = numerator % denominator;
+    return remainder;
+  }
+};
+
+// src/templates/tools/utils/statistics.ts
+var Statistics = class {
+  /**
+   * Calculate the arithmetic mean (average) of an array of numbers
+   * @param numbers - Array of numbers to calculate the mean of
+   * @returns The arithmetic mean value
+   */
+  static mean(numbers) {
+    const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const mean = sum / numbers.length;
+    return mean;
+  }
+  /**
+   * Calculate the median (middle value) of an array of numbers
+   * @param numbers - Array of numbers to calculate the median of
+   * @returns The median value
+   */
+  static median(numbers) {
+    numbers.sort();
+    const medianIndex = numbers.length / 2;
+    let medianValue;
+    if (numbers.length % 2 !== 0) {
+      medianValue = numbers[Math.floor(medianIndex)];
+    } else {
+      medianValue = (numbers[medianIndex] + numbers[medianIndex - 1]) / 2;
+    }
+    return medianValue;
+  }
+  /**
+   * Calculate the mode (most frequent value(s)) of an array of numbers
+   * @param numbers - Array of numbers to calculate the mode of
+   * @returns Object containing the mode value(s) and their frequency
+   */
+  static mode(numbers) {
+    const modeMap = /* @__PURE__ */ new Map();
+    numbers.forEach((value) => {
+      if (modeMap.has(value)) {
+        modeMap.set(value, modeMap.get(value) + 1);
+      } else {
+        modeMap.set(value, 1);
+      }
+    });
+    let maxFrequency = 0;
+    for (const numberFrequency of modeMap.values()) {
+      if (numberFrequency > maxFrequency) {
+        maxFrequency = numberFrequency;
+      }
+    }
+    const modeResult = [];
+    for (const [key, value] of modeMap.entries()) {
+      if (value === maxFrequency) {
+        modeResult.push(key);
+      }
+    }
+    return {
+      modeResult,
+      maxFrequency
+    };
+  }
+  /**
+   * Find the minimum value in an array of numbers
+   * @param numbers - Array of numbers to find the minimum of
+   * @returns The minimum value
+   */
+  static min(numbers) {
+    const minValue = Math.min(...numbers);
+    return minValue;
+  }
+  /**
+   * Find the maximum value in an array of numbers
+   * @param numbers - Array of numbers to find the maximum of
+   * @returns The maximum value
+   */
+  static max(numbers) {
+    const maxValue = Math.max(...numbers);
+    return maxValue;
+  }
+};
+
+// src/templates/tools/utils/trigonometric.ts
+var Trigonometric = class {
+  /**
+   * Calculate the sin of a number in radians
+   * @param number - The number to find the sin of
+   * @returns The sin of a number in radians
+   */
+  static sin(number) {
+    const sin = Math.sin(number);
+    return sin;
+  }
+  /**
+   * Calculate the arcsin of a number in radians
+   * @param number - The number to find the arcsin of
+   * @returns The arcsin of a number in radians
+   */
+  static arcsin(number) {
+    const arcsin = Math.asin(number);
+    return arcsin;
+  }
+  /**
+   * Calculate the cos of a number in radians
+   * @param number - The number to find the cos of
+   * @returns The cos of a number in radians
+   */
+  static cos(number) {
+    const cos = Math.cos(number);
+    return cos;
+  }
+  /**
+   * Calculate the arccos of a number in radians
+   * @param number - The number to find the arccos of
+   * @returns The arccos of a number in radians
+   */
+  static arccos(number) {
+    const arccos = Math.acos(number);
+    return arccos;
+  }
+  /**
+   * Calculate the tangent of a number in radians
+   * @param number - The number to find the tangent of
+   * @returns The tangent of a number in radians
+   */
+  static tan(number) {
+    const tangent = Math.tan(number);
+    return tangent;
+  }
+  /**
+   * Calculate the arc tangent of a number in radians
+   * @param number - The number to find the arc tangent of
+   * @returns The arc tangent of a number in radians
+   */
+  static arctan(number) {
+    const arctangent = Math.atan(number);
+    return arctangent;
+  }
+  /**
+   * Converts a radian into its equivalent value in degrees
+   * @param number - The number to get the degree of
+   * @returns The degree of the number
+   */
+  static radiansToDegrees(number) {
+    const degrees = number * (180 / Math.PI);
+    return degrees;
+  }
+  /**
+   * Converts a degree into its equivalent value in radians
+   * @param number - The number to get the radians of
+   * @returns The radians of the number
+   */
+  static degreesToRadians(number) {
+    const radians = number * (Math.PI / 180);
+    return radians;
+  }
+};
+
+// src/templates/tools/math.ts
+var additionTool = new ExuluTool2({
+  id: "addition",
+  name: "Addition",
+  description: "Adds two numbers together",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    firstNumber: z4.number().describe("The first addend"),
+    secondNumber: z4.number().describe("The second addend")
+  }),
+  execute: async ({ firstNumber, secondNumber }) => {
+    const value = Arithmetic.add(firstNumber, secondNumber);
+    return { result: `${value}` };
+  }
+});
+var subtractionTool = new ExuluTool2({
+  id: "subtraction",
+  name: "Subtraction",
+  description: "Subtracts the second number from the first number",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    minuend: z4.number().describe("The number to subtract from (minuend)"),
+    subtrahend: z4.number().describe("The number being subtracted (subtrahend)")
+  }),
+  execute: async ({ minuend, subtrahend }) => {
+    const value = Arithmetic.subtract(minuend, subtrahend);
+    return { result: `${value}` };
+  }
+});
+var multiplicationTool = new ExuluTool2({
+  id: "multiplication",
+  name: "Multiplication",
+  description: "Multiplies two numbers together",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    firstNumber: z4.number().describe("The first number"),
+    SecondNumber: z4.number().describe("The second number")
+  }),
+  execute: async ({ firstNumber, SecondNumber }) => {
+    const value = Arithmetic.multiply(firstNumber, SecondNumber);
+    return { result: `${value}` };
+  }
+});
+var divisionTool = new ExuluTool2({
+  id: "division",
+  name: "Division",
+  description: "Divides the first number by the second number",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numerator: z4.number().describe("The number being divided (numerator)"),
+    denominator: z4.number().describe("The number to divide by (denominator)")
+  }),
+  execute: async ({ numerator, denominator }) => {
+    const value = Arithmetic.division(numerator, denominator);
+    return { result: `${value}` };
+  }
+});
+var sumTool = new ExuluTool2({
+  id: "sum",
+  name: "Sum",
+  description: "Adds any number of numbers together",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).min(1).describe("Array of numbers to sum")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Arithmetic.sum(numbers);
+    return { result: `${value}` };
+  }
+});
+var moduloTool = new ExuluTool2({
+  id: "modulo",
+  name: "Modulo",
+  description: "Divides two numbers and returns the remainder",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numerator: z4.number().describe("The number being divided (numerator)"),
+    denominator: z4.number().describe("The number to divide by (denominator)")
+  }),
+  execute: async ({ numerator, denominator }) => {
+    const value = Arithmetic.modulo(numerator, denominator);
+    return { result: `${value}` };
+  }
+});
+var meanTool = new ExuluTool2({
+  id: "mean",
+  name: "Mean",
+  description: "Calculates the arithmetic mean of a list of numbers",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).min(1).describe("Array of numbers to find the mean of")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Statistics.mean(numbers);
+    return { result: `${value}` };
+  }
+});
+var medianTool = new ExuluTool2({
+  id: "median",
+  name: "Median",
+  description: "Calculates the median of a list of numbers",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).min(1).describe("Array of numbers to find the median of")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Statistics.median(numbers);
+    return { result: `${value}` };
+  }
+});
+var modeTool = new ExuluTool2({
+  id: "mode",
+  name: "Mode",
+  description: "Finds the most common number in a list of numbers",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).describe("Array of numbers to find the mode of")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Statistics.mode(numbers);
+    return { result: `Entries (${value.modeResult.join(", ")}) appeared ${value.maxFrequency} times` };
+  }
+});
+var minTool = new ExuluTool2({
+  id: "min",
+  name: "Minimum",
+  description: "Finds the minimum value from a list of numbers",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).describe("Array of numbers to find the minimum of")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Statistics.min(numbers);
+    return { result: `${value}` };
+  }
+});
+var maxTool = new ExuluTool2({
+  id: "max",
+  name: "Maximum",
+  description: "Finds the maximum value from a list of numbers",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    numbers: z4.array(z4.number()).describe("Array of numbers to find the maximum of")
+  }),
+  execute: async ({ numbers }) => {
+    const value = Statistics.max(numbers);
+    return { result: `${value}` };
+  }
+});
+var floorTool = new ExuluTool2({
+  id: "floor",
+  name: "Floor",
+  description: "Rounds a number down to the nearest integer",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to round down")
+  }),
+  execute: async ({ number }) => {
+    const value = Arithmetic.floor(number);
+    return { result: `${value}` };
+  }
+});
+var ceilingTool = new ExuluTool2({
+  id: "ceiling",
+  name: "Ceiling",
+  description: "Rounds a number up to the nearest integer",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to round up")
+  }),
+  execute: async ({ number }) => {
+    const value = Arithmetic.ceil(number);
+    return { result: `${value}` };
+  }
+});
+var roundTool = new ExuluTool2({
+  id: "round",
+  name: "Round",
+  description: "Rounds a number to the nearest integer",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to round")
+  }),
+  execute: async ({ number }) => {
+    const value = Arithmetic.round(number);
+    return { result: `${value}` };
+  }
+});
+var sinTool = new ExuluTool2({
+  id: "sin",
+  name: "Sine",
+  description: "Calculates the sine of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number in radians to find the sine of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.sin(number);
+    return { result: `${value}` };
+  }
+});
+var arcsinTool = new ExuluTool2({
+  id: "arcsin",
+  name: "Arcsine",
+  description: "Calculates the arcsine of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to find the arcsine of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.arcsin(number);
+    return { result: `${value}` };
+  }
+});
+var cosTool = new ExuluTool2({
+  id: "cos",
+  name: "Cosine",
+  description: "Calculates the cosine of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number in radians to find the cosine of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.cos(number);
+    return { result: `${value}` };
+  }
+});
+var arccosTool = new ExuluTool2({
+  id: "arccos",
+  name: "Arccosine",
+  description: "Calculates the arccosine of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to find the arccosine of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.arccos(number);
+    return { result: `${value}` };
+  }
+});
+var tanTool = new ExuluTool2({
+  id: "tan",
+  name: "Tangent",
+  description: "Calculates the tangent of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number in radians to find the tangent of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.tan(number);
+    return { result: `${value}` };
+  }
+});
+var arctanTool = new ExuluTool2({
+  id: "arctan",
+  name: "Arctangent",
+  description: "Calculates the arctangent of a number in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number to find the arctangent of")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.arctan(number);
+    return { result: `${value}` };
+  }
+});
+var radiansToDegreesTool = new ExuluTool2({
+  id: "radiansToDegrees",
+  name: "Radians to Degrees",
+  description: "Converts a radian value to its equivalent in degrees",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number in radians to convert to degrees")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.radiansToDegrees(number);
+    return { result: `${value}` };
+  }
+});
+var degreesToRadiansTool = new ExuluTool2({
+  id: "degreesToRadians",
+  name: "Degrees to Radians",
+  description: "Converts a degree value to its equivalent in radians",
+  type: "function",
+  config: [],
+  inputSchema: z4.object({
+    number: z4.number().describe("The number in degrees to convert to radians")
+  }),
+  execute: async ({ number }) => {
+    const value = Trigonometric.degreesToRadians(number);
+    return { result: `${value}` };
+  }
+});
+var mathTools = [
+  additionTool,
+  subtractionTool,
+  multiplicationTool,
+  divisionTool,
+  sumTool,
+  moduloTool,
+  meanTool,
+  medianTool,
+  modeTool,
+  minTool,
+  maxTool,
+  floorTool,
+  ceilingTool,
+  roundTool,
+  sinTool,
+  arcsinTool,
+  cosTool,
+  arccosTool,
+  tanTool,
+  arctanTool,
+  radiansToDegreesTool,
+  degreesToRadiansTool
+];
+
 // src/registry/index.ts
 var isDev = process.env.NODE_ENV !== "production";
 var consoleTransport = new winston2.transports.Console({
@@ -7761,7 +8433,7 @@ var isValidPostgresName = (id) => {
   const regex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
   const isValid = regex.test(id);
   const length = id.length;
-  return isValid && length <= 80 && length > 5;
+  return isValid && length <= 80 && length > 2;
 };
 var ExuluApp = class {
   _agents = [];
@@ -7803,6 +8475,7 @@ var ExuluApp = class {
     this._config = config;
     this._tools = [
       ...tools ?? [],
+      ...mathTools,
       // Add contexts as tools
       ...Object.values(contexts || {}).map((context) => context.tool())
       // Because agents are stored in the database,  we add those as tools
@@ -7998,80 +8671,6 @@ var ExuluApp = class {
   };
 };
 
-// src/bullmq/queues.ts
-import { Queue as Queue3 } from "bullmq";
-import { BullMQOtel } from "bullmq-otel";
-var ExuluQueues = class {
-  queues;
-  constructor() {
-    this.queues = [];
-  }
-  list = /* @__PURE__ */ new Map();
-  // list of queue names
-  queue(name) {
-    return this.queues.find((x) => x.queue?.name === name);
-  }
-  // name: string
-  // concurrency: global concurrency for the queue
-  // ratelimit: maximum number of jobs per second
-  // Rate limit is set on workers (see workers.ts), even global rate limits,
-  // that is a bit counter-intuitive. Since queues are registered using .user
-  // method of ExuluQueues we need to store the desired rate limit on the queue
-  // here so we can use the value when creating workers for the queue instance
-  // as there is no way to store a rate limit value natively on a bullm queue.
-  register = (name, concurrency = 1, ratelimit = 1) => {
-    const use = async () => {
-      const existing = this.queues.find((x) => x.queue?.name === name);
-      if (existing) {
-        const globalConcurrency = await existing.queue.getGlobalConcurrency();
-        if (globalConcurrency !== concurrency) {
-          await existing.queue.setGlobalConcurrency(concurrency);
-        }
-        return {
-          queue: existing.queue,
-          ratelimit,
-          concurrency
-        };
-      }
-      if (!redisServer.host?.length || !redisServer.port?.length) {
-        console.error(`[EXULU] no redis server configured, but you are trying to use a queue ( ${name}), likely in an agent or embedder (look for ExuluQueues.register().use() ).`);
-        throw new Error(`[EXULU] no redis server configured.`);
-      }
-      const newQueue = new Queue3(
-        `${name}`,
-        {
-          connection: {
-            ...redisServer,
-            enableOfflineQueue: false
-          },
-          telemetry: new BullMQOtel("simple-guide")
-        }
-      );
-      await newQueue.setGlobalConcurrency(concurrency);
-      this.queues.push({
-        queue: newQueue,
-        ratelimit,
-        concurrency
-      });
-      return {
-        queue: newQueue,
-        ratelimit,
-        concurrency
-      };
-    };
-    this.list.set(name, {
-      name,
-      concurrency,
-      ratelimit,
-      use
-    });
-    return {
-      use
-    };
-  };
-};
-var queues = new ExuluQueues();
-
 // src/chunking/types/base.ts
 var Chunk = class _Chunk {
   /** The text of the chunk. */