@mastra/core 0.2.0-alpha.91 → 0.2.0-alpha.93

package/dist/chunk-F7ILHRX5.js

@@ -0,0 +1,659 @@
+import { MastraVector } from './chunk-HH5JIATB.js';
+import { BaseFilterTranslator } from './chunk-4LJFWC2Q.js';
+import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { createClient } from '@libsql/client';
+
+// src/vector/libsql/filter.ts
+var _LibSQLFilterTranslator = class _LibSQLFilterTranslator extends BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...BaseFilterTranslator.DEFAULT_OPERATORS,
+      regex: [],
+      custom: [
+        "$contains",
+        "$size"
+      ]
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) {
+      return filter;
+    }
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, currentPath = "") {
+    if (this.isRegex(node)) {
+      throw new Error("Direct regex pattern format is not supported in LibSQL");
+    }
+    const withPath = /* @__PURE__ */ __name((result2) => currentPath ? {
+      [currentPath]: result2
+    } : result2, "withPath");
+    if (this.isPrimitive(node)) {
+      return withPath({
+        $eq: this.normalizeComparisonValue(node)
+      });
+    }
+    if (Array.isArray(node)) {
+      return withPath({
+        $in: this.normalizeArrayValues(node)
+      });
+    }
+    const entries = Object.entries(node);
+    const result = {};
+    for (const [key, value] of entries) {
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isLogicalOperator(key)) {
+        result[key] = Array.isArray(value) ? value.map((filter) => this.translateNode(filter)) : this.translateNode(value);
+      } else if (this.isOperator(key)) {
+        if (this.isArrayOperator(key) && !Array.isArray(value) && key !== "$elemMatch") {
+          result[key] = [
+            value
+          ];
+        } else if (this.isBasicOperator(key) && Array.isArray(value)) {
+          result[key] = JSON.stringify(value);
+        } else {
+          result[key] = value;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+        if (hasOperators) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          Object.assign(result, this.translateNode(value, newPath));
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    return result;
+  }
+};
+__name(_LibSQLFilterTranslator, "LibSQLFilterTranslator");
+var LibSQLFilterTranslator = _LibSQLFilterTranslator;
+
+// src/vector/libsql/sql-builder.ts
+var createBasicOperator = /* @__PURE__ */ __name((symbol) => {
+  return (key) => ({
+    sql: `CASE 
+      WHEN ? IS NULL THEN json_extract(metadata, '$."${handleKey(key)}"') IS ${symbol === "=" ? "" : "NOT"} NULL
+      ELSE json_extract(metadata, '$."${handleKey(key)}"') ${symbol} ?
+    END`,
+    needsValue: true,
+    transformValue: /* @__PURE__ */ __name((value) => {
+      return [
+        value,
+        value
+      ];
+    }, "transformValue")
+  });
+}, "createBasicOperator");
+var createNumericOperator = /* @__PURE__ */ __name((symbol) => {
+  return (key) => ({
+    sql: `CAST(json_extract(metadata, '$."${handleKey(key)}"') AS NUMERIC) ${symbol} ?`,
+    needsValue: true
+  });
+}, "createNumericOperator");
+var validateJsonArray = /* @__PURE__ */ __name((key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
+   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`, "validateJsonArray");
+var FILTER_OPERATORS = {
+  $eq: createBasicOperator("="),
+  $ne: createBasicOperator("!="),
+  $gt: createNumericOperator(">"),
+  $gte: createNumericOperator(">="),
+  $lt: createNumericOperator("<"),
+  $lte: createNumericOperator("<="),
+  // Array Operators
+  $in: /* @__PURE__ */ __name((key, value) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') IN (${value.map(() => "?").join(",")})`,
+    needsValue: true
+  }), "$in"),
+  $nin: /* @__PURE__ */ __name((key, value) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') NOT IN (${value.map(() => "?").join(",")})`,
+    needsValue: true
+  }), "$nin"),
+  $all: /* @__PURE__ */ __name((key) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+    needsValue: true,
+    transformValue: /* @__PURE__ */ __name((value) => {
+      const arrayValue = Array.isArray(value) ? value : [
+        value
+      ];
+      if (arrayValue.length === 0) {
+        return {
+          sql: "1 = 0",
+          values: []
+        };
+      }
+      return {
+        sql: `(
+          CASE
+            WHEN ${validateJsonArray(key)} THEN
+                NOT EXISTS (
+                    SELECT value 
+                    FROM json_each(?) 
+                    WHERE value NOT IN (
+                    SELECT value 
+                    FROM json_each(json_extract(metadata, '$."${handleKey(key)}"'))
+                )
+            )
+            ELSE FALSE
+          END
+        )`,
+        values: [
+          JSON.stringify(arrayValue)
+        ]
+      };
+    }, "transformValue")
+  }), "$all"),
+  $elemMatch: /* @__PURE__ */ __name((key) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+    needsValue: true,
+    transformValue: /* @__PURE__ */ __name((value) => {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("$elemMatch requires an object with conditions");
+      }
+      const conditions = Object.entries(value).map(([field, fieldValue]) => {
+        if (field.startsWith("$")) {
+          const { sql, values } = buildCondition("elem.value", {
+            [field]: fieldValue
+          });
+          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
+          const elemSql = sql.replace(pattern, "elem.value");
+          return {
+            sql: elemSql,
+            values
+          };
+        } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
+          const { sql, values } = buildCondition(field, fieldValue);
+          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
+          const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
+          return {
+            sql: elemSql,
+            values
+          };
+        } else {
+          return {
+            sql: `json_extract(elem.value, '$."${field}"') = ?`,
+            values: [
+              fieldValue
+            ]
+          };
+        }
+      });
+      return {
+        sql: `(
+          CASE
+            WHEN ${validateJsonArray(key)} THEN
+              EXISTS (
+                SELECT 1 
+                FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
+                WHERE ${conditions.map((c) => c.sql).join(" AND ")}
+              )
+            ELSE FALSE
+          END
+        )`,
+        values: conditions.flatMap((c) => c.values)
+      };
+    }, "transformValue")
+  }), "$elemMatch"),
+  // Element Operators
+  $exists: /* @__PURE__ */ __name((key) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') IS NOT NULL`,
+    needsValue: false
+  }), "$exists"),
+  // Logical Operators
+  $and: /* @__PURE__ */ __name((key) => ({
+    sql: `(${key})`,
+    needsValue: false
+  }), "$and"),
+  $or: /* @__PURE__ */ __name((key) => ({
+    sql: `(${key})`,
+    needsValue: false
+  }), "$or"),
+  $not: /* @__PURE__ */ __name((key) => ({
+    sql: `NOT (${key})`,
+    needsValue: false
+  }), "$not"),
+  $nor: /* @__PURE__ */ __name((key) => ({
+    sql: `NOT (${key})`,
+    needsValue: false
+  }), "$nor"),
+  $size: /* @__PURE__ */ __name((key, paramIndex) => ({
+    sql: `(
+    CASE
+      WHEN json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array' THEN 
+        json_array_length(json_extract(metadata, '$."${handleKey(key)}"')) = $${paramIndex}
+      ELSE FALSE
+    END
+  )`,
+    needsValue: true
+  }), "$size"),
+  //   /**
+  //    * Regex Operators
+  //    * Supports case insensitive and multiline
+  //    */
+  //   $regex: (key: string): FilterOperator => ({
+  //     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+  //     needsValue: true,
+  //     transformValue: (value: any) => {
+  //       const pattern = typeof value === 'object' ? value.$regex : value;
+  //       const options = typeof value === 'object' ? value.$options || '' : '';
+  //       let sql = `json_extract(metadata, '$."${handleKey(key)}"')`;
+  //       // Handle multiline
+  //       //   if (options.includes('m')) {
+  //       //     sql = `REPLACE(${sql}, CHAR(10), '\n')`;
+  //       //   }
+  //       //       let finalPattern = pattern;
+  //       // if (options) {
+  //       //   finalPattern = `(\\?${options})${pattern}`;
+  //       // }
+  //       //   // Handle case insensitivity
+  //       //   if (options.includes('i')) {
+  //       //     sql = `LOWER(${sql}) REGEXP LOWER(?)`;
+  //       //   } else {
+  //       //     sql = `${sql} REGEXP ?`;
+  //       //   }
+  //       if (options.includes('m')) {
+  //         sql = `EXISTS (
+  //         SELECT 1
+  //         FROM json_each(
+  //           json_array(
+  //             ${sql},
+  //             REPLACE(${sql}, CHAR(10), CHAR(13))
+  //           )
+  //         ) as lines
+  //         WHERE lines.value REGEXP ?
+  //       )`;
+  //       } else {
+  //         sql = `${sql} REGEXP ?`;
+  //       }
+  //       // Handle case insensitivity
+  //       if (options.includes('i')) {
+  //         sql = sql.replace('REGEXP ?', 'REGEXP LOWER(?)');
+  //         sql = sql.replace('value REGEXP', 'LOWER(value) REGEXP');
+  //       }
+  //       // Handle extended - allows whitespace and comments in pattern
+  //       if (options.includes('x')) {
+  //         // Remove whitespace and comments from pattern
+  //         const cleanPattern = pattern.replace(/\s+|#.*$/gm, '');
+  //         return {
+  //           sql,
+  //           values: [cleanPattern],
+  //         };
+  //       }
+  //       return {
+  //         sql,
+  //         values: [pattern],
+  //       };
+  //     },
+  //   }),
+  $contains: /* @__PURE__ */ __name((key) => ({
+    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+    needsValue: true,
+    transformValue: /* @__PURE__ */ __name((value) => {
+      if (Array.isArray(value)) {
+        return {
+          sql: `(
+            SELECT ${validateJsonArray(key)}
+            AND EXISTS (
+              SELECT 1 
+              FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as m
+              WHERE m.value IN (SELECT value FROM json_each(?))
+            )
+          )`,
+          values: [
+            JSON.stringify(value)
+          ]
+        };
+      }
+      if (value && typeof value === "object") {
+        let traverse2 = function(obj, path = []) {
+          for (const [k, v] of Object.entries(obj)) {
+            const currentPath = [
+              ...path,
+              k
+            ];
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+              traverse2(v, currentPath);
+            } else {
+              paths.push(currentPath.join("."));
+              values.push(v);
+            }
+          }
+        };
+        __name(traverse2, "traverse");
+        const paths = [];
+        const values = [];
+        traverse2(value);
+        return {
+          sql: `(${paths.map((path) => `json_extract(metadata, '$."${handleKey(key)}"."${path}"') = ?`).join(" AND ")})`,
+          values
+        };
+      }
+      return value;
+    }, "transformValue")
+  }), "$contains")
+};
+var handleKey = /* @__PURE__ */ __name((key) => {
+  return key.replace(/\./g, '"."');
+}, "handleKey");
+function buildFilterQuery(filter) {
+  if (!filter) {
+    return {
+      sql: "",
+      values: []
+    };
+  }
+  const values = [];
+  const conditions = Object.entries(filter).map(([key, value]) => {
+    const condition = buildCondition(key, value);
+    values.push(...condition.values);
+    return condition.sql;
+  }).join(" AND ");
+  return {
+    sql: conditions ? `WHERE ${conditions}` : "",
+    values
+  };
+}
+__name(buildFilterQuery, "buildFilterQuery");
+function buildCondition(key, value, parentPath) {
+  if ([
+    "$and",
+    "$or",
+    "$not",
+    "$nor"
+  ].includes(key)) {
+    return handleLogicalOperator(key, value);
+  }
+  if (!value || typeof value !== "object") {
+    return {
+      sql: `json_extract(metadata, '$."${key.replace(/\./g, '"."')}"') = ?`,
+      values: [
+        value
+      ]
+    };
+  }
+  return handleOperator(key, value);
+}
+__name(buildCondition, "buildCondition");
+function handleLogicalOperator(key, value, parentPath) {
+  if (!value || value.length === 0) {
+    switch (key) {
+      case "$and":
+      case "$nor":
+        return {
+          sql: "true",
+          values: []
+        };
+      case "$or":
+        return {
+          sql: "false",
+          values: []
+        };
+      case "$not":
+        throw new Error("$not operator cannot be empty");
+      default:
+        return {
+          sql: "true",
+          values: []
+        };
+    }
+  }
+  if (key === "$not") {
+    const entries = Object.entries(value);
+    const conditions2 = entries.map(([fieldKey, fieldValue]) => buildCondition(fieldKey, fieldValue));
+    return {
+      sql: `NOT (${conditions2.map((c) => c.sql).join(" AND ")})`,
+      values: conditions2.flatMap((c) => c.values)
+    };
+  }
+  const values = [];
+  const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
+  const conditions = Array.isArray(value) ? value.map((f) => {
+    const entries = Object.entries(f);
+    return entries.map(([k, v]) => buildCondition(k, v));
+  }) : [
+    buildCondition(key, value)
+  ];
+  const joined = conditions.flat().map((c) => {
+    values.push(...c.values);
+    return c.sql;
+  }).join(` ${joinOperator} `);
+  return {
+    sql: key === "$nor" ? `NOT (${joined})` : `(${joined})`,
+    values
+  };
+}
+__name(handleLogicalOperator, "handleLogicalOperator");
+function handleOperator(key, value) {
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const entries = Object.entries(value);
+    const results = entries.map(([operator2, operatorValue2]) => operator2 === "$not" ? {
+      sql: `NOT (${Object.entries(operatorValue2).map(([op, val]) => processOperator(key, op, val).sql).join(" AND ")})`,
+      values: Object.entries(operatorValue2).flatMap(([op, val]) => processOperator(key, op, val).values)
+    } : processOperator(key, operator2, operatorValue2));
+    return {
+      sql: `(${results.map((r) => r.sql).join(" AND ")})`,
+      values: results.flatMap((r) => r.values)
+    };
+  }
+  const [[operator, operatorValue] = []] = Object.entries(value);
+  return processOperator(key, operator, operatorValue);
+}
+__name(handleOperator, "handleOperator");
+var processOperator = /* @__PURE__ */ __name((key, operator, operatorValue) => {
+  if (!operator.startsWith("$") || !FILTER_OPERATORS[operator]) {
+    throw new Error(`Invalid operator: ${operator}`);
+  }
+  const operatorFn = FILTER_OPERATORS[operator];
+  const operatorResult = operatorFn(key, operatorValue);
+  if (!operatorResult.needsValue) {
+    return {
+      sql: operatorResult.sql,
+      values: []
+    };
+  }
+  const transformed = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
+  if (transformed && typeof transformed === "object" && "sql" in transformed) {
+    return transformed;
+  }
+  return {
+    sql: operatorResult.sql,
+    values: Array.isArray(transformed) ? transformed : [
+      transformed
+    ]
+  };
+}, "processOperator");
+
+// src/vector/libsql/index.ts
+var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
+  constructor({ connectionUrl, authToken, syncUrl, syncInterval }) {
+    super();
+    __publicField(this, "turso");
+    this.turso = createClient({
+      url: connectionUrl,
+      syncUrl,
+      authToken,
+      syncInterval
+    });
+  }
+  transformFilter(filter) {
+    const libsqlFilter = new LibSQLFilterTranslator();
+    const translatedFilter = libsqlFilter.translate(filter ?? {});
+    return translatedFilter;
+  }
+  async query(indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0) {
+    try {
+      const vectorStr = `[${queryVector.join(",")}]`;
+      const translatedFilter = this.transformFilter(filter);
+      const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
+      filterValues.push(minScore);
+      const query = `
+        WITH vector_scores AS (
+          SELECT
+            vector_id as id,
+            (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
+            metadata
+            ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
+          FROM ${indexName}
+          ${filterQuery}
+        )
+        SELECT *
+        FROM vector_scores
+        WHERE score > ?
+        ORDER BY score DESC
+        LIMIT ${topK}`;
+      const result = await this.turso.execute({
+        sql: query,
+        args: filterValues
+      });
+      return result.rows.map(({ id, score, metadata, embedding }) => ({
+        id,
+        score,
+        metadata: JSON.parse(metadata ?? "{}"),
+        ...includeVector && embedding && {
+          vector: JSON.parse(embedding)
+        }
+      }));
+    } finally {
+    }
+  }
+  async upsert(indexName, vectors, metadata, ids) {
+    const tx = await this.turso.transaction("write");
+    try {
+      const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+      for (let i = 0; i < vectors.length; i++) {
+        const query = `
+          INSERT INTO ${indexName} (vector_id, embedding, metadata)
+          VALUES (?, vector32(?), ?)
+          ON CONFLICT(vector_id) DO UPDATE SET
+            embedding = vector32(?),
+            metadata = ?
+        `;
+        await tx.execute({
+          sql: query,
+          // @ts-ignore
+          args: [
+            vectorIds[i],
+            JSON.stringify(vectors[i]),
+            JSON.stringify(metadata?.[i] || {}),
+            JSON.stringify(vectors[i]),
+            JSON.stringify(metadata?.[i] || {})
+          ]
+        });
+      }
+      await tx.commit();
+      return vectorIds;
+    } catch (error) {
+      await tx.rollback();
+      throw error;
+    }
+  }
+  async createIndex(indexName, dimension, _metric = "cosine") {
+    try {
+      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+        throw new Error("Invalid index name format");
+      }
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      await this.turso.execute({
+        sql: `
+        CREATE TABLE IF NOT EXISTS ${indexName} (
+          id SERIAL PRIMARY KEY,
+          vector_id TEXT UNIQUE NOT NULL,
+          embedding F32_BLOB(${dimension}),
+          metadata TEXT DEFAULT '{}'
+        );
+      `,
+        args: []
+      });
+      await this.turso.execute({
+        sql: `
+        CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
+        ON ${indexName} (libsql_vector_idx(embedding))
+      `,
+        args: []
+      });
+    } catch (error) {
+      console.error("Failed to create vector table:", error);
+      throw error;
+    } finally {
+    }
+  }
+  async deleteIndex(indexName) {
+    try {
+      await this.turso.execute({
+        sql: `DROP TABLE IF EXISTS ${indexName}`,
+        args: []
+      });
+    } catch (error) {
+      console.error("Failed to delete vector table:", error);
+      throw new Error(`Failed to delete vector table: ${error.message}`);
+    } finally {
+    }
+  }
+  async listIndexes() {
+    try {
+      const vectorTablesQuery = `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' 
+        AND sql LIKE '%F32_BLOB%';
+      `;
+      const result = await this.turso.execute({
+        sql: vectorTablesQuery,
+        args: []
+      });
+      return result.rows.map((row) => row.name);
+    } catch (error) {
+      throw new Error(`Failed to list vector tables: ${error.message}`);
+    }
+  }
+  async describeIndex(indexName) {
+    try {
+      const tableInfoQuery = `
+        SELECT sql 
+        FROM sqlite_master 
+        WHERE type='table' 
+        AND name = ?;
+      `;
+      const tableInfo = await this.turso.execute({
+        sql: tableInfoQuery,
+        args: [
+          indexName
+        ]
+      });
+      if (!tableInfo.rows[0]?.sql) {
+        throw new Error(`Table ${indexName} not found`);
+      }
+      const dimension = parseInt(tableInfo.rows[0].sql.match(/F32_BLOB\((\d+)\)/)?.[1] || "0");
+      const countQuery = `
+        SELECT COUNT(*) as count
+        FROM ${indexName};
+      `;
+      const countResult = await this.turso.execute({
+        sql: countQuery,
+        args: []
+      });
+      const metric = "cosine";
+      return {
+        dimension,
+        count: countResult?.rows?.[0]?.count ?? 0,
+        metric
+      };
+    } catch (e) {
+      throw new Error(`Failed to describe vector table: ${e.message}`);
+    }
+  }
+  async truncateIndex(indexName) {
+    await this.turso.execute({
+      sql: `DELETE FROM ${indexName}`,
+      args: []
+    });
+  }
+};
+__name(_DefaultVectorDB, "DefaultVectorDB");
+var DefaultVectorDB = _DefaultVectorDB;
+
+export { DefaultVectorDB };

