@exulu/backend 0.2.3 → 0.2.5

package/dist/index.js

@@ -5,6 +5,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/index.ts
+import "dotenv/config";
+
 // src/redis/client.ts
 import { createClient } from "redis";
 
@@ -114,6 +117,10 @@ var usersSchema = {
       name: "firstname",
       type: "text"
     },
+    {
+      name: "name",
+      type: "text"
+    },
     {
       name: "lastname",
       type: "text"
@@ -217,6 +224,70 @@ var statisticsSchema = {
     }
   ]
 };
+var workflowSchema = {
+  name: {
+    plural: "workflows",
+    singular: "workflow"
+  },
+  fields: [
+    {
+      name: "workflow_name",
+      type: "text"
+    },
+    {
+      name: "run_id",
+      type: "text"
+    },
+    {
+      name: "snapshot",
+      type: "text"
+    }
+  ]
+};
+var threadsSchema = {
+  name: {
+    plural: "threads",
+    singular: "thread"
+  },
+  fields: [
+    {
+      name: "resourceId",
+      type: "text"
+    },
+    {
+      name: "title",
+      type: "text"
+    },
+    {
+      name: "metadata",
+      type: "text"
+    }
+  ]
+};
+var messagesSchema = {
+  name: {
+    plural: "messages",
+    singular: "message"
+  },
+  fields: [
+    {
+      name: "thread_id",
+      type: "text"
+    },
+    {
+      name: "content",
+      type: "text"
+    },
+    {
+      name: "role",
+      type: "text"
+    },
+    {
+      name: "type",
+      type: "text"
+    }
+  ]
+};
 var jobsSchema = {
   name: {
     plural: "jobs",
@@ -241,7 +312,7 @@ var jobsSchema = {
     },
     {
       name: "result",
-      type: "text"
+      type: "longText"
     },
     {
       name: "name",
@@ -251,6 +322,10 @@ var jobsSchema = {
       name: "agent",
       type: "text"
     },
+    {
+      name: "workflow",
+      type: "text"
+    },
     {
       name: "user",
       type: "text"
@@ -259,6 +334,10 @@ var jobsSchema = {
       name: "item",
       type: "text"
     },
+    {
+      name: "steps",
+      type: "number"
+    },
     {
       name: "inputs",
       type: "json"
@@ -362,14 +441,11 @@ var sanitizeName = (name) => {
   return name.toLowerCase().replace(/ /g, "_");
 };
 
-// src/postgres/init-db.ts
-import bcrypt2 from "bcryptjs";
-
 // src/auth/generate-key.ts
 import bcrypt from "bcryptjs";
 var SALT_ROUNDS = 12;
-async function encryptApiKey(apikey) {
-  const hash = await bcrypt.hash(apikey, SALT_ROUNDS);
+async function encryptString(string) {
+  const hash = await bcrypt.hash(string, SALT_ROUNDS);
   return hash;
 }
 var generateApiKey = async (name, email) => {
@@ -391,7 +467,7 @@ var generateApiKey = async (name, email) => {
   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 encryptApiKey(plainKey);
+  const encryptedKey = await encryptString(plainKey);
   const existingApiUser = await db2.from("users").where({ email }).first();
   if (!existingApiUser) {
     console.log("[EXULU] Creating default api user.");
@@ -402,6 +478,7 @@ var generateApiKey = async (name, email) => {
       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
@@ -566,11 +643,6 @@ var up = async function(knex) {
     });
   }
 };
-var SALT_ROUNDS2 = 12;
-async function encryptApiKey2(apikey) {
-  const hash = await bcrypt2.hash(apikey, SALT_ROUNDS2);
-  return hash;
-}
 var execute = async () => {
   console.log("[EXULU] Initializing database.");
   const { db: db2 } = await postgresClient();
@@ -583,33 +655,33 @@ var execute = async () => {
     const role = await db2.from("roles").insert({
       name: "admin",
       is_admin: true,
-      agents: []
+      agents: JSON.stringify([])
     }).returning("id");
     roleId = role[0].id;
   } else {
     roleId = existingRole.id;
   }
-  const newKeyName = "exulu_default_key";
-  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 encryptApiKey2(plainKey);
   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",
-      // password: "admin", todo add this again when we implement password auth / encryption as alternative to OTP
       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;
 };
 
@@ -620,7 +692,6 @@ import { Agent as MastraAgent } from "@mastra/core";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import "bullmq";
 import { Memory } from "@mastra/memory";
 import { PostgresStore, PgVector } from "@mastra/pg";
 
@@ -656,6 +727,7 @@ var bullmqDecorator = async ({
   configuration,
   updater,
   context,
+  steps,
   source,
   documents,
   trigger,
@@ -673,11 +745,13 @@ var bullmqDecorator = async ({
       ...context && { context },
       ...source && { source },
       ...documents && { documents },
+      ...steps && { steps },
       ...trigger && { trigger },
       ...item && { item },
       agent,
       user,
       inputs,
+      label,
       session
     },
     {
@@ -702,6 +776,7 @@ var bullmqDecorator = async ({
     ...embedder && { embedder },
     ...workflow && { workflow },
     ...configuration && { configuration },
+    ...steps && { steps },
     ...updater && { updater },
     ...context && { context },
     ...source && { source },
@@ -725,6 +800,17 @@ var bullmqDecorator = async ({
   };
 };
 
+// types/enums/jobs.ts
+var JOB_STATUS_ENUM = {
+  completed: "completed",
+  failed: "failed",
+  delayed: "delayed",
+  active: "active",
+  waiting: "waiting",
+  paused: "paused",
+  stuck: "stuck"
+};
+
 // src/registry/classes.ts
 function generateSlug(name) {
   const normalized = name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
@@ -759,6 +845,7 @@ var ExuluAgent = class {
   config;
   memory;
   tools;
+  agent;
   capabilities;
   constructor({ id, name, description, outputSchema, config, rateLimit, type, capabilities, tools }) {
     this.id = id;
@@ -771,6 +858,14 @@ var ExuluAgent = class {
     this.config = config;
     this.capabilities = capabilities;
     this.slug = `/agents/${generateSlug(this.name)}/run`;
+    if (this.type === "agent") {
+      this.agent = new MastraAgent({
+        name: this.config.name,
+        instructions: this.config.instructions,
+        model: this.config.model,
+        memory: this.memory ? this.memory : void 0
+      });
+    }
     if (config?.memory) {
       console.log("[EXULU] Initializing memory for agent " + this.name);
       const connectionString = `postgresql://${process.env.POSTGRES_DB_USER}:${process.env.POSTGRES_DB_PASSWORD}@${process.env.POSTGRES_DB_HOST}:${process.env.POSTGRES_DB_PORT}/exulu`;
@@ -784,7 +879,11 @@ var ExuluAgent = class {
           password: process.env.POSTGRES_DB_PASSWORD || "",
           ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false
         }),
-        ...config?.memory.vector ? { vector: new PgVector(connectionString) } : {},
+        ...config?.memory.vector ? {
+          vector: new PgVector({
+            connectionString
+          })
+        } : {},
         options: {
           lastMessages: config?.memory.lastMessages || 10,
           semanticRecall: {
@@ -795,33 +894,17 @@ var ExuluAgent = class {
       });
     }
   }
-  chat = async (id) => {
-    const { db: db2 } = await postgresClient();
-    const agent = await db2.from("agents").select("*").where("id", "=", id).first();
-    if (!agent) {
+  chat = () => {
+    if (!this.agent) {
       throw new Error("Agent not found");
     }
-    let tools = {};
-    agent.tools?.forEach(({ name }) => {
-      const tool = this.tools?.find((t) => t.name === name);
-      if (!tool) {
-        return;
-      }
-      return tool;
-    });
     updateStatistic({
       name: "count",
       label: this.name,
       type: STATISTICS_TYPE_ENUM.AGENT_RUN,
       trigger: "agent"
     });
-    return new MastraAgent({
-      name: this.config.name,
-      instructions: this.config.instructions,
-      model: this.config.model,
-      tools,
-      memory: this.memory ? this.memory : void 0
-    });
+    return this.agent;
   };
 };
 var ExuluEmbedder = class {
@@ -878,35 +961,141 @@ var ExuluWorkflow = class {
   enable_batch = false;
   slug = "";
   queue;
-  workflow;
-  inputSchema;
-  constructor({ id, name, description, workflow, queue, enable_batch, inputSchema }) {
+  steps;
+  constructor({ id, name, description, steps, queue, enable_batch }) {
     this.id = id;
     this.name = name;
     this.description = description;
     this.enable_batch = enable_batch;
     this.slug = `/workflows/${generateSlug(this.name)}/run`;
     this.queue = queue;
-    this.inputSchema = inputSchema;
-    this.workflow = workflow;
+    this.steps = steps;
   }
+  start = async ({
+    inputs: initialInputs,
+    user,
+    logger,
+    job,
+    session,
+    agent,
+    label
+  }) => {
+    let inputs;
+    const { db: db2 } = 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({
+        status: JOB_STATUS_ENUM.active,
+        name: `Job running '${this.name}' for '${label}'`,
+        agent,
+        workflow: this.id,
+        type: "workflow",
+        steps: this.steps?.length || 0,
+        inputs: initialInputs,
+        session,
+        user
+      }).returning(["id", "status"]);
+      job = result[0];
+      logger.write(`Created new job for workflow ${this.name}, job id: ${job?.id}`, "INFO");
+    }
+    if (!job) {
+      throw new Error("Job not found, or failed to be created.");
+    }
+    if (job.status !== JOB_STATUS_ENUM.active) {
+      await db2("jobs").update({
+        status: JOB_STATUS_ENUM.active,
+        inputs: initialInputs
+      }).where({ id: job?.id }).returning("id");
+    }
+    const runStep = async (step, inputs2) => {
+      let result;
+      try {
+        result = await step.fn({
+          inputs: inputs2,
+          logger,
+          job,
+          user
+        });
+        return result;
+      } catch (error) {
+        logger.write(`Step ${step.name} failed with error: ${error.message}`, "ERROR");
+        if (step.retries && step.retries > 0) {
+          logger.write(`Retrying step ${step.name} with ${step.retries} retries left`, "INFO");
+          step.retries--;
+          let result2 = await runStep(step, inputs2);
+          return result2;
+        }
+        logger.write(`Step ${step.name} failed with error: ${error.message}`, "ERROR");
+        throw error;
+      }
+    };
+    let final;
+    try {
+      for (let i = 0; i < this.steps.length; i++) {
+        const step = this.steps[i];
+        if (!step) {
+          throw new Error("Step not found.");
+        }
+        if (i === 0) {
+          inputs = initialInputs;
+        }
+        logger.write(`Running step ${step.name} with inputs: ${JSON.stringify(inputs)}`, "INFO");
+        let result = await runStep(step, inputs);
+        inputs = result;
+        logger.write(`Step ${step.name} output: ${JSON.stringify(result)}`, "INFO");
+        final = result;
+      }
+      await db2("jobs").update({
+        status: JOB_STATUS_ENUM.completed,
+        result: JSON.stringify(final),
+        finished_at: db2.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({
+        status: JOB_STATUS_ENUM.failed,
+        result: JSON.stringify({
+          error: error.message || error,
+          stack: error.stack || "No stack trace available"
+        })
+      }).where({ id: job?.id }).returning("id");
+      throw error;
+    }
+  };
 };
 var ExuluLogger = class {
   logPath;
   job;
   constructor(job, logsDir) {
     this.job = job;
-    if (!fs.existsSync(logsDir)) {
-      fs.mkdirSync(logsDir, { recursive: true });
+    if (logsDir && job) {
+      if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+      }
+      this.logPath = path.join(logsDir, `${job.id}_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.txt`);
     }
-    this.logPath = path.join(logsDir, `${job.id}_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.txt`);
   }
   async write(message, level) {
     const logMessage = message.endsWith("\n") ? message : message + "\n";
+    if (!this.logPath) {
+      switch (level) {
+        case "INFO":
+          console.log(message);
+          break;
+        case "WARNING":
+          console.warn(message);
+          break;
+        case "ERROR":
+          console.error(message);
+          break;
+      }
+      return;
+    }
     try {
       await fs.promises.appendFile(this.logPath, `[EXULU][${level}] - ${(/* @__PURE__ */ new Date()).toISOString()}: ${logMessage}`);
     } catch (error) {
-      console.error(`Error writing to log file ${this.job.id}:`, error);
+      console.error(`Error writing to log file ${this.job ? this.job.id : "unknown job"}:`, error);
       throw error;
     }
   }
@@ -1469,7 +1658,7 @@ import "express";
 import { getToken } from "next-auth/jwt";
 
 // src/auth/auth.ts
-import bcrypt3 from "bcryptjs";
+import bcrypt2 from "bcryptjs";
 var authentication = async ({
   apikey,
   authtoken,
@@ -1562,16 +1751,14 @@ var authentication = async ({
         code: 401
       };
     }
-    console.log("[EXULU] users", users);
     console.log("[EXULU] request_key_name", request_key_name);
     console.log("[EXULU] request_key_compare_value", request_key_compare_value);
     const filtered = users.filter(({ apikey: apikey2, id }) => apikey2.includes(request_key_name));
-    console.log("[EXULU] filtered", filtered);
     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);
       console.log("[EXULU] user_key_compare_value", user_key_compare_value);
-      const isMatch = await bcrypt3.compare(request_key_compare_value, user_key_compare_value);
+      const isMatch = await bcrypt2.compare(request_key_compare_value, user_key_compare_value);
       console.log("[EXULU] isMatch", isMatch);
       if (isMatch) {
         await db2.from("users").where({ id: user.id }).update({
@@ -1793,6 +1980,7 @@ var VectorMethodEnum = {
 // 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";
 
@@ -2129,8 +2317,8 @@ import { expressMiddleware } from "@as-integrations/express5";
 
 // src/registry/uppy.ts
 import "express";
+import bodyParser from "body-parser";
 import { getToken as getToken2 } from "next-auth/jwt";
-var bodyParser = __require("body-parser");
 var createUppyRoutes = async (app) => {
   const {
     S3Client,
@@ -2526,7 +2714,6 @@ var createUppyRoutes = async (app) => {
 
 // src/registry/routes.ts
 import { InMemoryLRUCache } from "@apollo/utils.keyvaluecache";
-var Papa = __require("papaparse");
 var global_queues = {
   logs_cleaner: "logs-cleaner"
 };
@@ -2624,7 +2811,7 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
   } else {
     console.log("===========================", "[EXULU] no redis server configured, not setting up recurring jobs.", "===========================");
   }
-  const schema = createSDL([usersSchema, rolesSchema, agentsSchema, jobsSchema]);
+  const schema = createSDL([usersSchema, rolesSchema, agentsSchema, jobsSchema, workflowSchema, threadsSchema, messagesSchema]);
   console.log("[EXULU] graphql server");
   const server = new ApolloServer({
     cache: new InMemoryLRUCache(),
@@ -2680,6 +2867,7 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
         description: agent.description,
         active: agent.active,
         public: agent.public,
+        type: agent.type,
         slug: backend?.slug,
         rateLimit: backend?.rateLimit,
         streaming: backend?.streaming,
@@ -2889,21 +3077,27 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
       }
       const context = contexts.find((context2) => context2.id === req.params.context);
       if (!context) {
+        console.error("[EXULU] context not found in registry.", req.params.context);
         res.status(400).json({
           message: "Context not found in registry."
         });
         return;
       }
+      console.log("[EXULU] context", context);
       const exists = await context.tableExists();
       if (!exists) {
+        console.log("[EXULU] context table does not exist, creating it.");
         await context.createItemsTable();
       }
+      console.log("[EXULU] inserting item", req.body);
       const result = await context.insertItem(authenticationResult.user.id, req.body, !!req.body.upsert);
+      console.log("[EXULU] result", result);
       res.status(200).json({
         message: "Item created successfully.",
         id: result
       });
     } catch (error) {
+      console.error("[EXULU] error upserting item", error);
       res.status(500).json({
         message: error?.message || "An error occurred while creating the item."
       });
@@ -3248,7 +3442,7 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
       slug: workflow.slug,
       enable_batch: workflow.enable_batch,
       queue: workflow.queue?.name,
-      inputSchema: workflow.inputSchema ? zerialize(workflow.inputSchema) : null
+      inputSchema: workflow.steps[0]?.inputSchema ? zerialize(workflow.steps[0].inputSchema) : null
     })));
   });
   console.log("[EXULU] workflow by id");
@@ -3275,7 +3469,7 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
     res.status(200).json({
       ...workflow,
       queue: workflow.queue?.name,
-      inputSchema: workflow.inputSchema ? zerialize(workflow.inputSchema) : null,
+      inputSchema: workflow.steps[0]?.inputSchema ? zerialize(workflow.steps[0].inputSchema) : null,
       workflow: void 0
     });
   });
@@ -3411,10 +3605,6 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
       note: `Execute workflow ${workflow.name}`
     });
     app.post(`${workflow.slug}`, async (req, res) => {
-      if (!workflow.queue) {
-        res.status(500).json({ detail: "No queue set for workflow." });
-        return;
-      }
       const authenticationResult = await requestValidators.authenticate(req);
       if (!authenticationResult.user?.id) {
         res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
@@ -3431,6 +3621,7 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
           label: `Job running '${workflow.name}' for '${req.body.label}'`,
           agent: req.body.agent,
           workflow: workflow.id,
+          steps: workflow.steps?.length || 0,
           type: "workflow",
           inputs,
           session: req.body.session,
@@ -3449,22 +3640,19 @@ var createExpressRoutes = async (app, agents, embedders, tools, workflows, conte
         });
         return;
       }
-      const { runId, start, watch } = workflow.workflow.createRun();
       console.log("[EXULU] running workflow with inputs.", inputs);
-      const output = await start({
-        triggerData: {
-          ...inputs,
-          user: authenticationResult.user.id
-        }
+      const logger = new ExuluLogger();
+      const result = await workflow.start({
+        inputs,
+        user: authenticationResult.user.id,
+        logger,
+        session: req.body.session,
+        agent: req.body.agent,
+        label: req.body.label
       });
-      const failedSteps = Object.entries(output.results).filter(([_, step]) => step.status === "failed").map(([id, step]) => `${id}: ${step.error}`);
-      if (failedSteps.length > 0) {
-        const message = `Workflow has failed steps: ${failedSteps.join("\n - ")}`;
-        throw new Error(message);
-      }
       res.status(200).json({
         "job": {},
-        "output": output
+        "output": result
       });
       return;
     });
@@ -3527,43 +3715,40 @@ import { Worker } from "bullmq";
 // src/registry/utils.ts
 import "bullmq";
 var bullmq = {
-  validate: (job) => {
-    if (!job.data) {
-      throw new Error(`Missing job data for job ${job.id}.`);
+  validate: (bullmqJob) => {
+    if (!bullmqJob.data) {
+      throw new Error(`Missing job data for job ${bullmqJob.id}.`);
     }
-    if (!job.data.type) {
-      throw new Error(`Missing property "type" in data for job ${job.id}.`);
+    if (!bullmqJob.data.type) {
+      throw new Error(`Missing property "type" in data for job ${bullmqJob.id}.`);
     }
-    if (!job.data.inputs) {
-      throw new Error(`Missing property "inputs" in data for job ${job.id}.`);
+    if (!bullmqJob.data.inputs) {
+      throw new Error(`Missing property "inputs" in data for job ${bullmqJob.id}.`);
     }
-    if (job.data.type !== "embedder" && job.data.type !== "workflow") {
-      throw new Error(`Property "type" in data for job ${job.id} must be of value "embedder" or "workflow".`);
+    if (bullmqJob.data.type !== "embedder" && bullmqJob.data.type !== "workflow") {
+      throw new Error(`Property "type" in data for job ${bullmqJob.id} must be of value "embedder" or "workflow".`);
     }
-    if (!job.data.workflow && !job.data.embedder) {
-      throw new Error(`Property "backend" in data for job ${job.id} missing. Job  data: ${JSON.stringify(job)}`);
+    if (!bullmqJob.data.workflow && !bullmqJob.data.embedder) {
+      throw new Error(`Property "backend" in data for job ${bullmqJob.id} missing. Job  data: ${JSON.stringify(bullmqJob)}`);
     }
   },
   process: {
-    workflow: async (job, workflow, logsDir) => {
+    workflow: async (bullmqJob, exuluJob, workflow, logsDir) => {
       if (!workflow) {
-        throw new Error(`Workflow function with id: ${job.data.backend} not found in registry.`);
-      }
-      const { runId, start, watch } = workflow.workflow.createRun();
-      console.log("[EXULU] starting workflow with job inputs.", job.data.inputs);
-      const logger = new ExuluLogger(job, logsDir);
-      const output = await start({ triggerData: {
-        ...job.data.inputs,
-        redis: job.id,
-        logger
-      } });
-      const failedSteps = Object.entries(output.results).filter(([_, step]) => step.status === "failed").map(([id, step]) => `${id}: ${step.error}`);
-      if (failedSteps.length > 0) {
-        const message = `Workflow has failed steps: ${failedSteps.join("\n - ")}`;
-        logger.write(message, "ERROR");
-        throw new Error(message);
-      }
-      await logger.write(`Workflow completed. ${JSON.stringify(output.results)}`, "INFO");
+        throw new Error(`Workflow function with id: ${bullmqJob.data.backend} not found in registry.`);
+      }
+      console.log("[EXULU] starting workflow with job inputs.", bullmqJob.data.inputs);
+      const logger = new ExuluLogger(exuluJob, logsDir);
+      const output = await workflow.start({
+        job: exuluJob,
+        inputs: bullmqJob.data.inputs,
+        user: bullmqJob.data.user,
+        logger,
+        session: bullmqJob.data.session,
+        agent: bullmqJob.data.agent,
+        label: bullmqJob.data.label
+      });
+      await logger.write(`Workflow completed. ${JSON.stringify(output)}`, "INFO");
       return output;
     }
   }
@@ -3590,56 +3775,56 @@ var createWorkers = async (queues2, contexts, embedders, workflows, _logsDir) =>
     console.log(`[EXULU] creating worker for queue ${queue}.`);
     const worker = new Worker(
       `${queue}`,
-      async (job) => {
+      async (bullmqJob) => {
         const { db: db2 } = await postgresClient();
         try {
-          bullmq.validate(job);
-          if (job.data.type === "embedder") {
-            if (!job.data.updater) {
+          bullmq.validate(bullmqJob);
+          if (bullmqJob.data.type === "embedder") {
+            if (!bullmqJob.data.updater) {
               throw new Error("No updater set for embedder job.");
             }
-            const context = contexts.find((context2) => context2.id === job.data.context);
+            const context = contexts.find((context2) => context2.id === bullmqJob.data.context);
             if (!context) {
-              throw new Error(`Context ${job.data.context} not found in the registry.`);
+              throw new Error(`Context ${bullmqJob.data.context} not found in the registry.`);
             }
-            if (!job.data.embedder) {
+            if (!bullmqJob.data.embedder) {
               throw new Error(`No embedder set for embedder job.`);
             }
-            const embedder = embedders.find((embedder2) => embedder2.id === job.data.embedder);
+            const embedder = embedders.find((embedder2) => embedder2.id === bullmqJob.data.embedder);
             if (!embedder) {
-              throw new Error(`Embedder ${job.data.embedder} not found in the registry.`);
+              throw new Error(`Embedder ${bullmqJob.data.embedder} not found in the registry.`);
             }
-            if (!job.data.source) {
+            if (!bullmqJob.data.source) {
               throw new Error("No source set for embedder job.");
             }
-            const source = context.sources.get(job.data.source);
+            const source = context.sources.get(bullmqJob.data.source);
             if (!source) {
-              throw new Error(`Source ${job.data.source} not found in the registry.`);
+              throw new Error(`Source ${bullmqJob.data.source} not found in the registry.`);
             }
-            if (!job.data.updater) {
+            if (!bullmqJob.data.updater) {
               throw new Error("No updater set for embedder job.");
             }
-            const updater = source.updaters.find((updater2) => updater2.id === job.data.updater);
+            const updater = source.updaters.find((updater2) => updater2.id === bullmqJob.data.updater);
             if (!updater) {
-              throw new Error(`Updater ${job.data.updater} not found in the registry.`);
+              throw new Error(`Updater ${bullmqJob.data.updater} not found in the registry.`);
             }
-            if (!job.data.documents) {
+            if (!bullmqJob.data.documents) {
               throw new Error("No input documents set for embedder job.");
             }
-            if (!Array.isArray(job.data.documents)) {
+            if (!Array.isArray(bullmqJob.data.documents)) {
               throw new Error("Input documents must be an array.");
             }
-            const result = await embedder.upsert(job.data.context, job.data.documents, {
+            const result = await embedder.upsert(bullmqJob.data.context, bullmqJob.data.documents, {
               label: context.name,
-              trigger: job.data.trigger || "unknown"
+              trigger: bullmqJob.data.trigger || "unknown"
             });
-            const mongoRecord = await db2.from("jobs").where({ redis: job.id }).first();
+            const mongoRecord = await db2.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: job.id }).update({
+            await db2.from("jobs").where({ redis: bullmqJob.id }).update({
               status: "completed",
               finishedAt,
               duration,
@@ -3647,19 +3832,19 @@ var createWorkers = async (queues2, contexts, embedders, workflows, _logsDir) =>
             });
             return result;
           }
-          if (job.data.type === "workflow") {
-            const workflow = workflows.find((workflow2) => workflow2.id === job.data.workflow);
+          if (bullmqJob.data.type === "workflow") {
+            const workflow = workflows.find((workflow2) => workflow2.id === bullmqJob.data.workflow);
             if (!workflow) {
-              throw new Error(`Workflow ${job.data.workflow} not found in the registry.`);
+              throw new Error(`Workflow ${bullmqJob.data.workflow} not found in the registry.`);
             }
-            const result = await bullmq.process.workflow(job, workflow, logsDir);
-            const mongoRecord = await db2.from("jobs").where({ redis: job.id }).first();
-            if (!mongoRecord) {
+            const exuluJob = await db2.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(mongoRecord.createdAt).getTime()) / 1e3;
-            await db2.from("jobs").where({ redis: job.id }).update({
+            const duration = (finishedAt.getTime() - new Date(exuluJob.createdAt).getTime()) / 1e3;
+            await db2.from("jobs").where({ redis: bullmqJob.id }).update({
               status: "completed",
               finishedAt,
               duration,
@@ -3668,7 +3853,7 @@ var createWorkers = async (queues2, contexts, embedders, workflows, _logsDir) =>
             return result;
           }
         } catch (error) {
-          await db2.from("jobs").where({ redis: job.id }).update({
+          await db2.from("jobs").where({ redis: bullmqJob.id }).update({
             status: "failed",
             finishedAt: /* @__PURE__ */ new Date(),
             error: error instanceof Error ? error.message : String(error)
@@ -3810,12 +3995,19 @@ var ExuluApp = class {
 };
 
 // src/index.ts
+import { RecursiveChunker, SentenceChunker } from "chonkie";
 var ExuluJobs = {
   redis: redisClient,
   jobs: {
     validate: validateJob
   }
 };
+var ExuluChunkers = {
+  chonkie: {
+    sentence: SentenceChunker,
+    recursive: RecursiveChunker
+  }
+};
 var ExuluDatabase = {
   init: async () => {
     await execute();
@@ -3825,14 +4017,17 @@ var ExuluDatabase = {
   }
 };
 export {
+  JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM,
   STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM,
   ExuluAgent,
   ExuluApp,
   authentication as ExuluAuthentication,
+  ExuluChunkers,
   ExuluContext,
   ExuluDatabase,
   ExuluEmbedder,
   ExuluJobs,
+  ExuluLogger,
   queues as ExuluQueues,
   ExuluSource,
   ExuluTool,