@exulu/backend 1.4.0 → 1.5.0

package/dist/index.js

@@ -69,6 +69,32 @@ var validateJob = (job) => {
   return job;
 };
 
+// src/registry/classes.ts
+import "zod";
+import "bullmq";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import { generateObject, generateText, streamText, tool } from "ai";
+
+// types/enums/statistics.ts
+var STATISTICS_TYPE_ENUM = {
+  CONTEXT_RETRIEVE: "context.retrieve",
+  SOURCE_UPDATE: "source.update",
+  EMBEDDER_UPSERT: "embedder.upsert",
+  EMBEDDER_GENERATE: "embedder.generate",
+  EMBEDDER_DELETE: "embedder.delete",
+  WORKFLOW_RUN: "workflow.run",
+  CONTEXT_UPSERT: "context.upsert",
+  TOOL_CALL: "tool.call",
+  AGENT_RUN: "agent.run"
+};
+
+// types/enums/eval-types.ts
+var EVAL_TYPES_ENUM = {
+  llm_as_judge: "llm_as_judge"
+};
+
 // src/postgres/client.ts
 import Knex from "knex";
 import "knex";
@@ -77,7 +103,12 @@ var db = {};
 async function postgresClient() {
   if (!db["exulu"]) {
     try {
-      console.log("[EXULU] Initializing exulu database.");
+      console.log("[EXULU] Connecting to exulu database.");
+      console.log("[EXULU] POSTGRES_DB_HOST:", process.env.POSTGRES_DB_HOST);
+      console.log("[EXULU] POSTGRES_DB_PORT:", process.env.POSTGRES_DB_PORT);
+      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);
       const knex = Knex({
         client: "pg",
         connection: {
@@ -101,745 +132,142 @@ async function postgresClient() {
   };
 }
 
-// src/postgres/core-schema.ts
-var agentMessagesSchema = {
-  name: {
-    plural: "agent_messages",
-    singular: "agent_message"
-  },
-  fields: [
-    {
-      name: "content",
-      type: "text"
-    },
-    {
-      name: "title",
-      type: "text"
-    },
-    {
-      name: "session",
-      type: "text"
-    }
-  ]
-};
-var agentSessionsSchema = {
-  name: {
-    plural: "agent_sessions",
-    singular: "agent_session"
-  },
-  fields: [
-    {
-      name: "agent",
-      type: "uuid"
-    },
+// src/registry/classes.ts
+import pgvector2 from "pgvector/knex";
+
+// src/registry/decoraters/bullmq.ts
+import "bullmq";
+import { v4 as uuidv4 } from "uuid";
+var bullmqDecorator = async ({
+  label,
+  type,
+  workflow,
+  embedder,
+  inputs,
+  queue,
+  user,
+  agent,
+  session,
+  configuration,
+  updater,
+  context,
+  steps,
+  source,
+  documents,
+  trigger,
+  item
+}) => {
+  const redisId = uuidv4();
+  const job = await queue.add(
+    `${embedder || workflow}`,
     {
-      name: "user",
-      // next auth stores users with id type SERIAL, so we need to use number
-      type: "number"
+      type: `${type}`,
+      ...embedder && { embedder },
+      ...workflow && { workflow },
+      ...configuration && { configuration },
+      ...updater && { updater },
+      ...context && { context },
+      ...source && { source },
+      ...documents && { documents },
+      ...steps && { steps },
+      ...trigger && { trigger },
+      ...item && { item },
+      agent,
+      user,
+      inputs,
+      label,
+      session
     },
     {
-      name: "title",
-      type: "text"
+      jobId: redisId
     }
-  ]
+  );
+  const { db: db2 } = await postgresClient();
+  const now = /* @__PURE__ */ new Date();
+  console.log("[EXULU] scheduling new job", inputs);
+  const insertData = {
+    name: `${label}`,
+    redis: job.id,
+    status: "waiting",
+    type,
+    inputs,
+    agent,
+    item,
+    createdAt: now,
+    updatedAt: now,
+    user,
+    session,
+    ...embedder && { embedder },
+    ...workflow && { workflow },
+    ...configuration && { configuration },
+    ...steps && { steps },
+    ...updater && { updater },
+    ...context && { context },
+    ...source && { source },
+    ...documents && { documents: documents.map((doc2) => doc2.id) },
+    ...trigger && { trigger }
+  };
+  await db2("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();
+  if (!doc?.id) {
+    throw new Error("Failed to get job ID after insert/update");
+  }
+  console.log("[EXULU] created job", doc?.id);
+  return {
+    ...job,
+    id: doc?.id,
+    redis: job.id
+  };
 };
-var usersSchema = {
-  name: {
-    plural: "users",
-    singular: "user"
-  },
-  fields: [
-    {
-      name: "firstname",
-      type: "text"
-    },
-    {
-      name: "name",
-      type: "text"
-    },
-    {
-      name: "lastname",
-      type: "text"
-    },
-    {
-      name: "email",
-      type: "text",
-      index: true
-    },
-    {
-      name: "temporary_token",
-      type: "text"
-    },
-    {
-      name: "type",
-      type: "text",
-      index: true
-    },
-    {
-      name: "profile_image",
-      type: "text"
-    },
-    {
-      name: "super_admin",
-      type: "boolean",
-      default: false
-    },
-    {
-      name: "status",
-      type: "text"
-    },
-    {
-      name: "emailVerified",
-      type: "text"
-    },
-    {
-      name: "apikey",
-      type: "text"
-    },
-    {
-      name: "last_used",
-      type: "date"
-    },
-    {
-      name: "anthropic_token",
-      type: "text"
-    },
-    {
-      name: "role",
-      type: "uuid"
-    }
-  ]
+
+// src/registry/utils/map-types.ts
+var mapType = (t, type, name, defaultValue) => {
+  if (type === "text") {
+    t.text(name);
+    return;
+  }
+  if (type === "longText") {
+    t.text(name);
+    return;
+  }
+  if (type === "shortText") {
+    t.string(name, 100);
+    return;
+  }
+  if (type === "number") {
+    t.float(name);
+    return;
+  }
+  if (type === "boolean") {
+    t.boolean(name).defaultTo(defaultValue || false);
+    return;
+  }
+  if (type === "code") {
+    t.text(name);
+    return;
+  }
+  if (type === "json") {
+    t.jsonb(name);
+    return;
+  }
+  if (type === "date") {
+    t.timestamp(name);
+    return;
+  }
+  if (type === "uuid") {
+    t.uuid(name);
+    return;
+  }
+  throw new Error("Invalid type: " + type);
 };
-var rolesSchema = {
-  name: {
-    plural: "roles",
-    singular: "role"
-  },
-  fields: [
-    {
-      name: "name",
-      type: "text"
-    },
-    {
-      name: "is_admin",
-      type: "boolean",
-      default: false
-    },
-    {
-      name: "agents",
-      type: "json"
-    }
-  ]
-};
-var statisticsSchema = {
-  name: {
-    plural: "statistics",
-    singular: "statistic"
-  },
-  fields: [
-    {
-      name: "name",
-      type: "text"
-    },
-    {
-      name: "label",
-      type: "text"
-    },
-    {
-      name: "type",
-      type: "text"
-    },
-    {
-      name: "total",
-      type: "number"
-    }
-  ]
-};
-var workflowSchema = {
-  name: {
-    plural: "workflows",
-    singular: "workflow"
-  },
-  fields: [
-    {
-      name: "workflow_name",
-      type: "text"
-    },
-    {
-      name: "run_id",
-      type: "text"
-    },
-    {
-      name: "snapshot",
-      type: "text"
-    }
-  ]
-};
-var evalResultsSchema = {
-  name: {
-    plural: "eval_results",
-    singular: "eval_result"
-  },
-  fields: [
-    {
-      name: "input",
-      type: "longText"
-    },
-    {
-      name: "output",
-      type: "longText"
-    },
-    {
-      name: "duration",
-      type: "number"
-    },
-    {
-      name: "category",
-      type: "text"
-    },
-    {
-      name: "metadata",
-      type: "json"
-    },
-    {
-      name: "result",
-      type: "number"
-    },
-    {
-      name: "agent_id",
-      type: "uuid"
-    },
-    {
-      name: "workflow_id",
-      type: "uuid"
-    },
-    {
-      name: "eval_type",
-      type: "text"
-    },
-    {
-      name: "eval_name",
-      type: "text"
-    },
-    {
-      name: "comment",
-      type: "longText"
-    }
-  ]
-};
-var jobsSchema = {
-  name: {
-    plural: "jobs",
-    singular: "job"
-  },
-  fields: [
-    {
-      name: "redis",
-      type: "text"
-    },
-    {
-      name: "session",
-      type: "text"
-    },
-    {
-      name: "status",
-      type: "text"
-    },
-    {
-      name: "type",
-      type: "text"
-    },
-    {
-      name: "result",
-      type: "longText"
-    },
-    {
-      name: "name",
-      type: "text"
-    },
-    {
-      name: "agent",
-      type: "uuid"
-    },
-    {
-      name: "workflow",
-      type: "uuid"
-    },
-    {
-      name: "user",
-      // next auth stores users with id type SERIAL, so we need to use number
-      type: "number"
-    },
-    {
-      name: "item",
-      type: "uuid"
-    },
-    {
-      name: "steps",
-      type: "number"
-    },
-    {
-      name: "inputs",
-      type: "json"
-    },
-    {
-      name: "finished_at",
-      type: "date"
-    },
-    {
-      name: "duration",
-      type: "number"
-    }
-  ]
-};
-var agentsSchema = {
-  name: {
-    plural: "agents",
-    singular: "agent"
-  },
-  fields: [
-    {
-      name: "name",
-      type: "text"
-    },
-    {
-      name: "description",
-      type: "text"
-    },
-    {
-      name: "extensions",
-      type: "json"
-    },
-    {
-      name: "backend",
-      type: "text"
-    },
-    {
-      name: "type",
-      type: "text"
-    },
-    {
-      name: "active",
-      type: "boolean",
-      default: false
-    },
-    {
-      name: "public",
-      type: "boolean",
-      default: false
-    },
-    {
-      name: "tools",
-      type: "json"
-    }
-  ]
-};
-
-// src/registry/utils/map-types.ts
-var mapType = (t, type, name, defaultValue) => {
-  if (type === "text") {
-    t.text(name);
-    return;
-  }
-  if (type === "longText") {
-    t.text(name);
-    return;
-  }
-  if (type === "shortText") {
-    t.string(name, 100);
-    return;
-  }
-  if (type === "number") {
-    t.float(name);
-    return;
-  }
-  if (type === "boolean") {
-    t.boolean(name).defaultTo(defaultValue || false);
-    return;
-  }
-  if (type === "code") {
-    t.text(name);
-    return;
-  }
-  if (type === "json") {
-    t.jsonb(name);
-    return;
-  }
-  if (type === "date") {
-    t.timestamp(name);
-    return;
-  }
-  if (type === "uuid") {
-    t.uuid(name);
-    return;
-  }
-  throw new Error("Invalid type: " + type);
-};
-
-// src/registry/utils/sanitize-name.ts
-var sanitizeName = (name) => {
-  return name.toLowerCase().replace(/ /g, "_");
-};
-
-// src/auth/generate-key.ts
-import bcrypt from "bcryptjs";
-var SALT_ROUNDS = 12;
-async function encryptString(string) {
-  const hash = await bcrypt.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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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")) {
-    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 () => {
-  console.log("[EXULU] Initializing database.");
-  const { db: db2 } = await postgresClient();
-  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/classes.ts
-import "zod";
-import "bullmq";
-import { z } from "zod";
-import * as fs from "fs";
-import * as path from "path";
-import { generateObject, generateText, streamText, tool } from "ai";
-
-// types/enums/statistics.ts
-var STATISTICS_TYPE_ENUM = {
-  CONTEXT_RETRIEVE: "context.retrieve",
-  SOURCE_UPDATE: "source.update",
-  EMBEDDER_UPSERT: "embedder.upsert",
-  EMBEDDER_GENERATE: "embedder.generate",
-  EMBEDDER_DELETE: "embedder.delete",
-  WORKFLOW_RUN: "workflow.run",
-  CONTEXT_UPSERT: "context.upsert",
-  TOOL_CALL: "tool.call",
-  AGENT_RUN: "agent.run"
-};
-
-// types/enums/eval-types.ts
-var EVAL_TYPES_ENUM = {
-  llm_as_judge: "llm_as_judge"
-};
-
-// src/registry/classes.ts
-import pgvector2 from "pgvector/knex";
 
-// src/registry/decoraters/bullmq.ts
-import "bullmq";
-import { v4 as uuidv4 } from "uuid";
-var bullmqDecorator = async ({
-  label,
-  type,
-  workflow,
-  embedder,
-  inputs,
-  queue,
-  user,
-  agent,
-  session,
-  configuration,
-  updater,
-  context,
-  steps,
-  source,
-  documents,
-  trigger,
-  item
-}) => {
-  const redisId = uuidv4();
-  const job = await queue.add(
-    `${embedder || workflow}`,
-    {
-      type: `${type}`,
-      ...embedder && { embedder },
-      ...workflow && { workflow },
-      ...configuration && { configuration },
-      ...updater && { updater },
-      ...context && { context },
-      ...source && { source },
-      ...documents && { documents },
-      ...steps && { steps },
-      ...trigger && { trigger },
-      ...item && { item },
-      agent,
-      user,
-      inputs,
-      label,
-      session
-    },
-    {
-      jobId: redisId
-    }
-  );
-  const { db: db2 } = await postgresClient();
-  const now = /* @__PURE__ */ new Date();
-  console.log("[EXULU] scheduling new job", inputs);
-  const insertData = {
-    name: `${label}`,
-    redis: job.id,
-    status: "waiting",
-    type,
-    inputs,
-    agent,
-    item,
-    createdAt: now,
-    updatedAt: now,
-    user,
-    session,
-    ...embedder && { embedder },
-    ...workflow && { workflow },
-    ...configuration && { configuration },
-    ...steps && { steps },
-    ...updater && { updater },
-    ...context && { context },
-    ...source && { source },
-    ...documents && { documents: documents.map((doc2) => doc2.id) },
-    ...trigger && { trigger }
-  };
-  await db2("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();
-  if (!doc?.id) {
-    throw new Error("Failed to get job ID after insert/update");
-  }
-  console.log("[EXULU] created job", doc?.id);
-  return {
-    ...job,
-    id: doc?.id,
-    redis: job.id
-  };
+// src/registry/utils/sanitize-name.ts
+var sanitizeName = (name) => {
+  return name.toLowerCase().replace(/ /g, "_");
 };
 
 // types/enums/jobs.ts
@@ -2020,7 +1448,7 @@ var getToken = async (authHeader) => {
 };
 
 // src/auth/auth.ts
-import bcrypt2 from "bcryptjs";
+import bcrypt from "bcryptjs";
 var authentication = async ({
   apikey,
   authtoken,
@@ -2115,7 +1543,7 @@ var authentication = async ({
     for (const user of filtered) {
       const user_key_last_slash_index = user.apikey.lastIndexOf("/");
       const user_key_compare_value = user.apikey.substring(0, user_key_last_slash_index);
-      const isMatch = await bcrypt2.compare(request_key_compare_value, user_key_compare_value);
+      const isMatch = await bcrypt.compare(request_key_compare_value, user_key_compare_value);
       if (isMatch) {
         await db2.from("users").where({ id: user.id }).update({
           last_used: /* @__PURE__ */ new Date()
@@ -2172,595 +1600,929 @@ var requestValidators = {
         message: "Missing body."
       };
     }
-    if (!req.body.agent) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing agent in body."
-      };
+    if (!req.body.agent) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing agent in body."
+      };
+    }
+    if (!req.body.session) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing session in body."
+      };
+    }
+    if (!req.body.inputs) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing inputs in body."
+      };
+    }
+    if (!req.body.label) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing label for job in body."
+      };
+    }
+    return {
+      error: false
+    };
+  },
+  embedders: (req, configuration) => {
+    const contentType = req.headers["content-type"] || "";
+    if (!contentType.includes("application/json")) {
+      return {
+        error: true,
+        code: 400,
+        message: "Unsupported content type."
+      };
+    }
+    if (!req.body) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing body."
+      };
+    }
+    if (!req.body.inputs) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing inputs."
+      };
+    }
+    if (!req.body.label) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing label for job in body."
+      };
+    }
+    if (configuration) {
+      for (const key in configuration) {
+        if (!req.body.configuration[key]) {
+          return {
+            error: true,
+            code: 400,
+            message: `Missing ${key} in body.configuration.`
+          };
+        }
+      }
+    }
+    return {
+      error: false
+    };
+  },
+  agents: (req) => {
+    const contentType = req.headers["content-type"] || "";
+    if (!contentType.includes("application/json")) {
+      return {
+        error: true,
+        code: 400,
+        message: "Unsupported content type."
+      };
+    }
+    if (!req.body) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing body."
+      };
+    }
+    if (!req.body.threadId) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing threadId in body."
+      };
+    }
+    if (!req.body.resourceId) {
+      return {
+        error: true,
+        code: 400,
+        message: "Missing resourceId in body."
+      };
+    }
+    if (!req.body.messages) {
+      return {
+        error: true,
+        code: 400,
+        message: 'Missing "messages" property in body.'
+      };
+    }
+    return {
+      error: false
+    };
+  }
+};
+
+// src/registry/routes.ts
+import { zerialize } from "zodex";
+
+// src/bullmq/queues.ts
+import { Queue as Queue3 } from "bullmq";
+var ExuluQueues = class {
+  queues;
+  constructor() {
+    this.queues = [];
+  }
+  queue(name) {
+    return this.queues.find((x) => x.name === name);
+  }
+  use(name) {
+    const existing = this.queues.find((x) => x.name === name);
+    if (existing) {
+      return existing;
+    }
+    if (!redisServer.host?.length || !redisServer.port?.length) {
+      console.error(`[EXULU] no redis server configured, but you are trying to use a queue ( ${name}), likely in an agent or workflow (look for ExuluQueues.use() ).`);
+      throw new Error(`[EXULU] no redis server configured.`);
+    }
+    const newQueue = new Queue3(`${name}`, { connection: redisServer });
+    this.queues.push(newQueue);
+    return newQueue;
+  }
+};
+var queues = new ExuluQueues();
+
+// types/models/vector-methods.ts
+var VectorMethodEnum = {
+  "cosineDistance": "cosineDistance",
+  "l1Distance": "l1Distance",
+  "l2Distance": "l2Distance",
+  "hammingDistance": "hammingDistance",
+  "jaccardDistance": "jaccardDistance",
+  "maxInnerProduct": "maxInnerProduct"
+};
+
+// src/registry/routes.ts
+import express from "express";
+import { ApolloServer } from "@apollo/server";
+import * as Papa from "papaparse";
+import cors from "cors";
+import "reflect-metadata";
+
+// src/registry/utils/graphql.ts
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import GraphQLJSON from "graphql-type-json";
+import { GraphQLScalarType, Kind } from "graphql";
+import CryptoJS from "crypto-js";
+var GraphQLDate = new GraphQLScalarType({
+  name: "Date",
+  description: "Date custom scalar type",
+  serialize(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number") {
+      return new Date(value).toISOString();
     }
-    if (!req.body.session) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing session in body."
-      };
+    if (typeof value === "string") {
+      return new Date(value).toISOString();
     }
-    if (!req.body.inputs) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing inputs in body."
-      };
+    return value;
+  },
+  parseValue(value) {
+    if (typeof value === "string") {
+      return new Date(value);
     }
-    if (!req.body.label) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing label for job in body."
-      };
+    if (typeof value === "number") {
+      return new Date(value);
     }
