@exulu/backend 1.16.0 → 1.17.0

package/dist/index.js

@@ -175,87 +175,48 @@ import pgvector2 from "pgvector/knex";
 import "bullmq";
 import { v4 as uuidv4 } from "uuid";
 var bullmqDecorator = async ({
+  queue,
   label,
-  type,
-  workflow,
   embedder,
   inputs,
-  queue,
   user,
-  agent,
-  session,
-  configuration,
-  updater,
-  context,
-  steps,
-  source,
-  documents,
+  role,
   trigger,
-  item
+  workflow,
+  item,
+  context
 }) => {
+  if (embedder && workflow) {
+    throw new Error("Cannot have both embedder and workflow in the same job.");
+  }
+  if (workflow && item) {
+    throw new Error("Cannot have both workflow and item in the same job.");
+  }
+  let type = "embedder";
+  if (workflow) {
+    type = "workflow";
+  }
   const redisId = uuidv4();
   const job = await queue.add(
     `${embedder || workflow}`,
     {
-      type: `${type}`,
+      label,
       ...embedder && { embedder },
-      ...workflow && { workflow },
-      ...configuration && { configuration },
-      ...updater && { updater },
-      ...context && { context },
-      ...source && { source },
-      ...documents && { documents },
-      ...steps && { steps },
+      type: `${type}`,
+      inputs,
+      ...user && { user },
+      ...role && { role },
       ...trigger && { trigger },
+      ...workflow && { workflow },
       ...item && { item },
-      agent,
-      user,
-      inputs,
-      label,
-      session
+      ...context && { context }
     },
     {
       jobId: redisId
     }
   );
-  const { db: db3 } = 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 db3("jobs").insert(insertData).onConflict("redis").merge({
-    ...insertData,
-    updatedAt: now
-    // Only updatedAt changes on updates
-  });
-  const doc = await db3.from("jobs").where({ redis: job.id }).first();
-  if (!doc?.id) {
-    throw new Error("Failed to get job ID after insert/update");
-  }
-  console.log("[EXULU] created job", doc?.id);
   return {
     ...job,
-    id: doc?.id,
     redis: job.id
   };
 };
