@exulu/backend 1.5.0 → 1.6.1

package/dist/index.cjs

@@ -45,7 +45,8 @@ __export(index_exports, {
   ExuluSource: () => ExuluSource,
   ExuluTool: () => ExuluTool,
   ExuluWorkflow: () => ExuluWorkflow,
-  ExuluZodFileType: () => ExuluZodFileType
+  ExuluZodFileType: () => ExuluZodFileType,
+  db: () => db2
 });
 module.exports = __toCommonJS(index_exports);
 var import_config = require("dotenv/config");
@@ -142,6 +143,36 @@ var import_knex = __toESM(require("knex"), 1);
 var import_knex2 = require("knex");
 var import_knex3 = require("pgvector/knex");
 var db = {};
+var databaseExistsChecked = false;
+async function ensureDatabaseExists() {
+  console.log("[EXULU] Ensuring exulu database exists...");
+  const defaultKnex = (0, import_knex.default)({
+    client: "pg",
+    connection: {
+      host: process.env.POSTGRES_DB_HOST,
+      port: parseInt(process.env.POSTGRES_DB_PORT || "5432"),
+      user: process.env.POSTGRES_DB_USER,
+      database: "postgres",
+      // Connect to default database
+      password: process.env.POSTGRES_DB_PASSWORD,
+      ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false
+    }
+  });
+  try {
+    const result = await defaultKnex.raw(`
+            SELECT 1 FROM pg_database WHERE datname = 'exulu'
+        `);
+    if (result.rows.length === 0) {
+      console.log("[EXULU] Database 'exulu' does not exist. Creating it...");
+      await defaultKnex.raw(`CREATE DATABASE exulu`);
+      console.log("[EXULU] Database 'exulu' created successfully.");
+    } else {
+      console.log("[EXULU] Database 'exulu' already exists.");
+    }
+  } finally {
+    await defaultKnex.destroy();
+  }
+}
 async function postgresClient() {
   if (!db["exulu"]) {
     try {
@@ -151,6 +182,12 @@ async function postgresClient() {
       console.log("[EXULU] POSTGRES_DB_USER:", process.env.POSTGRES_DB_USER);
       console.log("[EXULU] POSTGRES_DB_PASSWORD:", process.env.POSTGRES_DB_PASSWORD);
       console.log("[EXULU] POSTGRES_DB_SSL:", process.env.POSTGRES_DB_SSL);
+      console.log("[EXULU] Database exists checked:", databaseExistsChecked);
+      if (!databaseExistsChecked) {
+        console.log("[EXULU] Ensuring exulu database exists...");
+        await ensureDatabaseExists();
+        databaseExistsChecked = true;
+      }
       const knex = (0, import_knex.default)({
         client: "pg",
         connection: {
@@ -224,7 +261,7 @@ var bullmqDecorator = async ({
       jobId: redisId
     }
   );
-  const { db: db2 } = await postgresClient();
+  const { db: db3 } = await postgresClient();
   const now = /* @__PURE__ */ new Date();
   console.log("[EXULU] scheduling new job", inputs);
   const insertData = {
@@ -249,12 +286,12 @@ var bullmqDecorator = async ({
     ...documents && { documents: documents.map((doc2) => doc2.id) },
     ...trigger && { trigger }
   };
-  await db2("jobs").insert(insertData).onConflict("redis").merge({
+  await db3("jobs").insert(insertData).onConflict("redis").merge({
     ...insertData,
     updatedAt: now
     // Only updatedAt changes on updates
   });
-  const doc = await db2.from("jobs").where({ redis: job.id }).first();
+  const doc = await db3.from("jobs").where({ redis: job.id }).first();
   if (!doc?.id) {
     throw new Error("Failed to get job ID after insert/update");
   }
@@ -657,10 +694,10 @@ var ExuluWorkflow = class {
     label
   }) => {
     let inputs;
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     if (!job?.id) {
       logger.write(`Creating new job for workflow ${this.name} with inputs: ${JSON.stringify(initialInputs)}`, "INFO");
-      const result = await db2("jobs").insert({
+      const result = await db3("jobs").insert({
         status: JOB_STATUS_ENUM.active,
         name: `Job running '${this.name}' for '${label}'`,
         agent,
@@ -678,7 +715,7 @@ var ExuluWorkflow = class {
       throw new Error("Job not found, or failed to be created.");
     }
     if (job.status !== JOB_STATUS_ENUM.active) {
-      await db2("jobs").update({
+      await db3("jobs").update({
         status: JOB_STATUS_ENUM.active,
         inputs: initialInputs
       }).where({ id: job?.id }).returning("id");
@@ -721,15 +758,15 @@ var ExuluWorkflow = class {
         logger.write(`Step ${step.name} output: ${JSON.stringify(result)}`, "INFO");
         final = result;
       }
-      await db2("jobs").update({
+      await db3("jobs").update({
         status: JOB_STATUS_ENUM.completed,
         result: JSON.stringify(final),
-        finished_at: db2.fn.now()
+        finished_at: db3.fn.now()
       }).where({ id: job?.id }).returning("id");
       return final;
     } catch (error) {
       logger.write(`Workflow ${this.name} failed with error: ${error.message} for job ${job?.id}`, "ERROR");
-      await db2("jobs").update({
+      await db3("jobs").update({
         status: JOB_STATUS_ENUM.failed,
         result: JSON.stringify({
           error: error.message || error,
@@ -842,8 +879,8 @@ var ExuluEval = class {
                             </correct_answers>`
             });
             console.log("[EXULU] eval result", object);
-            const { db: db2 } = await postgresClient();
-            await db2("eval_results").insert({
+            const { db: db3 } = await postgresClient();
+            await db3("eval_results").insert({
               input: data.prompt,
               output: data.result,
               duration: data.duration,
@@ -854,8 +891,8 @@ var ExuluEval = class {
               comment: object.comment,
               category: data.category,
               metadata: data.metadata,
-              createdAt: db2.fn.now(),
-              updatedAt: db2.fn.now()
+              createdAt: db3.fn.now(),
+              updatedAt: db3.fn.now()
             });
             return {
               score: object.correctnessScore,
@@ -959,15 +996,15 @@ var ExuluContext = class {
     return sanitizeName(this.name) + "_chunks";
   };
   tableExists = async () => {
-    const { db: db2 } = await postgresClient();
-    const tableExists = await db2.schema.hasTable(this.getTableName());
+    const { db: db3 } = await postgresClient();
+    const tableExists = await db3.schema.hasTable(this.getTableName());
     return tableExists;
   };
   async updateItem(user, id, item) {
     if (!id) {
       throw new Error("Id is required for updating an item.");
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     Object.keys(item).forEach((key) => {
       if (key === "name" || key === "description" || key === "external_id" || key === "tags" || key === "source" || key === "textLength" || key === "upsert" || key === "archived") {
         return;
@@ -980,8 +1017,8 @@ var ExuluContext = class {
     delete item.id;
     delete item.created_at;
     delete item.upsert;
-    item.updated_at = db2.fn.now();
-    const result = await db2.from(this.getTableName()).where({ id }).update(item).returning("id");
+    item.updated_at = db3.fn.now();
+    const result = await db3.from(this.getTableName()).where({ id }).update(item).returning("id");
     if (this.configuration.calculateVectors === "onUpdate" || this.configuration.calculateVectors === "always") {
       if (this.embedder.queue?.name) {
         console.log("[EXULU] embedder is in queue mode, scheduling job.");
@@ -1005,18 +1042,18 @@ var ExuluContext = class {
         label: this.name,
         trigger: "agent"
       });
-      const exists = await db2.schema.hasTable(this.getChunksTableName());
+      const exists = await db3.schema.hasTable(this.getChunksTableName());
       if (!exists) {
         await this.createChunksTable();
       }
-      await db2.from(this.getChunksTableName()).where({ source }).delete();
-      await db2.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
+      await db3.from(this.getChunksTableName()).where({ source }).delete();
+      await db3.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
         source,
         content: chunk.content,
         chunk_index: chunk.index,
         embedding: import_knex4.default.toSql(chunk.vector)
       })));
-      await db2.from(this.getTableName()).where({ id }).update({
+      await db3.from(this.getTableName()).where({ id }).update({
         embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
       }).returning("id");
     }
@@ -1029,9 +1066,9 @@ var ExuluContext = class {
     if (!item.name) {
       throw new Error("Name field is required.");
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     if (item.external_id) {
-      const existingItem = await db2.from(this.getTableName()).where({ external_id: item.external_id }).first();
+      const existingItem = await db3.from(this.getTableName()).where({ external_id: item.external_id }).first();
       if (existingItem && !upsert) {
         throw new Error("Item with external id " + item.external_id + " already exists.");
       }
@@ -1041,7 +1078,7 @@ var ExuluContext = class {
       }
     }
     if (upsert && item.id) {
-      const existingItem = await db2.from(this.getTableName()).where({ id: item.id }).first();
+      const existingItem = await db3.from(this.getTableName()).where({ id: item.id }).first();
       if (existingItem && upsert) {
         await this.updateItem(user, existingItem.id, item);
         return existingItem.id;
@@ -1058,11 +1095,11 @@ var ExuluContext = class {
     });
     delete item.id;
     delete item.upsert;
-    const result = await db2.from(this.getTableName()).insert({
+    const result = await db3.from(this.getTableName()).insert({
       ...item,
-      id: db2.fn.uuid(),
-      created_at: db2.fn.now(),
-      updated_at: db2.fn.now()
+      id: db3.fn.uuid(),
+      created_at: db3.fn.now(),
+      updated_at: db3.fn.now()
     }).returning("id");
     if (this.configuration.calculateVectors === "onInsert" || this.configuration.calculateVectors === "always") {
       if (this.embedder.queue?.name) {
@@ -1088,18 +1125,18 @@ var ExuluContext = class {
         label: this.name,
         trigger: "agent"
       });
-      const exists = await db2.schema.hasTable(this.getChunksTableName());
+      const exists = await db3.schema.hasTable(this.getChunksTableName());
       if (!exists) {
         await this.createChunksTable();
       }
       console.log("[EXULU] Inserting chunks.");
-      await db2.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
+      await db3.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
         source,
         content: chunk.content,
         chunk_index: chunk.index,
         embedding: import_knex4.default.toSql(chunk.vector)
       })));
-      await db2.from(this.getTableName()).where({ id: result[0].id }).update({
+      await db3.from(this.getTableName()).where({ id: result[0].id }).update({
         embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
       }).returning("id");
     }
@@ -1129,10 +1166,10 @@ var ExuluContext = class {
     if (limit < 1) limit = 10;
     let offset = (page - 1) * limit;
     const mainTable = this.getTableName();
-    const { db: db2 } = await postgresClient();
-    const columns = await db2(mainTable).columnInfo();
-    const totalQuery = db2.count("* as count").from(mainTable).first();
-    const itemsQuery = db2.select(Object.keys(columns).map((column) => mainTable + "." + column)).from(mainTable).offset(offset).limit(limit);
+    const { db: db3 } = await postgresClient();
+    const columns = await db3(mainTable).columnInfo();
+    const totalQuery = db3.count("* as count").from(mainTable).first();
+    const itemsQuery = db3.select(Object.keys(columns).map((column) => mainTable + "." + column)).from(mainTable).offset(offset).limit(limit);
     if (sort) {
       itemsQuery.orderBy(sort, order === "desc" ? "desc" : "asc");
     }
@@ -1208,29 +1245,29 @@ var ExuluContext = class {
       const vectorExpr = `${vectorStr}::vector`;
       switch (method) {
         case "l1Distance":
-          itemsQuery.select(db2.raw(`?? <-> ${vectorExpr} as l1_distance`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`?? <-> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`?? <-> ${vectorExpr} as l1_distance`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`?? <-> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
           break;
         case "l2Distance":
-          itemsQuery.select(db2.raw(`?? <-> ${vectorExpr} as l2_distance`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`?? <-> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`?? <-> ${vectorExpr} as l2_distance`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`?? <-> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
           break;
         case "hammingDistance":
-          itemsQuery.select(db2.raw(`?? <#> ${vectorExpr} as hamming_distance`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`?? <#> ${vectorExpr} as hamming_distance`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
           break;
         case "jaccardDistance":
-          itemsQuery.select(db2.raw(`?? <#> ${vectorExpr} as jaccard_distance`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`?? <#> ${vectorExpr} as jaccard_distance`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
           break;
         case "maxInnerProduct":
-          itemsQuery.select(db2.raw(`?? <#> ${vectorExpr} as inner_product`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`?? <#> ${vectorExpr} as inner_product`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`?? <#> ${vectorExpr} ASC`, [`${chunksTable}.embedding`]));
           break;
         case "cosineDistance":
         default:
-          itemsQuery.select(db2.raw(`1 - (?? <#> ${vectorExpr}) as cosine_distance`, [`${chunksTable}.embedding`]));
-          itemsQuery.orderByRaw(db2.raw(`1 - (?? <#> ${vectorExpr}) DESC`, [`${chunksTable}.embedding`]));
+          itemsQuery.select(db3.raw(`1 - (?? <#> ${vectorExpr}) as cosine_distance`, [`${chunksTable}.embedding`]));
+          itemsQuery.orderByRaw(db3.raw(`1 - (?? <#> ${vectorExpr}) DESC`, [`${chunksTable}.embedding`]));
           break;
       }
       let items = await itemsQuery;
@@ -1299,12 +1336,12 @@ var ExuluContext = class {
     }
   };
   createItemsTable = async () => {
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const tableName = this.getTableName();
     console.log("[EXULU] Creating table: " + tableName);
-    return await db2.schema.createTable(tableName, (table) => {
+    return await db3.schema.createTable(tableName, (table) => {
       console.log("[EXULU] Creating fields for table.", this.fields);
-      table.uuid("id").primary().defaultTo(db2.fn.uuid());
+      table.uuid("id").primary().defaultTo(db3.fn.uuid());
       table.text("name");
       table.text("description");
       table.text("tags");
@@ -1324,11 +1361,11 @@ var ExuluContext = class {
     });
   };
   createChunksTable = async () => {
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const tableName = this.getChunksTableName();
     console.log("[EXULU] Creating table: " + tableName);
-    return await db2.schema.createTable(tableName, (table) => {
-      table.uuid("id").primary().defaultTo(db2.fn.uuid());
+    return await db3.schema.createTable(tableName, (table) => {
+      table.uuid("id").primary().defaultTo(db3.fn.uuid());
       table.uuid("source").references("id").inTable(this.getTableName());
       table.text("content");
       table.integer("chunk_index");
@@ -1400,15 +1437,15 @@ var ExuluSource = class {
 };
 var updateStatistic = async (statistic) => {
   const currentDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const { db: db2 } = await postgresClient();
-  const existing = await db2.from("statistics").where({
+  const { db: db3 } = await postgresClient();
+  const existing = await db3.from("statistics").where({
     name: statistic.name,
     label: statistic.label,
     type: statistic.type,
     createdAt: currentDate
   }).first();
   if (!existing) {
-    await db2.from("statistics").insert({
+    await db3.from("statistics").insert({
       name: statistic.name,
       label: statistic.label,
       type: statistic.type,
@@ -1416,8 +1453,8 @@ var updateStatistic = async (statistic) => {
       createdAt: currentDate
     });
   } else {
-    await db2.from("statistics").update({
-      total: db2.raw("total + ?", [statistic.count ?? 1])
+    await db3.from("statistics").update({
+      total: db3.raw("total + ?", [statistic.count ?? 1])
     }).where({
       name: statistic.name,
       label: statistic.label,
@@ -1495,7 +1532,7 @@ var authentication = async ({
   apikey,
   authtoken,
   internalkey,
-  db: db2
+  db: db3
 }) => {
   if (internalkey) {
     if (!process.env.INTERNAL_SECRET) {
@@ -1532,7 +1569,7 @@ var authentication = async ({
           code: 401
         };
       }
-      const user = await db2.from("users").select("*").where("email", authtoken?.email).first();
+      const user = await db3.from("users").select("*").where("email", authtoken?.email).first();
       if (!user) {
         return {
           error: true,
@@ -1555,7 +1592,7 @@ var authentication = async ({
     }
   }
   if (apikey) {
-    const users = await db2.from("users").select("*").where("type", "api");
+    const users = await db3.from("users").select("*").where("type", "api");
     if (!users || users.length === 0) {
       return {
         error: true,
@@ -1587,7 +1624,7 @@ var authentication = async ({
       const user_key_compare_value = user.apikey.substring(0, user_key_last_slash_index);
       const isMatch = await import_bcryptjs.default.compare(request_key_compare_value, user_key_compare_value);
       if (isMatch) {
-        await db2.from("users").where({ id: user.id }).update({
+        await db3.from("users").where({ id: user.id }).update({
           last_used: /* @__PURE__ */ new Date()
         }).returning("id");
         return {
@@ -1615,7 +1652,7 @@ var authentication = async ({
 var requestValidators = {
   authenticate: async (req) => {
     const apikey = req.headers["exulu-api-key"] || null;
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     let authtoken = null;
     if (typeof apikey !== "string") {
       authtoken = await getToken((req.headers["authorization"] || req.headers["x-api-key"]) ?? "");
@@ -1623,7 +1660,7 @@ var requestValidators = {
     return await authentication({
       authtoken,
       apikey,
-      db: db2
+      db: db3
     });
   },
   workflows: (req) => {
@@ -1966,11 +2003,11 @@ function createMutations(table) {
   const tableNameSingular = table.name.singular.toLowerCase();
   return {
     [`${tableNamePlural}CreateOne`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       const requestedFields = getRequestedFields(info);
       let { input } = args;
       input = encryptSensitiveFields(input);
-      const results = await db2(tableNamePlural).insert({
+      const results = await db3(tableNamePlural).insert({
         ...input,
         createdAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
@@ -1978,43 +2015,43 @@ function createMutations(table) {
       return results[0];
     },
     [`${tableNamePlural}UpdateOne`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       let { where, input } = args;
       input = encryptSensitiveFields(input);
-      await db2(tableNamePlural).where(where).update({
+      await db3(tableNamePlural).where(where).update({
         ...input,
         updatedAt: /* @__PURE__ */ new Date()
       });
       const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where(where).first();
+      const result = await db3.from(tableNamePlural).select(requestedFields).where(where).first();
       return result;
     },
     [`${tableNamePlural}UpdateOneById`]: async (_, args, context, info) => {
       let { id, input } = args;
       input = encryptSensitiveFields(input);
-      const { db: db2 } = context;
-      await db2(tableNamePlural).where({ id }).update({
+      const { db: db3 } = context;
+      await db3(tableNamePlural).where({ id }).update({
         ...input,
         updatedAt: /* @__PURE__ */ new Date()
       });
       const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
+      const result = await db3.from(tableNamePlural).select(requestedFields).where({ id }).first();
       return result;
     },
     [`${tableNamePlural}RemoveOne`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       const { where } = args;
       const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where(where).first();
-      await db2(tableNamePlural).where(where).del();
+      const result = await db3.from(tableNamePlural).select(requestedFields).where(where).first();
+      await db3(tableNamePlural).where(where).del();
       return result;
     },
     [`${tableNamePlural}RemoveOneById`]: async (_, args, context, info) => {
       const { id } = args;
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
-      await db2(tableNamePlural).where({ id }).del();
+      const result = await db3.from(tableNamePlural).select(requestedFields).where({ id }).first();
+      await db3(tableNamePlural).where({ id }).del();
       return result;
     }
   };
@@ -2051,16 +2088,16 @@ function createQueries(table) {
   };
   return {
     [`${tableNameSingular}ById`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id: args.id }).first();
+      const result = await db3.from(tableNamePlural).select(requestedFields).where({ id: args.id }).first();
       return result;
     },
     [`${tableNameSingular}One`]: async (_, args, context, info) => {
       const { filters = [], sort } = args;
-      const { db: db2 } = context;
+      const { db: db3 } = context;
       const requestedFields = getRequestedFields(info);
-      let query = db2.from(tableNamePlural).select(requestedFields);
+      let query = db3.from(tableNamePlural).select(requestedFields);
       query = applyFilters(query, filters);
       query = applySorting(query, sort);
       const result = await query.first();
@@ -2068,8 +2105,8 @@ function createQueries(table) {
     },
     [`${tableNamePlural}Pagination`]: async (_, args, context, info) => {
       const { limit = 10, page = 0, filters = [], sort } = args;
-      const { db: db2 } = context;
-      let baseQuery = db2(tableNamePlural);
+      const { db: db3 } = context;
+      let baseQuery = db3(tableNamePlural);
       baseQuery = applyFilters(baseQuery, filters);
       const [{ count }] = await baseQuery.clone().count("* as count");
       const itemCount = Number(count);
@@ -2099,8 +2136,8 @@ function createQueries(table) {
     ...tableNamePlural === "jobs" ? {
       jobStatistics: async (_, args, context, info) => {
         const { user, agent, from, to } = args;
-        const { db: db2 } = context;
-        let query = db2("jobs");
+        const { db: db3 } = context;
+        let query = db3("jobs");
         if (user) {
           query = query.where("user", user);
         }
@@ -2117,7 +2154,7 @@ function createQueries(table) {
         const [{ completedCount }] = await completedQuery.count("* as completedCount");
         const failedQuery = query.clone().where("status", "failed");
         const [{ failedCount }] = await failedQuery.count("* as failedCount");
-        const durationQuery = query.clone().where("status", "completed").whereNotNull("duration").select(db2.raw('AVG("duration") as averageDuration'));
+        const durationQuery = query.clone().where("status", "completed").whereNotNull("duration").select(db3.raw('AVG("duration") as averageDuration'));
         const [{ averageDuration }] = await durationQuery;
         return {
           completedCount: Number(completedCount),
@@ -2634,11 +2671,11 @@ var createUppyRoutes = async (app) => {
     if (typeof apikey !== "string") {
       authtoken = await getToken(req.headers.authorization ?? "");
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const authenticationResult = await authentication({
       authtoken,
       apikey,
-      db: db2
+      db: db3
     });
     if (!authenticationResult.user?.id) {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
@@ -2679,7 +2716,7 @@ var createUppyRoutes = async (app) => {
   app.get("/s3/download", async (req, res, next) => {
     const apikey = req.headers["exulu-api-key"] || null;
     const internalkey = req.headers["internal-key"] || null;
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     let authtoken = null;
     if (typeof apikey !== "string" && typeof internalkey !== "string") {
       authtoken = await getToken(req.headers.authorization ?? "");
@@ -2688,7 +2725,7 @@ var createUppyRoutes = async (app) => {
       authtoken,
       apikey,
       internalkey,
-      db: db2
+      db: db3
     });
     if (!authenticationResult.user?.id) {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
@@ -2752,7 +2789,7 @@ var createUppyRoutes = async (app) => {
   const generateS3Key = (filename) => `${crypto.randomUUID()}-${filename}`;
   const signOnServer = async (req, res, next) => {
     const apikey = req.headers["exulu-api-key"] || null;
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     let authtoken = null;
     if (typeof apikey !== "string") {
       authtoken = await getToken(req.headers.authorization ?? "");
@@ -2760,7 +2797,7 @@ var createUppyRoutes = async (app) => {
     const authenticationResult = await authentication({
       authtoken,
       apikey,
-      db: db2
+      db: db3
     });
     if (!authenticationResult.user?.id) {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
@@ -2800,7 +2837,7 @@ var createUppyRoutes = async (app) => {
   });
   app.post("/s3/multipart", async (req, res, next) => {
     const apikey = req.headers["exulu-api-key"] || null;
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     let authtoken = null;
     if (typeof apikey !== "string") {
       authtoken = await getToken(req.headers.authorization ?? "");
@@ -2808,7 +2845,7 @@ var createUppyRoutes = async (app) => {
     const authenticationResult = await authentication({
       authtoken,
       apikey,
-      db: db2
+      db: db3
     });
     if (!authenticationResult.user?.id) {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
@@ -2992,6 +3029,7 @@ var global_queues = {
   logs_cleaner: "logs-cleaner"
 };
 var createRecurringJobs = async () => {
+  console.log("[EXULU] creating recurring jobs.");
   const recurringJobSchedulersLogs = [];
   const queue = queues.use(global_queues.logs_cleaner);
   recurringJobSchedulersLogs.push({
@@ -3019,7 +3057,7 @@ var createRecurringJobs = async () => {
       }
     }
   );
-  console.log("Recurring job schedulers:");
+  console.log("[EXULU] recurring job schedulers:");
   console.table(recurringJobSchedulersLogs);
   return queue;
 };
@@ -3112,10 +3150,10 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
         if (!authenticationResult.user?.id) {
           throw new Error(authenticationResult.message);
         }
-        const { db: db2 } = await postgresClient();
+        const { db: db3 } = await postgresClient();
         return {
           req,
-          db: db2
+          db: db3
         };
       }
     })
@@ -3134,8 +3172,8 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
       return;
     }
-    const { db: db2 } = await postgresClient();
-    const agentsFromDb = await db2.from("agents").select("*");
+    const { db: db3 } = await postgresClient();
+    const agentsFromDb = await db3.from("agents").select("*");
     res.status(200).json(agentsFromDb.map((agent) => {
       const backend = agents.find((a) => a.id === agent.backend);
       if (!backend) {
@@ -3166,7 +3204,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
       return;
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const id = req.params.id;
     if (!id) {
       res.status(400).json({
@@ -3174,7 +3212,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       });
       return;
     }
-    const agent = await db2.from("agents").where({ id }).first();
+    const agent = await db3.from("agents").where({ id }).first();
     if (!agent) {
       res.status(400).json({
         message: "Agent not found in database."
@@ -3240,7 +3278,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
     if (!id && !external_id) {
       throw new Error("Missing id or external_id in request.");
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const context = contexts.find((context2) => context2.id === contextId);
     if (!context) {
       throw new Error("Context not found in registry.");
@@ -3249,7 +3287,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
     if (!exists) {
       throw new Error("Table with name " + context.getTableName() + " does not exist.");
     }
-    const query = db2.from(context.getTableName()).select("id");
+    const query = db3.from(context.getTableName()).select("id");
     if (id) {
       query.where({ id });
     }
@@ -3260,11 +3298,11 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
     if (!item) {
       return null;
     }
-    const chunks = await db2.from(context.getChunksTableName()).where({ source: item.id }).select("id");
+    const chunks = await db3.from(context.getChunksTableName()).where({ source: item.id }).select("id");
     if (chunks.length > 0) {
-      await db2.from(context.getChunksTableName()).where({ source: item.id }).delete();
+      await db3.from(context.getChunksTableName()).where({ source: item.id }).delete();
     }
-    const mutation = db2.from(context.getTableName()).where({ id: item.id }).delete().returning("id");
+    const mutation = db3.from(context.getTableName()).where({ id: item.id }).delete().returning("id");
     const result = await mutation;
     return result;
   };
@@ -3319,7 +3357,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       });
       return;
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const context = contexts.find((context2) => context2.id === req.params.context);
     if (!context) {
       res.status(400).json({
@@ -3331,11 +3369,11 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
     if (!itemsTableExists) {
       await context.createItemsTable();
     }
-    const chunksTableExists = await db2.schema.hasTable(context.getChunksTableName());
+    const chunksTableExists = await db3.schema.hasTable(context.getChunksTableName());
     if (!chunksTableExists) {
       await context.createChunksTable();
     }
-    const item = await db2.from(context.getTableName()).where({ id: req.params.id }).select("*").first();
+    const item = await db3.from(context.getTableName()).where({ id: req.params.id }).select("*").first();
     if (!item) {
       res.status(404).json({
         message: "Item not found."
@@ -3343,7 +3381,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       return;
     }
     console.log("[EXULU] chunks table name.", context.getChunksTableName());
-    const chunks = await db2.from(context.getChunksTableName()).where({ source: req.params.id }).select("id", "content", "source", "embedding", "chunk_index", "created_at", "updated_at");
+    const chunks = await db3.from(context.getChunksTableName()).where({ source: req.params.id }).select("id", "content", "source", "embedding", "chunk_index", "created_at", "updated_at");
     console.log("[EXULU] chunks", chunks);
     res.status(200).json({
       ...item,
@@ -3593,7 +3631,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
       return;
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     const type = req.body.type;
     if (!Object.values(STATISTICS_TYPE_ENUM).includes(type)) {
       res.status(400).json({
@@ -3607,7 +3645,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       from = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
       to = /* @__PURE__ */ new Date();
     }
-    const query = db2.from("statistics").select("*");
+    const query = db3.from("statistics").select("*");
     query.where("name", "count");
     query.andWhere("type", type);
     query.andWhere("createdAt", ">=", from);
@@ -3642,7 +3680,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
       return;
     }
-    const { db: db2 } = await postgresClient();
+    const { db: db3 } = await postgresClient();
     let from = new Date(req.body.from);
     let to = new Date(req.body.to);
     if (!from || !to) {
@@ -3650,7 +3688,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       to = /* @__PURE__ */ new Date();
     }
     let promises2 = Object.values(STATISTICS_TYPE_ENUM).map(async (type) => {
-      const result = await db2.from("statistics").where("name", "count").andWhere("type", type).andWhere("createdAt", ">=", from).andWhere("createdAt", "<=", to).sum("total as total");
+      const result = await db3.from("statistics").where("name", "count").andWhere("type", type).andWhere("createdAt", ">=", from).andWhere("createdAt", "<=", to).sum("total as total");
       return {
         [type]: result[0]?.total || 0
       };
@@ -3671,9 +3709,9 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
       return;
     }
-    const { db: db2 } = await postgresClient();
-    const statistics = await db2("statistics").where("name", "count").andWhere("type", "context.retrieve").sum("total as total").first();
-    const response = await db2("jobs").select(db2.raw(`to_char("createdAt", 'YYYY-MM-DD') as date`)).count("* as count").where("type", "embedder").groupByRaw(`to_char("createdAt", 'YYYY-MM-DD')`).then((rows) => ({
+    const { db: db3 } = await postgresClient();
+    const statistics = await db3("statistics").where("name", "count").andWhere("type", "context.retrieve").sum("total as total").first();
+    const response = await db3("jobs").select(db3.raw(`to_char("createdAt", 'YYYY-MM-DD') as date`)).count("* as count").where("type", "embedder").groupByRaw(`to_char("createdAt", 'YYYY-MM-DD')`).then((rows) => ({
       jobs: rows
     }));
     let jobs = [];
@@ -3683,7 +3721,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
         count: job.count
       }));
     }
-    const embeddingsCountResult = await db2("jobs").where("type", "embedder").count("* as count").first();
+    const embeddingsCountResult = await db3("jobs").where("type", "embedder").count("* as count").first();
     res.status(200).json({
       active: contexts.filter((context) => context.active).length,
       inactive: contexts.filter((context) => !context.active).length,
@@ -3883,8 +3921,8 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
         });
         return;
       }
-      const { db: db2 } = await postgresClient();
-      const agentInstance = await db2.from("agents").where({
+      const { db: db3 } = await postgresClient();
+      const agentInstance = await db3.from("agents").where({
         id: instance
       }).first();
       if (!agentInstance) {
@@ -4019,26 +4057,18 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
   app.use("/gateway/anthropic/:id", import_express3.default.raw({ type: "*/*", limit: REQUEST_SIZE_LIMIT }), async (req, res) => {
     const path3 = req.url;
     const url = `${TARGET_API}${path3}`;
-    console.log("[PROXY] Manual proxy to:", url);
-    console.log("[PROXY] Method:", req.method);
-    console.log("[PROXY] Headers:", Object.keys(req.headers));
-    console.log("[PROXY] Request body length:", req.body ? req.body.length : 0);
-    console.log("[PROXY] Request model name:", req.body.model);
-    console.log("[PROXY] Request stream:", req.body.stream);
-    console.log("[PROXY] Request messages:", req.body.messages?.length);
     try {
-      console.log("[PROXY] Request body tools array length:", req.body.tools?.length);
       if (!req.body.tools) {
         req.body.tools = [];
       }
       const authenticationResult = await requestValidators.authenticate(req);
       if (!authenticationResult.user?.id) {
+        console.log("[EXULU] failed authentication result", authenticationResult);
         res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
         return;
       }
-      console.log("[EXULU] authentication result", authenticationResult);
-      const { db: db2 } = await postgresClient();
-      const agent = await db2.from("agents").where({
+      const { db: db3 } = await postgresClient();
+      const agent = await db3.from("agents").where({
         id: req.params.id
       }).first();
       if (!agent) {
@@ -4049,7 +4079,7 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
         res.end(Buffer.from(arrayBuffer));
         return;
       }
-      console.log("[EXULU] agent", agent?.name);
+      console.log("[EXULU] anthropic proxy called for agent:", agent?.name);
       if (!process.env.NEXTAUTH_SECRET) {
         const arrayBuffer = createCustomAnthropicStreamingMessage(CLAUDE_MESSAGES.missing_nextauth_secret);
         res.setHeader("Content-Type", "application/json");
@@ -4071,14 +4101,11 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
       };
       if (req.headers["accept"]) headers["accept"] = req.headers["accept"];
       if (req.headers["user-agent"]) headers["user-agent"] = req.headers["user-agent"];
-      console.log("[EXULU] anthropic api key", anthropicApiKey);
       const response = await fetch(url, {
         method: req.method,
         headers,
         body: req.method !== "GET" ? JSON.stringify(req.body) : void 0
       });
-      console.log("[PROXY] Response:", response);
-      console.log("[PROXY] Response:", response.body);
       await updateStatistic({
         name: "count",
         label: "Claude Code",
@@ -4104,14 +4131,12 @@ var createExpressRoutes = async (app, agents, tools, workflows, contexts) => {
           const { done, value } = await reader.read();
           if (done) break;
           const chunk = decoder.decode(value, { stream: true });
-          console.log("[PROXY] Chunk:", chunk);
           res.write(chunk);
         }
         res.end();
         return;
       }
       const data = await response.arrayBuffer();
-      console.log("[PROXY] Data:", data);
       res.end(Buffer.from(data));
     } catch (error) {
       console.error("[PROXY] Manual proxy error:", error);
@@ -4236,8 +4261,8 @@ var defaultLogsDir = import_path.default.join(process.cwd(), "logs");
 var redisConnection;
 var createWorkers = async (queues2, contexts, workflows, _logsDir) => {
   if (!redisServer.host || !redisServer.port) {
-    console.error("[EXULU] you are trying to start workers, but no redis server is configured in the environment.");
-    throw new Error("No redis server configured in the environment, so cannot start workers.");
+    console.error("[EXULU] you are trying to start worker, but no redis server is configured in the environment.");
+    throw new Error("No redis server configured in the environment, so cannot start worker.");
   }
   if (!redisConnection) {
     redisConnection = new import_ioredis.default({
@@ -4251,7 +4276,7 @@ var createWorkers = async (queues2, contexts, workflows, _logsDir) => {
     const worker = new import_bullmq7.Worker(
       `${queue}`,
       async (bullmqJob) => {
-        const { db: db2 } = await postgresClient();
+        const { db: db3 } = await postgresClient();
         try {
           bullmq.validate(bullmqJob);
           if (bullmqJob.data.type === "embedder") {
@@ -4293,19 +4318,19 @@ var createWorkers = async (queues2, contexts, workflows, _logsDir) => {
               label: context.name,
               trigger: bullmqJob.data.trigger || "unknown"
             });
-            const mongoRecord = await db2.from("jobs").where({ redis: bullmqJob.id }).first();
+            const mongoRecord = await db3.from("jobs").where({ redis: bullmqJob.id }).first();
             if (!mongoRecord) {
               throw new Error("Job not found in the database.");
             }
             const finishedAt = /* @__PURE__ */ new Date();
             const duration = (finishedAt.getTime() - new Date(mongoRecord.createdAt).getTime()) / 1e3;
-            await db2.from("jobs").where({ redis: bullmqJob.id }).update({
+            await db3.from("jobs").where({ redis: bullmqJob.id }).update({
               status: "completed",
               finishedAt,
               duration,
               result: JSON.stringify(result)
             });
-            await db2.from((void 0).getTableName()).where({ id: result[0].id }).update({
+            await db3.from((void 0).getTableName()).where({ id: result[0].id }).update({
               embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
             }).returning("id");
             return result;
@@ -4315,14 +4340,14 @@ var createWorkers = async (queues2, contexts, workflows, _logsDir) => {
             if (!workflow) {
               throw new Error(`Workflow ${bullmqJob.data.workflow} not found in the registry.`);
             }
-            const exuluJob = await db2.from("jobs").where({ redis: bullmqJob.id }).first();
+            const exuluJob = await db3.from("jobs").where({ redis: bullmqJob.id }).first();
             if (!exuluJob) {
               throw new Error("Job not found in the database.");
             }
             const result = await bullmq.process.workflow(bullmqJob, exuluJob, workflow, logsDir);
             const finishedAt = /* @__PURE__ */ new Date();
             const duration = (finishedAt.getTime() - new Date(exuluJob.createdAt).getTime()) / 1e3;
-            await db2.from("jobs").where({ redis: bullmqJob.id }).update({
+            await db3.from("jobs").where({ redis: bullmqJob.id }).update({
               status: "completed",
               finishedAt,
               duration,
@@ -4331,7 +4356,7 @@ var createWorkers = async (queues2, contexts, workflows, _logsDir) => {
             return result;
           }
         } catch (error) {
-          await db2.from("jobs").where({ redis: bullmqJob.id }).update({
+          await db3.from("jobs").where({ redis: bullmqJob.id }).update({
             status: "failed",
             finishedAt: /* @__PURE__ */ new Date(),
             error: error instanceof Error ? error.message : String(error)
@@ -4703,259 +4728,6 @@ var getTicket = new ExuluTool({
   }
 });
 
-// src/auth/generate-key.ts
-var import_bcryptjs2 = __toESM(require("bcryptjs"), 1);
-var SALT_ROUNDS = 12;
-async function encryptString(string) {
-  const hash = await import_bcryptjs2.default.hash(string, SALT_ROUNDS);
-  return hash;
-}
-var generateApiKey = async (name, email) => {
-  const { db: db2 } = await postgresClient();
-  console.log("[EXULU] Inserting default user and admin role.");
-  const existingRole = await db2.from("roles").where({ name: "admin" }).first();
-  let roleId;
-  if (!existingRole) {
-    console.log("[EXULU] Creating default admin role.");
-    const role = await db2.from("roles").insert({
-      name: "admin",
-      is_admin: true,
-      agents: []
-    }).returning("id");
-    roleId = role[0].id;
-  } else {
-    roleId = existingRole.id;
-  }
-  const newKeyName = name;
-  const plainKey = `sk_${Math.random().toString(36).substring(2, 15)}_${Math.random().toString(36).substring(2, 15)}`;
-  const postFix = `/${newKeyName.toLowerCase().trim().replaceAll(" ", "_")}`;
-  const encryptedKey = await encryptString(plainKey);
-  const existingApiUser = await db2.from("users").where({ email }).first();
-  if (!existingApiUser) {
-    console.log("[EXULU] Creating default api user.");
-    await db2.from("users").insert({
-      name,
-      email,
-      super_admin: true,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      type: "api",
-      emailVerified: /* @__PURE__ */ new Date(),
-      apikey: `${encryptedKey}${postFix}`,
-      // password: "admin", todo add this again when we implement password auth / encryption as alternative to OTP
-      role: roleId
-    });
-    console.log("[EXULU] Default api user created. Key: ", `${plainKey}${postFix}`);
-  } else {
-    console.log("[EXULU] API user with that name already exists.");
-  }
-  console.log("[EXULU] Key generated, copy and use the plain key from here, you will not be able to access it again.");
-  console.log("[EXULU] Key: ", `${plainKey}${postFix}`);
-  return {
-    key: `${plainKey}${postFix}`
-  };
-};
-
-// src/postgres/init-db.ts
-var up = async function(knex) {
-  if (!await knex.schema.hasTable("agent_sessions")) {
-    console.log("[EXULU] Creating agent_sessions table.");
-    await knex.schema.createTable("agent_sessions", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of agentSessionsSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("agent_messages")) {
-    console.log("[EXULU] Creating agent_messages table.");
-    await knex.schema.createTable("agent_messages", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of agentMessagesSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("roles")) {
-    console.log("[EXULU] Creating roles table.");
-    await knex.schema.createTable("roles", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of rolesSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("eval_results")) {
-    console.log("[EXULU] Creating eval_results table.");
-    await knex.schema.createTable("eval_results", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of evalResultsSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("statistics")) {
-    console.log("[EXULU] Creating statistics table.");
-    await knex.schema.createTable("statistics", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of statisticsSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("jobs")) {
-    console.log("[EXULU] Creating jobs table.");
-    await knex.schema.createTable("jobs", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of jobsSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("agents")) {
-    console.log("[EXULU] Creating agents table.");
-    await knex.schema.createTable("agents", (table) => {
-      table.uuid("id").primary().defaultTo(knex.fn.uuid());
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      for (const field of agentsSchema.fields) {
-        const { type, name, default: defaultValue } = field;
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("verification_token")) {
-    console.log("[EXULU] Creating verification_token table.");
-    await knex.schema.createTable("verification_token", (table) => {
-      table.text("identifier").notNullable();
-      table.timestamp("expires", { useTz: true }).notNullable();
-      table.text("token").notNullable();
-      table.primary(["identifier", "token"]);
-    });
-  }
-  if (!await knex.schema.hasTable("users")) {
-    console.log("[EXULU] Creating users table.");
-    await knex.schema.createTable("users", (table) => {
-      table.increments("id").primary();
-      table.timestamp("createdAt").defaultTo(knex.fn.now());
-      table.timestamp("updatedAt").defaultTo(knex.fn.now());
-      table.string("name", 255);
-      table.string("password", 255);
-      table.string("email", 255);
-      table.timestamp("emailVerified", { useTz: true });
-      table.text("image");
-      for (const field of usersSchema.fields) {
-        console.log("[EXULU] field", field);
-        const { type, name, default: defaultValue } = field;
-        if (name === "id" || name === "name" || name === "email" || name === "emailVerified" || name === "image") {
-          continue;
-        }
-        if (!type || !name) {
-          continue;
-        }
-        mapType(table, type, sanitizeName(name), defaultValue);
-      }
-    });
-  }
-  if (!await knex.schema.hasTable("accounts")) {
-    console.log("[EXULU] Creating accounts table.");
-    await knex.schema.createTable("accounts", (table) => {
-      table.increments("id").primary();
-      table.integer("userId").notNullable();
-      table.string("type", 255).notNullable();
-      table.string("provider", 255).notNullable();
-      table.string("providerAccountId", 255).notNullable();
-      table.text("refresh_token");
-      table.text("access_token");
-      table.bigInteger("expires_at");
-      table.text("id_token");
-      table.text("scope");
-      table.text("session_state");
-      table.text("token_type");
-    });
-  }
-};
-var execute = async () => {
-  const { db: db2 } = await postgresClient();
-  console.log("[EXULU] Checking Exulu IMP database status.");
-  await up(db2);
-  console.log("[EXULU] Inserting default user and admin role.");
-  const existingRole = await db2.from("roles").where({ name: "admin" }).first();
-  let roleId;
-  if (!existingRole) {
-    console.log("[EXULU] Creating default admin role.");
-    const role = await db2.from("roles").insert({
-      name: "admin",
-      is_admin: true,
-      agents: JSON.stringify([])
-    }).returning("id");
-    roleId = role[0].id;
-  } else {
-    roleId = existingRole.id;
-  }
-  const existingUser = await db2.from("users").where({ email: "admin@exulu.com" }).first();
-  if (!existingUser) {
-    const password = await encryptString("admin");
-    console.log("[EXULU] Creating default admin user.");
-    await db2.from("users").insert({
-      name: "exulu",
-      email: "admin@exulu.com",
-      super_admin: true,
-      createdAt: /* @__PURE__ */ new Date(),
-      emailVerified: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      password,
-      type: "user",
-      role: roleId
-    });
-  }
-  const { key } = await generateApiKey("exulu", "api@exulu.com");
-  console.log("[EXULU] Database initialized.");
-  console.log("[EXULU] Default api key: ", `${key}`);
-  console.log("[EXULU] Default password if using password auth: ", `admin`);
-  console.log("[EXULU] Default email if using password auth: ", `admin@exulu.com`);
-  return;
-};
-
 // src/registry/index.ts
 var ExuluApp = class {
   _agents = [];
@@ -4970,7 +4742,6 @@ var ExuluApp = class {
   // Factory function so we can async 
   // initialize the MCP server if needed.
   create = async ({ contexts, agents, workflows, config, tools }) => {
-    await execute();
     this._workflows = workflows ?? [];
     this._contexts = contexts ?? {};
     this._agents = [
@@ -6272,6 +6043,257 @@ var SentenceChunker = class _SentenceChunker extends BaseChunker {
   }
 };
 
+// src/auth/generate-key.ts
+var import_bcryptjs2 = __toESM(require("bcryptjs"), 1);
+var SALT_ROUNDS = 12;
+async function encryptString(string) {
+  const hash = await import_bcryptjs2.default.hash(string, SALT_ROUNDS);
+  return hash;
+}
+var generateApiKey = async (name, email) => {
+  const { db: db3 } = await postgresClient();
+  console.log("[EXULU] Inserting default user and admin role.");
+  const existingRole = await db3.from("roles").where({ name: "admin" }).first();
+  let roleId;
+  if (!existingRole) {
+    console.log("[EXULU] Creating default admin role.");
+    const role = await db3.from("roles").insert({
+      name: "admin",
+      is_admin: true,
+      agents: []
+    }).returning("id");
+    roleId = role[0].id;
+  } else {
+    roleId = existingRole.id;
+  }
+  const newKeyName = name;
+  const plainKey = `sk_${Math.random().toString(36).substring(2, 15)}_${Math.random().toString(36).substring(2, 15)}`;
+  const postFix = `/${newKeyName.toLowerCase().trim().replaceAll(" ", "_")}`;
+  const encryptedKey = await encryptString(plainKey);
+  const existingApiUser = await db3.from("users").where({ email }).first();
+  if (!existingApiUser) {
+    console.log("[EXULU] Creating default api user.");
+    await db3.from("users").insert({
+      name,
+      email,
+      super_admin: true,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      type: "api",
+      emailVerified: /* @__PURE__ */ new Date(),
+      apikey: `${encryptedKey}${postFix}`,
+      // password: "admin", todo add this again when we implement password auth / encryption as alternative to OTP
+      role: roleId
+    });
+    console.log("[EXULU] Default api user created. Key: ", `${plainKey}${postFix}`);
+  } else {
+    console.log("[EXULU] API user with that name already exists.");
+  }
+  return {
+    key: `${plainKey}${postFix}`
+  };
+};
+
+// src/postgres/init-db.ts
+var up = async function(knex) {
+  if (!await knex.schema.hasTable("agent_sessions")) {
+    console.log("[EXULU] Creating agent_sessions table.");
+    await knex.schema.createTable("agent_sessions", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of agentSessionsSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("agent_messages")) {
+    console.log("[EXULU] Creating agent_messages table.");
+    await knex.schema.createTable("agent_messages", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of agentMessagesSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("roles")) {
+    console.log("[EXULU] Creating roles table.");
+    await knex.schema.createTable("roles", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of rolesSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("eval_results")) {
+    console.log("[EXULU] Creating eval_results table.");
+    await knex.schema.createTable("eval_results", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of evalResultsSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("statistics")) {
+    console.log("[EXULU] Creating statistics table.");
+    await knex.schema.createTable("statistics", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of statisticsSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("jobs")) {
+    console.log("[EXULU] Creating jobs table.");
+    await knex.schema.createTable("jobs", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of jobsSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("agents")) {
+    console.log("[EXULU] Creating agents table.");
+    await knex.schema.createTable("agents", (table) => {
+      table.uuid("id").primary().defaultTo(knex.fn.uuid());
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      for (const field of agentsSchema.fields) {
+        const { type, name, default: defaultValue } = field;
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("verification_token")) {
+    console.log("[EXULU] Creating verification_token table.");
+    await knex.schema.createTable("verification_token", (table) => {
+      table.text("identifier").notNullable();
+      table.timestamp("expires", { useTz: true }).notNullable();
+      table.text("token").notNullable();
+      table.primary(["identifier", "token"]);
+    });
+  }
+  if (!await knex.schema.hasTable("users")) {
+    console.log("[EXULU] Creating users table.");
+    await knex.schema.createTable("users", (table) => {
+      table.increments("id").primary();
+      table.timestamp("createdAt").defaultTo(knex.fn.now());
+      table.timestamp("updatedAt").defaultTo(knex.fn.now());
+      table.string("name", 255);
+      table.string("password", 255);
+      table.string("email", 255);
+      table.timestamp("emailVerified", { useTz: true });
+      table.text("image");
+      for (const field of usersSchema.fields) {
+        console.log("[EXULU] field", field);
+        const { type, name, default: defaultValue } = field;
+        if (name === "id" || name === "name" || name === "email" || name === "emailVerified" || name === "image") {
+          continue;
+        }
+        if (!type || !name) {
+          continue;
+        }
+        mapType(table, type, sanitizeName(name), defaultValue);
+      }
+    });
+  }
+  if (!await knex.schema.hasTable("accounts")) {
+    console.log("[EXULU] Creating accounts table.");
+    await knex.schema.createTable("accounts", (table) => {
+      table.increments("id").primary();
+      table.integer("userId").notNullable();
+      table.string("type", 255).notNullable();
+      table.string("provider", 255).notNullable();
+      table.string("providerAccountId", 255).notNullable();
+      table.text("refresh_token");
+      table.text("access_token");
+      table.bigInteger("expires_at");
+      table.text("id_token");
+      table.text("scope");
+      table.text("session_state");
+      table.text("token_type");
+    });
+  }
+};
+var execute = async () => {
+  const { db: db3 } = await postgresClient();
+  console.log("[EXULU] Checking Exulu IMP database status.");
+  await up(db3);
+  console.log("[EXULU] Inserting default user and admin role.");
+  const existingRole = await db3.from("roles").where({ name: "admin" }).first();
+  let roleId;
+  if (!existingRole) {
+    console.log("[EXULU] Creating default admin role.");
+    const role = await db3.from("roles").insert({
+      name: "admin",
+      is_admin: true,
+      agents: JSON.stringify([])
+    }).returning("id");
+    roleId = role[0].id;
+  } else {
+    roleId = existingRole.id;
+  }
+  const existingUser = await db3.from("users").where({ email: "admin@exulu.com" }).first();
+  if (!existingUser) {
+    const password = await encryptString("admin");
+    console.log("[EXULU] Creating default admin user.");
+    await db3.from("users").insert({
+      name: "exulu",
+      email: "admin@exulu.com",
+      super_admin: true,
+      createdAt: /* @__PURE__ */ new Date(),
+      emailVerified: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      password,
+      type: "user",
+      role: roleId
+    });
+  }
+  const { key } = await generateApiKey("exulu", "api@exulu.com");
+  console.log("[EXULU] Database initialized.");
+  console.log("[EXULU] Default api key: ", `${key}`);
+  console.log("[EXULU] Default password if using password auth: ", `admin`);
+  console.log("[EXULU] Default email if using password auth: ", `admin@exulu.com`);
+  return;
+};
+
 // src/index.ts
 var ExuluJobs = {
   redis: redisClient,
@@ -6279,6 +6301,11 @@ var ExuluJobs = {
     validate: validateJob
   }
 };
+var db2 = {
+  init: async () => {
+    await execute();
+  }
+};
 var ExuluChunkers = {
   sentence: SentenceChunker,
   recursive: {
@@ -6303,5 +6330,6 @@ var ExuluChunkers = {
   ExuluSource,
   ExuluTool,
   ExuluWorkflow,
-  ExuluZodFileType
+  ExuluZodFileType,
+  db
 });