-    return {
-      error: false
-    };
+    return value;
   },
-  embedders: (req, configuration) => {
-    const contentType = req.headers["content-type"] || "";
-    if (!contentType.includes("application/json")) {
-      return {
-        error: true,
-        code: 400,
-        message: "Unsupported content type."
-      };
+  parseLiteral(ast) {
+    if (ast.kind === Kind.STRING) {
+      return new Date(ast.value);
     }
-    if (!req.body) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing body."
-      };
+    if (ast.kind === Kind.INT) {
+      return new Date(parseInt(ast.value, 10));
+    }
+    return null;
+  }
+});
+var map = (field) => {
+  let type;
+  switch (field.type) {
+    case "text":
+    case "shortText":
+    case "longText":
+    case "code":
+      type = "String";
+      break;
+    case "number":
+      type = "Float";
+      break;
+    case "boolean":
+      type = "Boolean";
+      break;
+    case "json":
+      type = "JSON";
+      break;
+    case "date":
+      type = "Date";
+      break;
+    default:
+      type = "String";
+  }
+  return type;
+};
+function createTypeDefs(table) {
+  const fields = table.fields.map((field) => {
+    let type;
+    type = map(field);
+    const required = field.required ? "!" : "";
+    return `  ${field.name}: ${type}${required}`;
+  });
+  const typeDef = `
+  type ${table.name.singular} {
+  ${fields.join("\n")}
+    id: ID!
+    createdAt: Date!
+    updatedAt: Date!
+  }
+  `;
+  const inputDef = `
+input ${table.name.singular}Input {
+${table.fields.map((f) => `  ${f.name}: ${map(f)}`).join("\n")}
+}
+`;
+  return typeDef + inputDef;
+}
+function createFilterTypeDefs(table) {
+  const fieldFilters = table.fields.map((field) => {
+    let type;
+    type = map(field);
+    return `
+  ${field.name}: FilterOperator${type}`;
+  });
+  const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
+  const operatorTypes = `
+input FilterOperatorString {
+  eq: String
+  ne: String
+  in: [String]
+  contains: String
+}
+
+input FilterOperatorDate {
+  lte: Date
+  gte: Date
+}
+
+input FilterOperatorFloat {
+  eq: Float
+  ne: Float
+  in: [Float]
+}
+
+input FilterOperatorBoolean {
+  eq: Boolean
+  ne: Boolean
+  in: [Boolean]
+}
+
+input FilterOperatorJSON {
+  eq: JSON
+  ne: JSON
+  in: [JSON]
+}
+
+input SortBy {
+  field: String!
+  direction: SortDirection!
+}
+
+enum SortDirection {
+  ASC
+  DESC
+}
+
+input Filter${tableNameSingularUpperCaseFirst} {
+${fieldFilters.join("\n")}
+}`;
+  return operatorTypes;
+}
+var getRequestedFields = (info) => {
+  const selections = info.operation.selectionSet.selections[0].selectionSet.selections;
+  const itemsSelection = selections.find((s) => s.name.value === "items");
+  const fields = itemsSelection ? Object.keys(itemsSelection.selectionSet.selections.reduce((acc, field) => {
+    acc[field.name.value] = true;
+    return acc;
+  }, {})) : Object.keys(selections.reduce((acc, field) => {
+    acc[field.name.value] = true;
+    return acc;
+  }, {}));
+  return fields.filter((field) => field !== "pageInfo" && field !== "items");
+};
+function createMutations(table) {
+  const tableNamePlural = table.name.plural.toLowerCase();
+  const tableNameSingular = table.name.singular.toLowerCase();
+  return {
+    [`${tableNamePlural}CreateOne`]: async (_, args, context, info) => {
+      const { db: db2 } = context;
+      const requestedFields = getRequestedFields(info);
+      let { input } = args;
+      input = encryptSensitiveFields(input);
+      const results = await db2(tableNamePlural).insert({
+        ...input,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      }).returning(requestedFields);
+      return results[0];
+    },
+    [`${tableNamePlural}UpdateOne`]: async (_, args, context, info) => {
+      const { db: db2 } = context;
+      let { where, input } = args;
+      input = encryptSensitiveFields(input);
+      await db2(tableNamePlural).where(where).update({
+        ...input,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      const requestedFields = getRequestedFields(info);
+      const result = await db2.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({
+        ...input,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      const requestedFields = getRequestedFields(info);
+      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
+      return result;
+    },
+    [`${tableNamePlural}RemoveOne`]: async (_, args, context, info) => {
+      const { db: db2 } = 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();
+      return result;
+    },
+    [`${tableNamePlural}RemoveOneById`]: async (_, args, context, info) => {
+      const { id } = args;
+      const { db: db2 } = context;
+      const requestedFields = getRequestedFields(info);
+      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
+      await db2(tableNamePlural).where({ id }).del();
+      return result;
     }
-    if (!req.body.inputs) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing inputs."
-      };
+  };
+}
+function createQueries(table) {
+  const tableNamePlural = table.name.plural.toLowerCase();
+  const tableNameSingular = table.name.singular.toLowerCase();
+  const applyFilters = (query, filters) => {
+    filters.forEach((filter) => {
+      Object.entries(filter).forEach(([fieldName, operators]) => {
+        if (operators) {
+          if (operators.eq !== void 0) {
+            query = query.where(fieldName, operators.eq);
+          }
+          if (operators.ne !== void 0) {
+            query = query.whereRaw(`?? IS DISTINCT FROM ?`, [fieldName, operators.ne]);
+          }
+          if (operators.in !== void 0) {
+            query = query.whereIn(fieldName, operators.in);
+          }
+          if (operators.contains !== void 0) {
+            query = query.where(fieldName, "like", `%${operators.contains}%`);
+          }
+        }
+      });
+    });
+    return query;
+  };
+  const applySorting = (query, sort) => {
+    if (sort) {
+      query = query.orderBy(sort.field, sort.direction.toLowerCase());
     }
-    if (!req.body.label) {
+    return query;
+  };
+  return {
+    [`${tableNameSingular}ById`]: async (_, args, context, info) => {
+      const { db: db2 } = context;
+      const requestedFields = getRequestedFields(info);
+      const result = await db2.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 requestedFields = getRequestedFields(info);
+      let query = db2.from(tableNamePlural).select(requestedFields);
+      query = applyFilters(query, filters);
+      query = applySorting(query, sort);
+      const result = await query.first();
+      return result;
+    },
+    [`${tableNamePlural}Pagination`]: async (_, args, context, info) => {
+      const { limit = 10, page = 0, filters = [], sort } = args;
+      const { db: db2 } = context;
+      let baseQuery = db2(tableNamePlural);
+      baseQuery = applyFilters(baseQuery, filters);
+      const [{ count }] = await baseQuery.clone().count("* as count");
+      const itemCount = Number(count);
+      const pageCount = Math.ceil(itemCount / limit);
+      const currentPage = page;
+      const hasPreviousPage = currentPage > 1;
+      const hasNextPage = currentPage < pageCount - 1;
+      let dataQuery = baseQuery.clone();
+      const requestedFields = getRequestedFields(info);
+      dataQuery = applySorting(dataQuery, sort);
+      if (page > 1) {
+        dataQuery = dataQuery.offset((page - 1) * limit);
+      }
+      const items = await dataQuery.select(requestedFields).limit(limit);
       return {
-        error: true,
-        code: 400,
-        message: "Missing label for job in body."
+        pageInfo: {
+          pageCount,
+          itemCount,
+          currentPage,
+          hasPreviousPage,
+          hasNextPage
+        },
+        items
       };
-    }
-    if (configuration) {
-      for (const key in configuration) {
-        if (!req.body.configuration[key]) {
-          return {
-            error: true,
-            code: 400,
-            message: `Missing ${key} in body.configuration.`
-          };
+    },
+    // Add jobStatistics query for jobs table
+    ...tableNamePlural === "jobs" ? {
+      jobStatistics: async (_, args, context, info) => {
+        const { user, agent, from, to } = args;
+        const { db: db2 } = context;
+        let query = db2("jobs");
+        if (user) {
+          query = query.where("user", user);
+        }
+        if (agent) {
+          query = query.where("agent", agent);
+        }
+        if (from) {
+          query = query.where("createdAt", ">=", from);
+        }
+        if (to) {
+          query = query.where("createdAt", "<=", to);
         }
+        const completedQuery = query.clone().where("status", "completed");
+        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 [{ averageDuration }] = await durationQuery;
+        return {
+          completedCount: Number(completedCount),
+          failedCount: Number(failedCount),
+          averageDuration: averageDuration ? Number(averageDuration) : 0
+        };
       }
+    } : {}
+  };
+}
+function createSDL(tables) {
+  let typeDefs = `
+    scalar JSON
+    scalar Date
+    
+    type Query {
+    `;
+  let mutationDefs = `
+    type Mutation {
+    `;
+  let modelDefs = "";
+  const resolvers = { JSON: GraphQLJSON, Date: GraphQLDate, Query: {}, Mutation: {} };
+  for (const table of tables) {
+    const tableNamePlural = table.name.plural.toLowerCase();
+    const tableNameSingular = table.name.singular.toLowerCase();
+    const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
+    typeDefs += `
+      ${tableNameSingular}ById(id: ID!): ${tableNameSingular}
+      ${tableNamePlural}Pagination(limit: Int, page: Int, filters: [Filter${tableNameSingularUpperCaseFirst}], sort: SortBy): ${tableNameSingularUpperCaseFirst}PaginationResult
+      ${tableNameSingular}One(filters: [Filter${tableNameSingularUpperCaseFirst}], sort: SortBy): ${tableNameSingular}
+      ${tableNamePlural === "jobs" ? `jobStatistics(user: ID, agent: String, from: String, to: String): JobStatistics` : ""}
+    `;
+    mutationDefs += `
+      ${tableNamePlural}CreateOne(input: ${tableNameSingular}Input!): ${tableNameSingular}
+      ${tableNamePlural}UpdateOne(where: JSON!, input: ${tableNameSingular}Input!): ${tableNameSingular}
+      ${tableNamePlural}UpdateOneById(id: ID!, input: ${tableNameSingular}Input!): ${tableNameSingular}
+      ${tableNamePlural}RemoveOne(where: JSON!): ${tableNameSingular}
+      ${tableNamePlural}RemoveOneById(id: ID!): ${tableNameSingular}
+    `;
+    modelDefs += createTypeDefs(table);
+    modelDefs += createFilterTypeDefs(table);
+    modelDefs += `
+type ${tableNameSingularUpperCaseFirst}PaginationResult {
+  pageInfo: PageInfo!
+  items: [${tableNameSingular}]!
+}
+
+type PageInfo {
+  pageCount: Int!
+  itemCount: Int!
+  currentPage: Int!
+  hasPreviousPage: Boolean!
+  hasNextPage: Boolean!
+}
+`;
+    if (tableNamePlural === "jobs") {
+      modelDefs += `
+type JobStatistics {
+  completedCount: Int!
+  failedCount: Int!
+  averageDuration: Float!
+}
+`;
     }
-    return {
-      error: false
-    };
-  },
-  agents: (req) => {
-    const contentType = req.headers["content-type"] || "";
-    if (!contentType.includes("application/json")) {
-      return {
-        error: true,
-        code: 400,
-        message: "Unsupported content type."
-      };
-    }
-    if (!req.body) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing body."
-      };
-    }
-    if (!req.body.threadId) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing threadId in body."
-      };
-    }
-    if (!req.body.resourceId) {
-      return {
-        error: true,
-        code: 400,
-        message: "Missing resourceId in body."
-      };
-    }
-    if (!req.body.messages) {
-      return {
-        error: true,
-        code: 400,
-        message: 'Missing "messages" property in body.'
-      };
+    Object.assign(resolvers.Query, createQueries(table));
+    Object.assign(resolvers.Mutation, createMutations(table));
+  }
+  typeDefs += "}\n";
+  mutationDefs += "}\n";
+  const fullSDL = typeDefs + mutationDefs + modelDefs;
+  const schema = makeExecutableSchema({
+    typeDefs: fullSDL,
+    resolvers
+  });
+  console.log("\n\u{1F4CA} GraphQL Schema Overview\n");
+  const queriesTable = Object.keys(resolvers.Query).map((query) => ({
+    "Operation Type": "Query",
+    "Name": query,
+    "Description": "Retrieves data"
+  }));
+  const mutationsTable = Object.keys(resolvers.Mutation).map((mutation) => ({
+    "Operation Type": "Mutation",
+    "Name": mutation,
+    "Description": "Modifies data"
+  }));
+  const typesTable = tables.flatMap(
+    (table) => table.fields.map((field) => ({
+      "Type": table.name.singular,
+      "Field": field.name,
+      "Field Type": field.type,
+      "Required": field.required ? "Yes" : "No"
+    }))
+  );
+  console.log("\u{1F50D} Operations:");
+  console.table([...queriesTable, ...mutationsTable]);
+  console.log("\n\u{1F4DD} Types and Fields:");
+  console.table(typesTable);
+  console.log("\n");
+  return schema;
+}
+var sensitiveFields = ["anthropic_token"];
+var encryptSensitiveFields = (input) => {
+  sensitiveFields.forEach((field) => {
+    if (input[field]) {
+      input[field] = CryptoJS.AES.encrypt(input[field], process.env.NEXTAUTH_SECRET).toString();
     }
-    return {
-      error: false
-    };
-  }
+  });
+  return input;
 };
 
 // src/registry/routes.ts
-import { zerialize } from "zodex";
+import { expressMiddleware } from "@as-integrations/express5";
 
-// src/bullmq/queues.ts
-import { Queue as Queue3 } from "bullmq";
-var ExuluQueues = class {
-  queues;
-  constructor() {
-    this.queues = [];
-  }
-  queue(name) {
-    return this.queues.find((x) => x.name === name);
-  }
-  use(name) {
-    const existing = this.queues.find((x) => x.name === name);
-    if (existing) {
-      return existing;
-    }
-    if (!redisServer.host?.length || !redisServer.port?.length) {
-      console.error(`[EXULU] no redis server configured, but you are trying to use a queue ( ${name}), likely in an agent or workflow (look for ExuluQueues.use() ).`);
-      throw new Error(`[EXULU] no redis server configured.`);
+// src/postgres/core-schema.ts
+var agentMessagesSchema = {
+  name: {
+    plural: "agent_messages",
+    singular: "agent_message"
+  },
+  fields: [
+    {
+      name: "content",
+      type: "text"
+    },
+    {
+      name: "title",
+      type: "text"
+    },
+    {
+      name: "session",
+      type: "text"
     }
-    const newQueue = new Queue3(`${name}`, { connection: redisServer });
-    this.queues.push(newQueue);
-    return newQueue;
-  }
+  ]
 };
-var queues = new ExuluQueues();
-
-// types/models/vector-methods.ts
-var VectorMethodEnum = {
-  "cosineDistance": "cosineDistance",
-  "l1Distance": "l1Distance",
-  "l2Distance": "l2Distance",
-  "hammingDistance": "hammingDistance",
-  "jaccardDistance": "jaccardDistance",
-  "maxInnerProduct": "maxInnerProduct"
+var agentSessionsSchema = {
+  name: {
+    plural: "agent_sessions",
+    singular: "agent_session"
+  },
+  fields: [
+    {
+      name: "agent",
+      type: "uuid"
+    },
+    {
+      name: "user",
+      // next auth stores users with id type SERIAL, so we need to use number
+      type: "number"
+    },
+    {
+      name: "title",
+      type: "text"
+    }
+  ]
 };
-
-// src/registry/routes.ts
-import express from "express";
-import { ApolloServer } from "@apollo/server";
-import * as Papa from "papaparse";
-import cors from "cors";
-import "reflect-metadata";
-
-// src/registry/utils/graphql.ts
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import GraphQLJSON from "graphql-type-json";
-import { GraphQLScalarType, Kind } from "graphql";
-import CryptoJS from "crypto-js";
-var GraphQLDate = new GraphQLScalarType({
-  name: "Date",
-  description: "Date custom scalar type",
-  serialize(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
+var usersSchema = {
+  name: {
+    plural: "users",
+    singular: "user"
+  },
+  fields: [
+    {
+      name: "firstname",
+      type: "text"
+    },
+    {
+      name: "name",
+      type: "text"
+    },
+    {
+      name: "lastname",
+      type: "text"
+    },
+    {
+      name: "email",
+      type: "text",
+      index: true
+    },
+    {
+      name: "temporary_token",
+      type: "text"
+    },
+    {
+      name: "type",
+      type: "text",
+      index: true
+    },
+    {
+      name: "profile_image",
+      type: "text"
+    },
+    {
+      name: "super_admin",
+      type: "boolean",
+      default: false
+    },
+    {
+      name: "status",
+      type: "text"
+    },
+    {
+      name: "emailVerified",
+      type: "text"
+    },
+    {
+      name: "apikey",
+      type: "text"
+    },
+    {
+      name: "last_used",
+      type: "date"
+    },
+    {
+      name: "anthropic_token",
+      type: "text"
+    },
+    {
+      name: "role",
+      type: "uuid"
     }
-    if (typeof value === "number") {
-      return new Date(value).toISOString();
+  ]
+};
+var rolesSchema = {
+  name: {
+    plural: "roles",
+    singular: "role"
+  },
+  fields: [
+    {
+      name: "name",
+      type: "text"
+    },
+    {
+      name: "is_admin",
+      type: "boolean",
+      default: false
+    },
+    {
+      name: "agents",
+      type: "json"
     }
-    if (typeof value === "string") {
-      return new Date(value).toISOString();
+  ]
+};
+var statisticsSchema = {
+  name: {
+    plural: "statistics",
+    singular: "statistic"
+  },
+  fields: [
+    {
+      name: "name",
+      type: "text"
+    },
+    {
+      name: "label",
+      type: "text"
+    },
+    {
+      name: "type",
+      type: "text"
+    },
+    {
+      name: "total",
+      type: "number"
     }
-    return value;
+  ]
+};
+var workflowSchema = {
+  name: {
+    plural: "workflows",
+    singular: "workflow"
   },
-  parseValue(value) {
-    if (typeof value === "string") {
-      return new Date(value);
+  fields: [
+    {
+      name: "workflow_name",
+      type: "text"
+    },
+    {
+      name: "run_id",
+      type: "text"
+    },
+    {
+      name: "snapshot",
+      type: "text"
     }
-    if (typeof value === "number") {
-      return new Date(value);
+  ]
+};
+var evalResultsSchema = {
+  name: {
+    plural: "eval_results",
+    singular: "eval_result"
+  },
+  fields: [
+    {
+      name: "input",
+      type: "longText"
+    },
+    {
+      name: "output",
+      type: "longText"
+    },
+    {
+      name: "duration",
+      type: "number"
+    },
+    {
+      name: "category",
+      type: "text"
+    },
+    {
+      name: "metadata",
+      type: "json"
+    },
+    {
+      name: "result",
+      type: "number"
+    },
+    {
+      name: "agent_id",
+      type: "uuid"
+    },
+    {
+      name: "workflow_id",
+      type: "uuid"
+    },
+    {
+      name: "eval_type",
+      type: "text"
+    },
+    {
+      name: "eval_name",
+      type: "text"
+    },
+    {
+      name: "comment",
+      type: "longText"
     }
-    return value;
+  ]
+};
+var jobsSchema = {
+  name: {
+    plural: "jobs",
+    singular: "job"
   },
-  parseLiteral(ast) {
-    if (ast.kind === Kind.STRING) {
-      return new Date(ast.value);
-    }
-    if (ast.kind === Kind.INT) {
-      return new Date(parseInt(ast.value, 10));
+  fields: [
+    {
+      name: "redis",
+      type: "text"
+    },
+    {
+      name: "session",
+      type: "text"
+    },
+    {
+      name: "status",
+      type: "text"
+    },
+    {
+      name: "type",
+      type: "text"
+    },
+    {
+      name: "result",
+      type: "longText"
+    },
+    {
+      name: "name",
+      type: "text"
+    },
+    {
+      name: "agent",
+      type: "uuid"
+    },
+    {
+      name: "workflow",
+      type: "uuid"
+    },
+    {
+      name: "user",
+      // next auth stores users with id type SERIAL, so we need to use number
+      type: "number"
+    },
+    {
+      name: "item",
+      type: "uuid"
+    },
+    {
+      name: "steps",
+      type: "number"
+    },
+    {
+      name: "inputs",
+      type: "json"
+    },
+    {
+      name: "finished_at",
+      type: "date"
+    },
+    {
+      name: "duration",
+      type: "number"
     }
-    return null;
-  }
-});
-var map = (field) => {
-  let type;
-  switch (field.type) {
-    case "text":
-    case "shortText":
-    case "longText":
-    case "code":
-      type = "String";
-      break;
-    case "number":
-      type = "Float";
-      break;
-    case "boolean":
-      type = "Boolean";
-      break;
-    case "json":
-      type = "JSON";
-      break;
-    case "date":
-      type = "Date";
-      break;
-    default:
-      type = "String";
-  }
-  return type;
-};
-function createTypeDefs(table) {
-  const fields = table.fields.map((field) => {
-    let type;
-    type = map(field);
-    const required = field.required ? "!" : "";
-    return `  ${field.name}: ${type}${required}`;
-  });
-  const typeDef = `
-  type ${table.name.singular} {
-  ${fields.join("\n")}
-    id: ID!
-    createdAt: Date!
-    updatedAt: Date!
-  }
-  `;
-  const inputDef = `
-input ${table.name.singular}Input {
-${table.fields.map((f) => `  ${f.name}: ${map(f)}`).join("\n")}
-}
-`;
-  return typeDef + inputDef;
-}
-function createFilterTypeDefs(table) {
-  const fieldFilters = table.fields.map((field) => {
-    let type;
-    type = map(field);
-    return `
-  ${field.name}: FilterOperator${type}`;
-  });
-  const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
-  const operatorTypes = `
-input FilterOperatorString {
-  eq: String
-  ne: String
-  in: [String]
-  contains: String
-}
-
-input FilterOperatorDate {
-  lte: Date
-  gte: Date
-}
-
-input FilterOperatorFloat {
-  eq: Float
-  ne: Float
-  in: [Float]
-}
-
-input FilterOperatorBoolean {
-  eq: Boolean
-  ne: Boolean
-  in: [Boolean]
-}
-
-input FilterOperatorJSON {
-  eq: JSON
-  ne: JSON
-  in: [JSON]
-}
-
-input SortBy {
-  field: String!
-  direction: SortDirection!
-}
-
-enum SortDirection {
-  ASC
-  DESC
-}
-
-input Filter${tableNameSingularUpperCaseFirst} {
-${fieldFilters.join("\n")}
-}`;
-  return operatorTypes;
-}
-var getRequestedFields = (info) => {
-  const selections = info.operation.selectionSet.selections[0].selectionSet.selections;
-  const itemsSelection = selections.find((s) => s.name.value === "items");
-  const fields = itemsSelection ? Object.keys(itemsSelection.selectionSet.selections.reduce((acc, field) => {
-    acc[field.name.value] = true;
-    return acc;
-  }, {})) : Object.keys(selections.reduce((acc, field) => {
-    acc[field.name.value] = true;
-    return acc;
-  }, {}));
-  return fields.filter((field) => field !== "pageInfo" && field !== "items");
+  ]
 };
-function createMutations(table) {
-  const tableNamePlural = table.name.plural.toLowerCase();
-  const tableNameSingular = table.name.singular.toLowerCase();
-  return {
-    [`${tableNamePlural}CreateOne`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
-      const requestedFields = getRequestedFields(info);
-      let { input } = args;
-      input = encryptSensitiveFields(input);
-      const results = await db2(tableNamePlural).insert({
-        ...input,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      }).returning(requestedFields);
-      return results[0];
-    },
-    [`${tableNamePlural}UpdateOne`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
-      let { where, input } = args;
-      input = encryptSensitiveFields(input);
-      await db2(tableNamePlural).where(where).update({
-        ...input,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where(where).first();
-      return result;
+var agentsSchema = {
+  name: {
+    plural: "agents",
+    singular: "agent"
+  },
+  fields: [
+    {
+      name: "name",
+      type: "text"
     },
-    [`${tableNamePlural}UpdateOneById`]: async (_, args, context, info) => {
-      let { id, input } = args;
-      input = encryptSensitiveFields(input);
-      const { db: db2 } = context;
-      await db2(tableNamePlural).where({ id }).update({
-        ...input,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-      const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
-      return result;
+    {
+      name: "description",
+      type: "text"
     },
-    [`${tableNamePlural}RemoveOne`]: async (_, args, context, info) => {
-      const { db: db2 } = 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();
-      return result;
+    {
+      name: "extensions",
+      type: "json"
     },
-    [`${tableNamePlural}RemoveOneById`]: async (_, args, context, info) => {
-      const { id } = args;
-      const { db: db2 } = context;
-      const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id }).first();
-      await db2(tableNamePlural).where({ id }).del();
-      return result;
-    }
-  };
-}
-function createQueries(table) {
-  const tableNamePlural = table.name.plural.toLowerCase();
-  const tableNameSingular = table.name.singular.toLowerCase();
-  const applyFilters = (query, filters) => {
-    filters.forEach((filter) => {
-      Object.entries(filter).forEach(([fieldName, operators]) => {
-        if (operators) {
-          if (operators.eq !== void 0) {
-            query = query.where(fieldName, operators.eq);
-          }
-          if (operators.ne !== void 0) {
-            query = query.whereRaw(`?? IS DISTINCT FROM ?`, [fieldName, operators.ne]);
-          }
-          if (operators.in !== void 0) {
-            query = query.whereIn(fieldName, operators.in);
-          }
-          if (operators.contains !== void 0) {
-            query = query.where(fieldName, "like", `%${operators.contains}%`);
-          }
-        }
-      });
-    });
-    return query;
-  };
-  const applySorting = (query, sort) => {
-    if (sort) {
-      query = query.orderBy(sort.field, sort.direction.toLowerCase());
-    }
-    return query;
-  };
-  return {
-    [`${tableNameSingular}ById`]: async (_, args, context, info) => {
-      const { db: db2 } = context;
-      const requestedFields = getRequestedFields(info);
-      const result = await db2.from(tableNamePlural).select(requestedFields).where({ id: args.id }).first();
-      return result;
+    {
+      name: "backend",
+      type: "text"
     },
-    [`${tableNameSingular}One`]: async (_, args, context, info) => {
-      const { filters = [], sort } = args;
-      const { db: db2 } = context;
-      const requestedFields = getRequestedFields(info);
-      let query = db2.from(tableNamePlural).select(requestedFields);
-      query = applyFilters(query, filters);
-      query = applySorting(query, sort);
-      const result = await query.first();
-      return result;
+    {
+      name: "type",
+      type: "text"
     },
-    [`${tableNamePlural}Pagination`]: async (_, args, context, info) => {
-      const { limit = 10, page = 0, filters = [], sort } = args;
-      const { db: db2 } = context;
-      let baseQuery = db2(tableNamePlural);
-      baseQuery = applyFilters(baseQuery, filters);
-      const [{ count }] = await baseQuery.clone().count("* as count");
-      const itemCount = Number(count);
-      const pageCount = Math.ceil(itemCount / limit);
-      const currentPage = page;
-      const hasPreviousPage = currentPage > 1;
-      const hasNextPage = currentPage < pageCount - 1;
-      let dataQuery = baseQuery.clone();
-      const requestedFields = getRequestedFields(info);
-      dataQuery = applySorting(dataQuery, sort);
-      if (page > 1) {
-        dataQuery = dataQuery.offset((page - 1) * limit);
-      }
-      const items = await dataQuery.select(requestedFields).limit(limit);
-      return {
-        pageInfo: {
-          pageCount,
-          itemCount,
-          currentPage,
-          hasPreviousPage,
-          hasNextPage
-        },
-        items
-      };
+    {
+      name: "active",
+      type: "boolean",
+      default: false
     },
-    // Add jobStatistics query for jobs table
-    ...tableNamePlural === "jobs" ? {
-      jobStatistics: async (_, args, context, info) => {
-        const { user, agent, from, to } = args;
-        const { db: db2 } = context;
-        let query = db2("jobs");
-        if (user) {
-          query = query.where("user", user);
-        }
-        if (agent) {
-          query = query.where("agent", agent);
-        }
-        if (from) {
-          query = query.where("createdAt", ">=", from);
-        }
-        if (to) {
-          query = query.where("createdAt", "<=", to);
-        }
-        const completedQuery = query.clone().where("status", "completed");
-        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 [{ averageDuration }] = await durationQuery;
-        return {
-          completedCount: Number(completedCount),
-          failedCount: Number(failedCount),
-          averageDuration: averageDuration ? Number(averageDuration) : 0
-        };
-      }
-    } : {}
-  };
-}
-function createSDL(tables) {
-  let typeDefs = `
-    scalar JSON
-    scalar Date
-    
-    type Query {
-    `;
-  let mutationDefs = `
-    type Mutation {
-    `;
-  let modelDefs = "";
-  const resolvers = { JSON: GraphQLJSON, Date: GraphQLDate, Query: {}, Mutation: {} };
-  for (const table of tables) {
-    const tableNamePlural = table.name.plural.toLowerCase();
-    const tableNameSingular = table.name.singular.toLowerCase();
-    const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
-    typeDefs += `
-      ${tableNameSingular}ById(id: ID!): ${tableNameSingular}
-      ${tableNamePlural}Pagination(limit: Int, page: Int, filters: [Filter${tableNameSingularUpperCaseFirst}], sort: SortBy): ${tableNameSingularUpperCaseFirst}PaginationResult
-      ${tableNameSingular}One(filters: [Filter${tableNameSingularUpperCaseFirst}], sort: SortBy): ${tableNameSingular}
-      ${tableNamePlural === "jobs" ? `jobStatistics(user: ID, agent: String, from: String, to: String): JobStatistics` : ""}
-    `;
-    mutationDefs += `
-      ${tableNamePlural}CreateOne(input: ${tableNameSingular}Input!): ${tableNameSingular}
-      ${tableNamePlural}UpdateOne(where: JSON!, input: ${tableNameSingular}Input!): ${tableNameSingular}
-      ${tableNamePlural}UpdateOneById(id: ID!, input: ${tableNameSingular}Input!): ${tableNameSingular}
-      ${tableNamePlural}RemoveOne(where: JSON!): ${tableNameSingular}
-      ${tableNamePlural}RemoveOneById(id: ID!): ${tableNameSingular}
-    `;
-    modelDefs += createTypeDefs(table);
-    modelDefs += createFilterTypeDefs(table);
-    modelDefs += `
-type ${tableNameSingularUpperCaseFirst}PaginationResult {
-  pageInfo: PageInfo!
-  items: [${tableNameSingular}]!
-}
-
-type PageInfo {
-  pageCount: Int!
-  itemCount: Int!
-  currentPage: Int!
-  hasPreviousPage: Boolean!
-  hasNextPage: Boolean!
-}
-`;
-    if (tableNamePlural === "jobs") {
-      modelDefs += `
-type JobStatistics {
-  completedCount: Int!
-  failedCount: Int!
-  averageDuration: Float!
-}
-`;
-    }
-    Object.assign(resolvers.Query, createQueries(table));
-    Object.assign(resolvers.Mutation, createMutations(table));
-  }
-  typeDefs += "}\n";
-  mutationDefs += "}\n";
-  const fullSDL = typeDefs + mutationDefs + modelDefs;
-  const schema = makeExecutableSchema({
-    typeDefs: fullSDL,
-    resolvers
-  });
-  console.log("\n\u{1F4CA} GraphQL Schema Overview\n");
-  const queriesTable = Object.keys(resolvers.Query).map((query) => ({
-    "Operation Type": "Query",
-    "Name": query,
-    "Description": "Retrieves data"
-  }));
-  const mutationsTable = Object.keys(resolvers.Mutation).map((mutation) => ({
-    "Operation Type": "Mutation",
-    "Name": mutation,
-    "Description": "Modifies data"
-  }));
-  const typesTable = tables.flatMap(
-    (table) => table.fields.map((field) => ({
-      "Type": table.name.singular,
-      "Field": field.name,
-      "Field Type": field.type,
-      "Required": field.required ? "Yes" : "No"
-    }))
-  );
-  console.log("\u{1F50D} Operations:");
-  console.table([...queriesTable, ...mutationsTable]);
-  console.log("\n\u{1F4DD} Types and Fields:");
-  console.table(typesTable);
-  console.log("\n");
-  return schema;
-}
-var sensitiveFields = ["anthropic_token"];
-var encryptSensitiveFields = (input) => {
-  sensitiveFields.forEach((field) => {
-    if (input[field]) {
-      input[field] = CryptoJS.AES.encrypt(input[field], process.env.NEXTAUTH_SECRET).toString();
+    {
+      name: "public",
+      type: "boolean",
+      default: false
+    },
+    {
+      name: "tools",
+      type: "json"
     }
-  });
-  return input;
+  ]
 };
 
-// src/registry/routes.ts
-import { expressMiddleware } from "@as-integrations/express5";
-
 // src/registry/uppy.ts
 import "express";
 var createUppyRoutes = async (app) => {
@@ -4342,14 +4104,14 @@ var preprocessInputs = async (data) => {
   return data;
 };
 var getPresignedFileUrl = async (key) => {
-  if (!process.env.NEXT_PUBLIC_UPLOAD_URL) {
-    throw new Error("Missing process.env.NEXT_PUBLIC_UPLOAD_URL");
+  if (!process.env.NEXT_BACKEND) {
+    throw new Error("Missing process.env.NEXT_BACKEND");
   }
   if (!process.env.INTERNAL_SECRET) {
-    throw new Error("Missing process.env.NEXT_PUBLIC_UPLOAD_URL");
+    throw new Error("Missing process.env.NEXT_BACKEND");
   }
   console.log(`[EXULU] fetching presigned url for file with key: ${key}`);
-  let url = `${process.env.NEXT_PUBLIC_UPLOAD_URL}/s3/download?key=${key}`;
+  let url = `${process.env.NEXT_BACKEND}/s3/download?key=${key}`;
   const response = await fetch(url, {
     method: "GET",
     headers: {
@@ -4899,6 +4661,259 @@ var getTicket = new ExuluTool({
   }
 });
 
+// src/auth/generate-key.ts
+import bcrypt2 from "bcryptjs";
+var SALT_ROUNDS = 12;
+async function encryptString(string) {
+  const hash = await bcrypt2.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 = [];
@@ -4913,6 +4928,7 @@ 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 = [
@@ -6228,14 +6244,6 @@ var ExuluChunkers = {
     rules: RecursiveRules
   }
 };
-var ExuluDatabase = {
-  init: async () => {
-    await execute();
-  },
-  generateApiKey: async (name, email) => {
-    return await generateApiKey(name, email);
-  }
-};
 export {
   JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM,
   STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM,
@@ -6244,7 +6252,6 @@ export {
   authentication as ExuluAuthentication,
   ExuluChunkers,
   ExuluContext,
-  ExuluDatabase,
   ExuluEmbedder,
   ExuluEval,
   ExuluJobs,