@@ -427,6 +388,7 @@ var ExuluEvalUtils = {
 // src/registry/classes.ts
 import CryptoJS from "crypto-js";
 import "express";
+import "@opentelemetry/api";
 function sanitizeToolName(name) {
   if (typeof name !== "string") return "";
   let sanitized = name.replace(/[^a-zA-Z0-9_-]+/g, "_");
@@ -602,6 +564,9 @@ var ExuluAgent = class {
     if (prompt && message) {
       throw new Error("Message and prompt cannot be provided at the same time.");
     }
+    if (!prompt && !message) {
+      throw new Error("Prompt or message is required for generating.");
+    }
     const model = this.model.create({
       apiKey: providerApiKey
     });
@@ -621,28 +586,52 @@ var ExuluAgent = class {
     }
     console.log("[EXULU] Model provider key", providerApiKey);
     console.log("[EXULU] Tool configs", toolConfigs);
-    const { text } = await generateText({
-      model,
-      // Should be a LanguageModelV1
-      system: "You are a helpful assistant. When you use a tool to answer a question do not explicitly comment on the result of the tool call unless the user has explicitly you to do something with the result.",
-      messages: messages ? convertToModelMessages(messages) : void 0,
-      prompt,
-      maxRetries: 2,
-      tools: convertToolsArrayToObject(tools, toolConfigs, providerApiKey, user, role),
-      stopWhen: [stepCountIs(5)]
-    });
-    if (statistics) {
-      await updateStatistic({
-        name: "count",
-        label: statistics.label,
-        type: STATISTICS_TYPE_ENUM.AGENT_RUN,
-        trigger: statistics.trigger,
-        count: 1,
-        user,
-        role
+    if (prompt) {
+      const { text } = await generateText({
+        model,
+        // Should be a LanguageModelV1
+        system: "You are a helpful assistant. When you use a tool to answer a question do not explicitly comment on the result of the tool call unless the user has explicitly you to do something with the result.",
+        prompt,
+        maxRetries: 2,
+        tools: convertToolsArrayToObject(tools, toolConfigs, providerApiKey, user, role),
+        stopWhen: [stepCountIs(5)]
+      });
+      if (statistics) {
+        await updateStatistic({
+          name: "count",
+          label: statistics.label,
+          type: STATISTICS_TYPE_ENUM.AGENT_RUN,
+          trigger: statistics.trigger,
+          count: 1,
+          user,
+          role
+        });
+      }
+      return text;
+    }
+    if (messages) {
+      const { text } = await generateText({
+        model,
+        // Should be a LanguageModelV1
+        system: "You are a helpful assistant. When you use a tool to answer a question do not explicitly comment on the result of the tool call unless the user has explicitly you to do something with the result.",
+        messages: convertToModelMessages(messages),
+        maxRetries: 2,
+        tools: convertToolsArrayToObject(tools, toolConfigs, providerApiKey, user, role),
+        stopWhen: [stepCountIs(5)]
       });
+      if (statistics) {
+        await updateStatistic({
+          name: "count",
+          label: statistics.label,
+          type: STATISTICS_TYPE_ENUM.AGENT_RUN,
+          trigger: statistics.trigger,
+          count: 1,
+          user,
+          role
+        });
+      }
+      return text;
     }
-    return text;
   };
   generateStream = async ({ express: express3, user, role, session, message, tools, statistics, toolConfigs, providerApiKey }) => {
     if (!this.model) {
@@ -674,7 +663,7 @@ var ExuluAgent = class {
     const result = streamText({
       model,
       // Should be a LanguageModelV1
-      messages: messages ? convertToModelMessages(messages) : void 0,
+      messages: convertToModelMessages(messages),
       system: "You are a helpful assistant. When you use a tool to answer a question do not explicitly comment on the result of the tool call unless the user has explicitly you to do something with the result.",
       maxRetries: 2,
       tools: convertToolsArrayToObject(tools, toolConfigs, providerApiKey, user, role),
@@ -1036,8 +1025,36 @@ var ExuluContext = class {
     const tableExists = await db3.schema.hasTable(this.getTableName());
     return tableExists;
   };
-  async updateItem(user, id, item, role) {
-    if (!id) {
+  createAndUpsertEmbeddings = async (item, user, statistics, role) => {
+    const { db: db3 } = await postgresClient();
+    const { id: source, chunks } = await this.embedder.generateFromDocument({
+      ...item,
+      id: item.id
+    }, {
+      label: statistics.label || this.name,
+      trigger: statistics.trigger || "agent"
+    }, user, role);
+    const exists = await db3.schema.hasTable(this.getChunksTableName());
+    if (!exists) {
+      await this.createChunksTable();
+    }
+    await db3.from(this.getChunksTableName()).where({ source }).delete();
+    await db3.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
+      source,
+      content: chunk.content,
+      chunk_index: chunk.index,
+      embedding: pgvector2.toSql(chunk.vector)
+    })));
+    await db3.from(this.getTableName()).where({ id: item.id }).update({
+      embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).returning("id");
+    return {
+      id: item.id,
+      chunks: chunks?.length || 0
+    };
+  };
+  async updateItem(user, item, role, trigger) {
+    if (!item.id) {
       throw new Error("Id is required for updating an item.");
     }
     const { db: db3 } = await postgresClient();
@@ -1054,51 +1071,37 @@ var ExuluContext = class {
     delete item.created_at;
     delete item.upsert;
     item.updated_at = db3.fn.now();
-    const result = await db3.from(this.getTableName()).where({ id }).update(item).returning("id");
+    const result = await db3.from(this.getTableName()).where({ id: item.id }).update(item).returning("id");
     if (this.configuration.calculateVectors === "onUpdate" || this.configuration.calculateVectors === "always") {
       if (this.embedder.queue?.name) {
         console.log("[EXULU] embedder is in queue mode, scheduling job.");
         const job = await bullmqDecorator({
-          label: `Job running '${this.embedder.name}' for '${item.name} (${item.id}).'`,
+          label: `${this.embedder.name}`,
           embedder: this.embedder.id,
-          type: "embedder",
+          context: this.id,
           inputs: item,
+          item: item.id,
           queue: this.embedder.queue,
-          user
+          user,
+          role,
+          trigger: trigger || "agent"
         });
         return {
           id: result[0].id,
           job: job.id
         };
       }
-      const { id: source, chunks } = await this.embedder.generateFromDocument({
-        ...item,
-        id
-      }, {
-        label: this.name,
-        trigger: "agent"
-      }, user, role);
-      const exists = await db3.schema.hasTable(this.getChunksTableName());
-      if (!exists) {
-        await this.createChunksTable();
-      }
-      await db3.from(this.getChunksTableName()).where({ source }).delete();
-      await db3.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
-        source,
-        content: chunk.content,
-        chunk_index: chunk.index,
-        embedding: pgvector2.toSql(chunk.vector)
-      })));
-      await db3.from(this.getTableName()).where({ id }).update({
-        embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      }).returning("id");
+      await this.createAndUpsertEmbeddings(item, user, {
+        label: this.embedder.name,
+        trigger: trigger || "agent"
+      }, role);
     }
     return {
       id: result[0].id,
       job: void 0
     };
   }
-  async insertItem(user, item, upsert = false, role) {
+  async insertItem(user, item, upsert = false, role, trigger) {
     if (!item.name) {
       throw new Error("Name field is required.");
     }
@@ -1109,14 +1112,20 @@ var ExuluContext = class {
         throw new Error("Item with external id " + item.external_id + " already exists.");
       }
       if (existingItem && upsert) {
-        await this.updateItem(user, existingItem.id, item, role);
+        await this.updateItem(user, {
+          ...item,
+          id: existingItem.id
+        }, role, trigger);
         return existingItem.id;
       }
     }
     if (upsert && item.id) {
       const existingItem = await db3.from(this.getTableName()).where({ id: item.id }).first();
       if (existingItem && upsert) {
-        await this.updateItem(user, existingItem.id, item, role);
+        await this.updateItem(user, {
+          ...item,
+          id: existingItem.id
+        }, role, trigger);
         return existingItem.id;
       }
     }
@@ -1141,12 +1150,15 @@ var ExuluContext = class {
       if (this.embedder.queue?.name) {
         console.log("[EXULU] embedder is in queue mode, scheduling job.");
         const job = await bullmqDecorator({
-          label: `Job running '${this.embedder.name}' for '${item.name} (${item.id}).'`,
+          label: `${this.embedder.name}`,
           embedder: this.embedder.id,
-          type: "embedder",
+          context: this.id,
           inputs: item,
+          item: item.id,
           queue: this.embedder.queue,
-          user
+          user,
+          role,
+          trigger: trigger || "agent"
         });
         return {
           id: result[0].id,
@@ -1154,27 +1166,13 @@ var ExuluContext = class {
         };
       }
       console.log("[EXULU] embedder is not in queue mode, calculating vectors directly.");
-      const { id: source, chunks } = await this.embedder.generateFromDocument({
+      await this.createAndUpsertEmbeddings({
         ...item,
         id: result[0].id
-      }, {
-        label: this.name,
-        trigger: "agent"
-      }, user, role);
-      const exists = await db3.schema.hasTable(this.getChunksTableName());
-      if (!exists) {
-        await this.createChunksTable();
-      }
-      console.log("[EXULU] Inserting chunks.");
-      await db3.from(this.getChunksTableName()).insert(chunks.map((chunk) => ({
-        source,
-        content: chunk.content,
-        chunk_index: chunk.index,
-        embedding: pgvector2.toSql(chunk.vector)
-      })));
-      await db3.from(this.getTableName()).where({ id: result[0].id }).update({
-        embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      }).returning("id");
+      }, user, {
+        label: this.embedder.name,
+        trigger: trigger || "agent"
+      }, role);
     }
     return {
       id: result[0].id,
@@ -1875,6 +1873,7 @@ import { zerialize } from "zodex";
 
 // src/bullmq/queues.ts
 import { Queue as Queue3 } from "bullmq";
+import { BullMQOtel } from "bullmq-otel";
 var ExuluQueues = class {
   queues;
   constructor() {
@@ -1892,7 +1891,13 @@ var ExuluQueues = class {
       console.error(`[EXULU] no redis server configured, but you are trying to use a queue ( ${name}), likely in an agent or embedder (look for ExuluQueues.use() ).`);
       throw new Error(`[EXULU] no redis server configured.`);
     }
-    const newQueue = new Queue3(`${name}`, { connection: redisServer });
+    const newQueue = new Queue3(
+      `${name}`,
+      {
+        connection: redisServer,
+        telemetry: new BullMQOtel("simple-guide")
+      }
+    );
     this.queues.push(newQueue);
     return newQueue;
   }
@@ -3679,6 +3684,7 @@ Intelligence Management Platform
 import OpenAI from "openai";
 import fs2 from "fs";
 import { randomUUID } from "crypto";
+import "@opentelemetry/api";
 var REQUEST_SIZE_LIMIT = "50mb";
 var global_queues = {
   logs_cleaner: "logs-cleaner"
@@ -3717,7 +3723,7 @@ var createRecurringJobs = async () => {
   console.table(recurringJobSchedulersLogs);
   return queue;
 };
-var createExpressRoutes = async (app, agents, tools, contexts) => {
+var createExpressRoutes = async (app, logger, agents, tools, contexts, config, tracer) => {
   const routeLogs = [];
   var corsOptions = {
     origin: "*",
@@ -3811,6 +3817,16 @@ var createExpressRoutes = async (app, agents, tools, contexts) => {
     express.json({ limit: REQUEST_SIZE_LIMIT }),
     expressMiddleware(server, {
       context: async ({ req }) => {
+        logger.info("================");
+        logger.info({
+          message: "Incoming Request",
+          method: req.method,
+          path: req.path,
+          requestId: "req-" + Date.now(),
+          ipAddress: req.ip,
+          userAgent: req.get("User-Agent")
+        });
+        logger.info("================");
         const authenticationResult = await requestValidators.authenticate(req);
         if (!authenticationResult.user?.id) {
           throw new Error(authenticationResult.message);
@@ -4197,7 +4213,15 @@ Mood: friendly and intelligent.
     if (!exists) {
       await context.createItemsTable();
     }
-    const result = await context.updateItem(authenticationResult.user.id, req.params.id, req.body, authenticationResult.user.role?.id);
+    const result = await context.updateItem(
+      authenticationResult.user.id,
+      {
+        ...req.body,
+        id: req.params.id
+      },
+      authenticationResult.user.role?.id,
+      authenticationResult.user.type === "api" ? "api" : "user"
+    );
     res.status(200).json({
       message: "Item updated successfully.",
       id: result
@@ -4244,7 +4268,13 @@ Mood: friendly and intelligent.
         await context.createItemsTable();
       }
       console.log("[EXULU] inserting item", req.body);
-      const result = await context.insertItem(authenticationResult.user.id, req.body, !!req.body.upsert, authenticationResult.user.role?.id);
+      const result = await context.insertItem(
+        authenticationResult.user.id,
+        req.body,
+        !!req.body.upsert,
+        authenticationResult.user.role?.id,
+        authenticationResult.user.type === "api" ? "api" : "user"
+      );
       console.log("[EXULU] result", result);
       res.status(200).json({
         message: "Item created successfully.",
@@ -4593,7 +4623,7 @@ Mood: friendly and intelligent.
         return;
       }
       console.log("[EXULU] agent tools", agentInstance.tools);
-      const enabledTools = agentInstance.tools.map(({ config, toolId }) => tools.find(({ id }) => id === toolId)).filter(Boolean);
+      const enabledTools = agentInstance.tools.map(({ config: config2, toolId }) => tools.find(({ id }) => id === toolId)).filter(Boolean);
       console.log("[EXULU] enabled tools", enabledTools);
       const variableName = agentInstance.providerApiKey;
       const variable = await db3.from("variables").where({ name: variableName }).first();
@@ -4799,43 +4829,22 @@ import IORedis from "ioredis";
 import { Worker } from "bullmq";
 
 // src/registry/utils.ts
-import "bullmq";
 var bullmq = {
-  validate: (bullmqJob) => {
-    if (!bullmqJob.data) {
-      throw new Error(`Missing job data for job ${bullmqJob.id}.`);
+  validate: (id, data) => {
+    if (!data) {
+      throw new Error(`Missing job data for job ${id}.`);
     }
-    if (!bullmqJob.data.type) {
-      throw new Error(`Missing property "type" in data for job ${bullmqJob.id}.`);
+    if (!data.type) {
+      throw new Error(`Missing property "type" in data for job ${id}.`);
     }
-    if (!bullmqJob.data.inputs) {
-      throw new Error(`Missing property "inputs" in data for job ${bullmqJob.id}.`);
+    if (!data.inputs) {
+      throw new Error(`Missing property "inputs" in data for job ${id}.`);
     }
-    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 (data.type !== "embedder" && data.type !== "workflow") {
+      throw new Error(`Property "type" in data for job ${id} must be of value "embedder" or "workflow".`);
     }
-    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 (bullmqJob, exuluJob, workflow, logsDir) => {
-      if (!workflow) {
-        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;
+    if (!data.workflow && !data.embedder) {
+      throw new Error(`Either a workflow or embedder must be set for job ${id}.`);
     }
   }
 };
@@ -4843,9 +4852,10 @@ var bullmq = {
 // src/registry/workers.ts
 import * as fs3 from "fs";
 import path2 from "path";
+import "@opentelemetry/api";
 var defaultLogsDir = path2.join(process.cwd(), "logs");
 var redisConnection;
-var createWorkers = async (queues2, contexts, _logsDir) => {
+var createWorkers = async (queues2, logger, contexts, _logsDir, tracer) => {
   if (!redisServer.host || !redisServer.port) {
     console.error("[EXULU] you are trying to start worker, but no redis server is configured in the environment.");
     throw new Error("No redis server configured in the environment, so cannot start worker.");
@@ -4862,84 +4872,30 @@ var createWorkers = async (queues2, contexts, _logsDir) => {
     const worker = new Worker(
       `${queue}`,
       async (bullmqJob) => {
+        const logger2 = new ExuluLogger(bullmqJob, logsDir);
         const { db: db3 } = await postgresClient();
         try {
-          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 === bullmqJob.data.context);
+          const data = bullmqJob.data;
+          bullmq.validate(bullmqJob.id, data);
+          if (data.type === "embedder") {
+            const context = contexts.find((context2) => context2.id === data.context);
             if (!context) {
-              throw new Error(`Context ${bullmqJob.data.context} not found in the registry.`);
+              throw new Error(`Context ${data.context} not found in the registry.`);
             }
-            if (!bullmqJob.data.embedder) {
+            if (!data.embedder) {
               throw new Error(`No embedder set for embedder job.`);
             }
-            const embedder = contexts.find((context2) => context2.embedder?.id === bullmqJob.data.embedder);
+            const embedder = contexts.find((context2) => context2.embedder?.id === data.embedder);
             if (!embedder) {
-              throw new Error(`Embedder ${bullmqJob.data.embedder} not found in the registry.`);
-            }
-            if (!bullmqJob.data.source) {
-              throw new Error("No source set for embedder job.");
-            }
-            const source = context.sources.get(bullmqJob.data.source);
-            if (!source) {
-              throw new Error(`Source ${bullmqJob.data.source} not found in the registry.`);
-            }
-            if (!bullmqJob.data.updater) {
-              throw new Error("No updater set for embedder job.");
-            }
-            const updater = source.updaters.find((updater2) => updater2.id === bullmqJob.data.updater);
-            if (!updater) {
-              throw new Error(`Updater ${bullmqJob.data.updater} not found in the registry.`);
-            }
-            if (!bullmqJob.data.documents) {
-              throw new Error("No input documents set for embedder job.");
-            }
-            if (!Array.isArray(bullmqJob.data.documents)) {
-              throw new Error("Input documents must be an array.");
+              throw new Error(`Embedder ${data.embedder} not found in the registry.`);
             }
-            const result = await embedder.upsert(bullmqJob.data.context, bullmqJob.data.documents, {
-              label: context.name,
-              trigger: bullmqJob.data.trigger || "unknown"
+            const result = await context.createAndUpsertEmbeddings(data.inputs, data.user, {
+              label: embedder.name,
+              trigger: data.trigger
             });
-            const mongoRecord = await db3.from("jobs").where({ redis: bullmqJob.id }).first();
-            if (!mongoRecord) {
-              throw new Error("Job not found in the database.");
-            }
-            const finishedAt = /* @__PURE__ */ new Date();
-            const duration = (finishedAt.getTime() - new Date(mongoRecord.createdAt).getTime()) / 1e3;
-            await db3.from("jobs").where({ redis: bullmqJob.id }).update({
-              status: "completed",
-              finishedAt,
-              duration,
-              result: JSON.stringify(result)
-            });
-            await db3.from((void 0).getTableName()).where({ id: result[0].id }).update({
-              embeddings_updated_at: (/* @__PURE__ */ new Date()).toISOString()
-            }).returning("id");
             return result;
           }
           if (bullmqJob.data.type === "workflow") {
-            const workflow = workflows.find((workflow2) => workflow2.id === bullmqJob.data.workflow);
-            if (!workflow) {
-              throw new Error(`Workflow ${bullmqJob.data.workflow} not found in the registry.`);
-            }
-            const exuluJob = await db3.from("jobs").where({ redis: bullmqJob.id }).first();
-            if (!exuluJob) {
-              throw new Error("Job not found in the database.");
-            }
-            const result = await bullmq.process.workflow(bullmqJob, exuluJob, workflow, logsDir);
-            const finishedAt = /* @__PURE__ */ new Date();
-            const duration = (finishedAt.getTime() - new Date(exuluJob.createdAt).getTime()) / 1e3;
-            await db3.from("jobs").where({ redis: bullmqJob.id }).update({
-              status: "completed",
-              finishedAt,
-              duration,
-              result: JSON.stringify(result)
-            });
-            return result;
           }
         } catch (error) {
           await db3.from("jobs").where({ redis: bullmqJob.id }).update({
@@ -5009,6 +4965,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { z as z2 } from "zod";
 import "express";
+import "@opentelemetry/api";
 var SESSION_ID_HEADER = "mcp-session-id";
 var ExuluMCP = class {
   server;
@@ -5016,7 +4973,7 @@ var ExuluMCP = class {
   express;
   constructor() {
   }
-  create = async ({ express: express3, contexts, agents, config, tools }) => {
+  create = async ({ express: express3, contexts, agents, config, tools, tracer, logger }) => {
     this.express = express3;
     if (!this.server) {
       console.log("[EXULU] Creating MCP server.");
@@ -5194,6 +5151,38 @@ var defaultAgent = new ExuluAgent({
   }
 });
 
+// src/registry/index.ts
+import { trace as trace2 } from "@opentelemetry/api";
+
+// src/registry/logger.ts
+import { OpenTelemetryTransportV3 } from "@opentelemetry/winston-transport";
+import winston from "winston";
+var createLogger = ({
+  enableOtel
+}) => {
+  const logger = winston.createLogger({
+    level: "debug",
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.errors({
+        stack: true
+      }),
+      winston.format.metadata(),
+      winston.format.json()
+    ),
+    defaultMeta: {
+      service: "Test-Exulu",
+      environment: process.env.NODE_ENV || "development"
+    },
+    transports: [
+      new winston.transports.Console(),
+      ...enableOtel ? [new OpenTelemetryTransportV3()] : []
+    ]
+  });
+  return logger;
+};
+var logger_default = createLogger;
+
 // src/registry/index.ts
 var ExuluApp = class {
   _agents = [];
@@ -5260,10 +5249,20 @@ var ExuluApp = class {
   bullmq = {
     workers: {
       create: async () => {
+        let tracer;
+        if (this._config?.telemetry?.enabled) {
+          console.log("[EXULU] telemetry enabled");
+          tracer = trace2.getTracer("exulu", "1.0.0");
+        }
+        const logger = logger_default({
+          enableOtel: this._config?.workers?.telemetry?.enabled ?? false
+        });
         return await createWorkers(
           this._queues,
+          logger,
           Object.values(this._contexts ?? {}),
-          this._config?.workers?.logsDir
+          this._config?.workers?.logsDir,
+          tracer
         );
       }
     }
@@ -5275,11 +5274,22 @@ var ExuluApp = class {
           throw new Error("Express app not initialized");
         }
         const app = this._expressApp;
+        let tracer;
+        if (this._config?.telemetry?.enabled) {
+          console.log("[EXULU] telemetry enabled");
+          tracer = trace2.getTracer("exulu", "1.0.0");
+        }
+        const logger = logger_default({
+          enableOtel: this._config?.telemetry?.enabled ?? false
+        });
         await createExpressRoutes(
           app,
+          logger,
           this._agents,
           this._tools,
-          Object.values(this._contexts ?? {})
+          Object.values(this._contexts ?? {}),
+          this._config,
+          tracer
         );
         if (this._config?.MCP.enabled) {
           const mcp = new ExuluMCP();
@@ -5288,7 +5298,9 @@ var ExuluApp = class {
             contexts: this._contexts,
             agents: this._agents,
             config: this._config,
-            tools: this._tools
+            tools: this._tools,
+            tracer,
+            logger
           });
           await mcp.connect();
         }
@@ -6701,6 +6713,50 @@ var execute = async () => {
   return;
 };
 
+// src/registry/otel.ts
+import process2 from "process";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+var create = ({
+  SIGNOZ_ACCESS_TOKEN,
+  SIGNOZ_TRACES_URL,
+  SIGNOZ_LOGS_URL
+}) => {
+  console.log("SIGNOZ_ACCESS_TOKEN", SIGNOZ_ACCESS_TOKEN);
+  console.log("SIGNOZ_TRACES_URL", SIGNOZ_TRACES_URL);
+  console.log("SIGNOZ_LOGS_URL", SIGNOZ_LOGS_URL);
+  const exporterOptions = {
+    url: SIGNOZ_TRACES_URL,
+    headers: {
+      "signoz-access-token": SIGNOZ_ACCESS_TOKEN
+    }
+  };
+  const traceExporter = new OTLPTraceExporter(exporterOptions);
+  const logExporter = new OTLPLogExporter({
+    url: SIGNOZ_LOGS_URL,
+    headers: {
+      "signoz-access-token": SIGNOZ_ACCESS_TOKEN
+    }
+  });
+  const sdk = new NodeSDK({
+    traceExporter,
+    logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+    instrumentations: [getNodeAutoInstrumentations()],
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: "Test-Exulu"
+    })
+  });
+  process2.on("SIGTERM", () => {
+    sdk.shutdown().then(() => console.log("Tracing terminated")).catch((error) => console.log("Error terminating tracing", error)).finally(() => process2.exit(0));
+  });
+  return sdk;
+};
+
 // types/enums/jobs.ts
 var JOB_STATUS_ENUM = {
   completed: "completed",
@@ -6719,6 +6775,19 @@ var ExuluJobs = {
     validate: validateJob
   }
 };
+var ExuluOtel = {
+  create: ({
+    SIGNOZ_ACCESS_TOKEN,
+    SIGNOZ_TRACES_URL,
+    SIGNOZ_LOGS_URL
+  }) => {
+    return create({
+      SIGNOZ_ACCESS_TOKEN,
+      SIGNOZ_TRACES_URL,
+      SIGNOZ_LOGS_URL
+    });
+  }
+};
 var db2 = {
   init: async () => {
     await execute();
@@ -6750,6 +6819,7 @@ export {
   ExuluEval,
   ExuluJobs,
   ExuluLogger,
+  ExuluOtel,
   queues as ExuluQueues,
   ExuluSource,
   ExuluTool,