package/dist/{chunk-WGUGRCAP.js → chunk-GGYXCZUW.js}

@@ -1,4 +1,4 @@
-import { Agent } from './chunk-MMJCCJNP.js';
+import { Agent } from './chunk-JWVCENG2.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 import { CohereClient } from 'cohere-ai';
 

package/dist/{chunk-FD4KOA4T.js → chunk-HH5JIATB.js}

@@ -1,5 +1,5 @@
+import { embed, embedMany } from './chunk-BOS3IA23.js';
 import { MastraBase } from './chunk-G4MCO7XF.js';
-import { embed, embedMany } from './chunk-5NQ3MEZM.js';
 import { __name } from './chunk-AJJZUHB4.js';
 
 // src/vector/index.ts

package/dist/{chunk-YKASGA6R.js → chunk-JJ57BXQR.js}

@@ -1,4 +1,4 @@
-import { MastraBundler } from './chunk-RDEXABVY.js';
+import { MastraBundler } from './chunk-MCB4M5W4.js';
 import { __name } from './chunk-AJJZUHB4.js';
 
 // src/deployer/index.ts

package/dist/{chunk-MMJCCJNP.js → chunk-JWVCENG2.js}

@@ -1,12 +1,11 @@
-import { executeHook, AvailableHooks } from './chunk-HBTQNIAX.js';
-import { LLM } from './chunk-YPMAHKBC.js';
+import { LLM } from './chunk-RI3ECMVF.js';
 import { InstrumentClass } from './chunk-6ZVFVYLE.js';
 import { MastraBase } from './chunk-G4MCO7XF.js';
 import { RegisteredLogger, LogLevel } from './chunk-ICMEXHKD.js';
+import { executeHook, AvailableHooks } from './chunk-HBTQNIAX.js';
 import { __name, __publicField, __privateAdd, __privateSet, __privateGet } from './chunk-AJJZUHB4.js';
 import { randomUUID } from 'crypto';
 import { z } from 'zod';
-import 'dotenv/config';
 
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;