@exulu/backend 1.28.2 → 1.30.0

package/dist/index.cjs

@@ -763,17 +763,6 @@ var requestValidators = {
 // src/registry/utils/graphql.ts
 var import_bcryptjs3 = __toESM(require("bcryptjs"), 1);
 
-// 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",
@@ -982,6 +971,14 @@ var agentsSchema = {
     {
       name: "tools",
       type: "json"
+    },
+    {
+      name: "animation_idle",
+      type: "text"
+    },
+    {
+      name: "animation_responding",
+      type: "text"
     }
   ]
 };
@@ -1683,6 +1680,19 @@ var generateApiKey = async (name, email) => {
 
 // src/registry/utils/graphql.ts
 var import_uuid2 = require("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 import_graphql2.GraphQLScalarType({
   name: "Date",
   description: "Date custom scalar type",
@@ -2522,11 +2532,14 @@ var addAgentFields = async (requestedFields, agents, result, tools, user) => {
         } else {
           hydrated = tools.find((t) => t.id === tool2.id);
         }
-        return {
+        const hydratedTool = {
           ...tool2,
           name: hydrated?.name || "",
-          description: hydrated?.description || ""
+          description: hydrated?.description || "",
+          category: tool2?.category || "default"
         };
+        console.log("[EXULU] hydratedTool", hydratedTool);
+        return hydratedTool;
       }));
       result.tools = result.tools.filter((tool2) => tool2 !== null);
     } else {
@@ -3470,7 +3483,8 @@ type PageInfo {
     deleteJob(queue: QueueEnum!, id: String!): JobActionReturnPayload
     `;
   typeDefs += `
-   tools: ToolPaginationResult
+   tools(search: String, category: String, limit: Int, page: Int): ToolPaginationResult
+   toolCategories: [String!]!
     `;
   typeDefs += `
    jobs(queue: QueueEnum!, statusses: [JobStateEnum!]): JobPaginationResult
@@ -3790,6 +3804,7 @@ type PageInfo {
   };
   resolvers.Query["tools"] = async (_, args, context, info) => {
     const requestedFields = getRequestedFields(info);
+    const { search, category, limit = 100, page = 0 } = args;
     const instances = await loadAgents();
     let agentTools = await Promise.all(
       instances.map(async (instance) => {
@@ -3801,16 +3816,39 @@ type PageInfo {
       })
     );
     const filtered = agentTools.filter((tool2) => tool2 !== null);
+    let allTools = [...filtered, ...tools];
+    if (search && search.trim()) {
+      const searchTerm = search.toLowerCase().trim();
+      allTools = allTools.filter(
+        (tool2) => tool2.name?.toLowerCase().includes(searchTerm) || tool2.description?.toLowerCase().includes(searchTerm)
+      );
+    }
+    if (category && category.trim()) {
+      allTools = allTools.filter((tool2) => tool2.category === category);
+    }
+    const total = allTools.length;
+    const start = page * limit;
+    const end = start + limit;
+    const paginatedTools = allTools.slice(start, end);
     return {
-      items: [...filtered, ...tools].map((tool2) => {
+      items: paginatedTools.map((tool2) => {
         const object = {};
         requestedFields.forEach((field) => {
           object[field] = tool2[field];
         });
         return object;
-      })
+      }),
+      total,
+      page,
+      limit
     };
   };
+  resolvers.Query["toolCategories"] = async () => {
+    const array = tools.map((tool2) => tool2.category).filter((category) => category && typeof category === "string");
+    array.push("contexts");
+    array.push("agents");
+    return [...new Set(array)].sort();
+  };
   modelDefs += `
     type ProviderPaginationResult {
         items: [Provider]!
@@ -3849,6 +3887,9 @@ type PageInfo {
   modelDefs += `
     type ToolPaginationResult {
     items: [Tool]!
+    total: Int!
+    page: Int!
+    limit: Int!
     }
     `;
   modelDefs += `
@@ -3958,6 +3999,7 @@ type Tool {
   id: ID!
   name: String!
   description: String
+  category: String
   type: String
   config: JSON
 }
@@ -4313,7 +4355,7 @@ var createUppyRoutes = async (app, config) => {
     const client2 = getS3Client(config);
     const command = new import_client_s3.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 }
     });
@@ -4846,6 +4888,7 @@ var ExuluAgent2 = class {
       id: agentInstance.id,
       name: `${agentInstance.name}`,
       type: "agent",
+      category: "agents",
       inputSchema: import_zod.z.object({
         prompt: import_zod.z.string().describe("The prompt (usually a question for the agent) to send to the agent."),
         information: import_zod.z.string().describe("A summary of relevant context / information from the current session")
@@ -5274,13 +5317,15 @@ var ExuluTool2 = class {
   id;
   name;
   description;
+  category;
   inputSchema;
   type;
   tool;
   config;
-  constructor({ id, name, description, inputSchema, type, execute: execute2, config }) {
+  constructor({ id, name, description, category, inputSchema, type, execute: execute2, config }) {
     this.id = id;
     this.config = config;
+    this.category = category || "default";
     this.name = name;
     this.description = description;
     this.inputSchema = inputSchema;
@@ -5709,6 +5754,7 @@ var ExuluContext = class {
       id: this.id,
       name: `${this.name}`,
       type: "context",
+      category: "contexts",
       inputSchema: import_zod.z.object({
         query: import_zod.z.string()
       }),
@@ -7839,6 +7885,616 @@ var llmAsJudgeEval = new ExuluEval2({
   llm: true
 });
 
+// src/templates/tools/math.ts
+var import_zod4 = require("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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    firstNumber: import_zod4.z.number().describe("The first addend"),
+    secondNumber: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    minuend: import_zod4.z.number().describe("The number to subtract from (minuend)"),
+    subtrahend: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    firstNumber: import_zod4.z.number().describe("The first number"),
+    SecondNumber: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numerator: import_zod4.z.number().describe("The number being divided (numerator)"),
+    denominator: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numerator: import_zod4.z.number().describe("The number being divided (numerator)"),
+    denominator: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    numbers: import_zod4.z.array(import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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",
+  category: "math",
+  config: [],
+  inputSchema: import_zod4.z.object({
+    number: import_zod4.z.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 import_winston2.default.transports.Console({
@@ -7868,7 +8524,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 = [];
@@ -7910,6 +8566,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