@exulu/backend 1.52.0 → 1.53.1

package/dist/index.cjs

@@ -805,7 +805,7 @@ var JOB_STATUS_ENUM = {
 };
 
 // ee/agentic-retrieval/index.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var import_ai2 = require("ai");
 
 // src/uppy/index.ts
@@ -3229,7 +3229,7 @@ var mapType = (t, type, name, defaultValue, unique) => {
 
 // src/exulu/tool.ts
 var import_ai = require("ai");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var import_crypto_js2 = __toESM(require("crypto-js"), 1);
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
@@ -3445,6 +3445,102 @@ function sanitizeToolName(name) {
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
 var import_node_crypto2 = require("crypto");
+
+// src/templates/tools/memory-tool.ts
+var import_zod3 = require("zod");
+var import_fs = __toESM(require("fs"), 1);
+var createNewMemoryItemTool = (agent, context) => {
+  const fields = {
+    name: import_zod3.z.string().describe("The name of the item to create"),
+    description: import_zod3.z.string().describe("The description of the item to create")
+  };
+  for (const field of context.fields) {
+    switch (field.type) {
+      case "text":
+      case "longText":
+      case "shortText":
+      case "code":
+      case "enum":
+        fields[field.name] = import_zod3.z.string().describe("The " + field.name + " of the item to create");
+        break;
+      case "json":
+        fields[field.name] = import_zod3.z.string({}).describe(
+          "The " + field.name + " of the item to create, it should be a valid JSON string."
+        );
+        break;
+      case "markdown":
+        fields[field.name] = import_zod3.z.string().describe(
+          "The " + field.name + " of the item to create, it should be a valid Markdown string."
+        );
+        break;
+      case "number":
+        fields[field.name] = import_zod3.z.number().describe("The " + field.name + " of the item to create");
+        break;
+      case "boolean":
+        fields[field.name] = import_zod3.z.boolean().describe("The " + field.name + " of the item to create");
+        break;
+      case "file":
+      case "uuid":
+      case "date":
+        break;
+      default:
+        fields[field.name] = import_zod3.z.string().describe("The " + field.name + " of the item to create");
+        break;
+    }
+  }
+  const toolName = "create_" + sanitizeName(context.name) + "_memory_item";
+  return new ExuluTool({
+    id: toolName,
+    name: "Create " + context.name + " Memory Item",
+    category: agent.name + "_memory",
+    description: "Create a new memory item in the " + agent.name + " memory context",
+    type: "function",
+    inputSchema: import_zod3.z.object(fields),
+    config: [],
+    execute: async ({ name, description, mode, information, exuluConfig, user }) => {
+      let result = { result: "" };
+      import_fs.default.writeFileSync("memory-tool.json", JSON.stringify({ name, description, information }, null, 2));
+      try {
+        const newItem = {
+          name,
+          description,
+          information,
+          rights_mode: "public"
+        };
+        const { item: createdItem, job: createdJob } = await context.createItem(
+          newItem,
+          exuluConfig,
+          user?.id,
+          user?.role?.id,
+          false
+        );
+        import_fs.default.writeFileSync("memory-tool-created.json", JSON.stringify({ createdItem, createdJob }, null, 2));
+        if (createdJob) {
+          result = {
+            result: `Created a Job to create the memory item with the following ID: ${createdJob}`
+          };
+        } else if (createdItem) {
+          result = {
+            result: `Created memory item with the following ID: ${createdItem.id}`
+          };
+        } else {
+          result = {
+            result: `Failed to create memory item`
+          };
+        }
+      } catch (error) {
+        import_fs.default.writeFileSync("memory-tool-error.json", JSON.stringify({ name, description, information, error }, null, 2));
+        console.error("[EXULU] Error creating memory item", error);
+        result = {
+          result: `Failed to create memory item: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      return result;
+    }
+  });
+};
+
+// src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
 var generateS3Key = (filename) => `${(0, import_node_crypto2.randomUUID)()}-${filename}`;
 var s3Client2;
 var getMimeType = (type) => {
@@ -3548,6 +3644,21 @@ var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExulu
       currentTools.push(projectRetrievalTool);
     }
   }
+  if (agent?.memory && contexts?.length) {
+    const context = contexts.find((context2) => context2.id === agent?.memory);
+    if (!context) {
+      throw new Error(
+        "Context was set for agent memory but not found in the contexts: " + agent?.memory + " please double check with a developer to see if the context was removed from code."
+      );
+    }
+    const createNewMemoryTool = createNewMemoryItemTool(agent, context);
+    if (createNewMemoryTool) {
+      if (!currentTools) {
+        currentTools = [];
+      }
+      currentTools.push(createNewMemoryTool);
+    }
+  }
   console.log("[EXULU] Convert tools array to object, session items", items);
   if (items) {
     const sessionItemsRetrievalTool = await createSessionItemsRetrievalTool({
@@ -3793,7 +3904,7 @@ var ExuluTool = class {
     this.type = type;
     this.tool = (0, import_ai.tool)({
       description,
-      inputSchema: inputSchema || import_zod3.z.object({}),
+      inputSchema: inputSchema || import_zod4.z.object({}),
       execute: execute2
     });
   }
@@ -3886,7 +3997,7 @@ var ExuluTool = class {
 };
 
 // src/exulu/context.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // ee/queues/decorator.ts
 var import_bullmq2 = require("bullmq");
@@ -4044,6 +4155,7 @@ var ExuluContext2 = class {
         exuluConfig
       });
       if (!result) {
+        console.log("[EXULU] Item filtered out by processor, skipping processing execution...");
         return {
           result: void 0,
           job: void 0
@@ -4244,10 +4356,12 @@ var ExuluContext2 = class {
         }
       }
     });
+    console.log("[EXULU] Creating item", item);
     const mutation = db2.from(getTableName(this.id)).insert({
       ...item,
       tags: item.tags ? Array.isArray(item.tags) ? item.tags.join(",") : item.tags : void 0
     }).returning("id");
+    console.log("[EXULU] Upsert", upsert);
     if (upsert) {
       if (item.external_id) {
         mutation.onConflict("external_id").merge();
@@ -4266,7 +4380,6 @@ var ExuluContext2 = class {
     let shouldGenerateEmbeddings = this.embedder && generateEmbeddingsOverwrite !== false && (generateEmbeddingsOverwrite || this.configuration.calculateVectors === "onInsert" || this.configuration.calculateVectors === "always");
     if (this.processor) {
       const processor = this.processor;
-      console.log("[EXULU] Processor found", processor);
       if (processor && (processor?.config?.trigger === "onInsert" || processor?.config?.trigger === "onUpdate" || processor?.config?.trigger === "always")) {
         const { job: processorJob, result: processorResult } = await this.processField(
           "api",
@@ -4281,7 +4394,7 @@ var ExuluContext2 = class {
         if (processorJob) {
           jobs.push(processorJob);
         }
-        if (!processorJob) {
+        if (!processorJob && processorResult) {
           await db2.from(getTableName(this.id)).where({ id: results[0].id }).update({
             ...processorResult
           });
@@ -4352,7 +4465,7 @@ var ExuluContext2 = class {
         if (processorJob) {
           jobs.push(processorJob);
         }
-        if (!processorJob) {
+        if (!processorJob && processorResult) {
           await db2.from(getTableName(this.id)).where({ id: record.id }).update({
             ...processorResult
           });
@@ -4606,12 +4719,12 @@ var ExuluContext2 = class {
       category: "contexts",
       needsApproval: true,
       // todo make configurable
-      inputSchema: import_zod4.z.object({
-        query: import_zod4.z.string().describe("The original question that the user asked"),
-        keywords: import_zod4.z.array(import_zod4.z.string()).describe(
+      inputSchema: import_zod5.z.object({
+        query: import_zod5.z.string().describe("The original question that the user asked"),
+        keywords: import_zod5.z.array(import_zod5.z.string()).describe(
           "The keywords that are relevant to the user's question, for example names of specific products, systems or parts, IDs, etc."
         ),
-        method: import_zod4.z.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
+        method: import_zod5.z.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
           "Search method: 'hybrid' (best for most queries - combines semantic understanding with exact term matching), 'keyword' (best for exact terms, technical names, IDs, or specific phrases), 'semantic' (best for conceptual queries where synonyms and paraphrasing matter)"
         )
       }),
@@ -4822,11 +4935,11 @@ function createCustomAgenticRetrievalToolLoopAgent({
             return await (0, import_ai2.generateText)({
               model,
               output: import_ai2.Output.object({
-                schema: import_zod5.z.object({
-                  reasoning: import_zod5.z.string().describe(
+                schema: import_zod6.z.object({
+                  reasoning: import_zod6.z.string().describe(
                     "The reasoning for the next step and why the agent needs to take this step. It MUST start with 'I must call tool XYZ', and MUST include the inputs for that tool."
                   ),
-                  finished: import_zod5.z.boolean().describe(
+                  finished: import_zod6.z.boolean().describe(
                     "Whether the agent has finished meaning no further steps are needed, this should only be true if the agent believes no further tool calls are needed to get the relevant information for the query."
                   )
                 })
@@ -4956,9 +5069,9 @@ function createCustomAgenticRetrievalToolLoopAgent({
             if (chunksCount > 1) {
               dynamicTools[getMoreToolName] = (0, import_ai2.tool)({
                 description: `The item ${chunk.item_name} has a total of${chunksCount} chunks, this tool allows you to get more content from this item across all its pages / chunks.`,
-                inputSchema: import_zod5.z.object({
-                  from_index: import_zod5.z.number().default(1).describe("The index of the chunk to start from."),
-                  to_index: import_zod5.z.number().max(chunksCount).describe("The index of the chunk to end at, max is " + chunksCount)
+                inputSchema: import_zod6.z.object({
+                  from_index: import_zod6.z.number().default(1).describe("The index of the chunk to start from."),
+                  to_index: import_zod6.z.number().max(chunksCount).describe("The index of the chunk to end at, max is " + chunksCount)
                 }),
                 execute: async ({ from_index, to_index }) => {
                   const chunks2 = await db2(chunksTable).select("*").where("source", chunk.item_id).whereBetween("chunk_index", [from_index, to_index]).orderBy("chunk_index", "asc");
@@ -4986,8 +5099,8 @@ function createCustomAgenticRetrievalToolLoopAgent({
             );
             dynamicTools[getContentToolName] = (0, import_ai2.tool)({
               description: `Get the content of the page ${chunk.chunk_index} for the item ${chunk.item_name}`,
-              inputSchema: import_zod5.z.object({
-                reasoning: import_zod5.z.string().describe("The reasoning for why you need to get the content of the page.")
+              inputSchema: import_zod6.z.object({
+                reasoning: import_zod6.z.string().describe("The reasoning for why you need to get the content of the page.")
               }),
               execute: async ({ reasoning }) => {
                 const { db: db3 } = await postgresClient();
@@ -5055,8 +5168,8 @@ var createAgenticRetrievalAgent = ({
     search_items_by_name: (0, import_ai2.tool)({
       description: `
         Search for relevant items by name across the available knowledge bases.`,
-      inputSchema: import_zod5.z.object({
-        knowledge_base_ids: import_zod5.z.array(import_zod5.z.enum(contexts.map((ctx) => ctx.id))).describe(`
+      inputSchema: import_zod6.z.object({
+        knowledge_base_ids: import_zod6.z.array(import_zod6.z.enum(contexts.map((ctx) => ctx.id))).describe(`
                     The available knowledge bases are:
                     ${contexts.map(
           (ctx) => `
@@ -5068,8 +5181,8 @@ var createAgenticRetrievalAgent = ({
                     `
         ).join("\n")}
                 `),
-        item_name: import_zod5.z.string().describe("The name of the item to search for."),
-        limit: import_zod5.z.number().default(100).describe(
+        item_name: import_zod6.z.string().describe("The name of the item to search for."),
+        limit: import_zod6.z.number().default(100).describe(
           "Maximum number of items to return (max 400), if searching through multiple knowledge bases, the limit is applied for each knowledge base individually."
         )
       }),
@@ -5175,11 +5288,11 @@ var createAgenticRetrievalAgent = ({
             - You can always fetch content later if needed
             
             `,
-      inputSchema: import_zod5.z.object({
-        query: import_zod5.z.string().describe(
+      inputSchema: import_zod6.z.object({
+        query: import_zod6.z.string().describe(
           "The search query to find relevant chunks, this must always be related to the content you are looking for, not something like 'Page 2'."
         ),
-        knowledge_base_ids: import_zod5.z.array(import_zod5.z.enum(contexts.map((ctx) => ctx.id))).describe(`
+        knowledge_base_ids: import_zod6.z.array(import_zod6.z.enum(contexts.map((ctx) => ctx.id))).describe(`
                     The available knowledge bases are:
                     ${contexts.map(
           (ctx) => `
@@ -5191,25 +5304,25 @@ var createAgenticRetrievalAgent = ({
                     `
         ).join("\n")}
                 `),
-        keywords: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+        keywords: import_zod6.z.array(import_zod6.z.string()).optional().describe(
           "Keywords to search for. Usually extracted from the query, allowing for more precise search results."
         ),
-        searchMethod: import_zod5.z.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
+        searchMethod: import_zod6.z.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
           "Search method: 'hybrid' (best for most queries - combines semantic understanding with exact term matching), 'keyword' (best for exact terms, technical names, IDs, or specific phrases), 'semantic' (best for conceptual queries where synonyms and paraphrasing matter)"
         ),
-        includeContent: import_zod5.z.boolean().default(true).describe(
+        includeContent: import_zod6.z.boolean().default(true).describe(
           "Whether to include the full chunk content in results. Set to FALSE when you only need to know WHICH documents/items are relevant (lists, overviews, counts). Set to TRUE when you need the ACTUAL content to answer the question (information, details, explanations). You can always fetch content later, so prefer FALSE for efficiency when listing documents."
         ),
-        item_ids: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+        item_ids: import_zod6.z.array(import_zod6.z.string()).optional().describe(
           "Use if you wish to retrieve content from specific items (documents) based on the item ID."
         ),
-        item_names: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+        item_names: import_zod6.z.array(import_zod6.z.string()).optional().describe(
           "Use if you wish to retrieve content from specific items (documents) based on the item name. Can be a partial match."
         ),
-        item_external_ids: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+        item_external_ids: import_zod6.z.array(import_zod6.z.string()).optional().describe(
           "Use if you wish to retrieve content from specific items (documents) based on the item external ID. Can be a partial match."
         ),
-        limit: import_zod5.z.number().default(10).describe("Maximum number of chunks to return (max 10)")
+        limit: import_zod6.z.number().default(10).describe("Maximum number of chunks to return (max 10)")
       }),
       execute: async ({
         query,
@@ -5400,9 +5513,9 @@ var createAgenticRetrievalTool = ({
         default: true
       }))
     ],
-    inputSchema: import_zod5.z.object({
-      query: import_zod5.z.string().describe("The question or query to answer using the knowledge bases"),
-      userInstructions: import_zod5.z.string().optional().describe("Instructions provided by the user to customize the retrieval process.")
+    inputSchema: import_zod6.z.object({
+      query: import_zod6.z.string().describe("The question or query to answer using the knowledge bases"),
+      userInstructions: import_zod6.z.string().optional().describe("Instructions provided by the user to customize the retrieval process.")
     }),
     execute: async function* ({
       query,
@@ -7420,7 +7533,32 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
                 );
               }
               const exuluStorage = new ExuluStorage({ config });
-              console.log("[EXULU] POS 2 -- EXULU CONTEXT PROCESS FIELD");
+              if (context.processor.filter) {
+                const result2 = await context.processor.filter({
+                  item: data.inputs,
+                  user: data.user,
+                  role: data.role,
+                  utils: {
+                    storage: exuluStorage
+                  },
+                  exuluConfig: config
+                });
+                if (!result2) {
+                  console.log("[EXULU] Item filtered out by processor, skipping processing execution...");
+                  return {
+                    result: "Item filtered out by processor, skipping processing execution...",
+                    // last message
+                    metadata: {
+                      item: {
+                        name: data.inputs?.name,
+                        id: data.inputs?.id,
+                        external_id: data.inputs?.external_id
+                      }
+                    }
+                  };
+                }
+              }
+              console.log("[EXULU] POS 2 -- EXULU CONTEXT PROCESS FIELD", data.inputs);
               let processorResult = await context.processor.execute({
                 item: data.inputs,
                 user: data.user,
@@ -9870,7 +10008,7 @@ var import_utils5 = require("@apollo/utils.keyvaluecache");
 var import_body_parser = __toESM(require("body-parser"), 1);
 var import_crypto_js6 = __toESM(require("crypto-js"), 1);
 var import_openai = __toESM(require("openai"), 1);
-var import_fs = __toESM(require("fs"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var import_node_crypto4 = require("crypto");
 var import_api2 = require("@opentelemetry/api");
 var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
@@ -9919,98 +10057,6 @@ function generateSlug(name) {
 // src/exulu/provider.ts
 var import_crypto_js5 = __toESM(require("crypto-js"), 1);
 var import_officeparser = require("officeparser");
-
-// src/templates/tools/memory-tool.ts
-var import_zod6 = require("zod");
-var createNewMemoryItemTool = (agent, context) => {
-  const fields = {
-    name: import_zod6.z.string().describe("The name of the item to create"),
-    description: import_zod6.z.string().describe("The description of the item to create")
-  };
-  for (const field of context.fields) {
-    switch (field.type) {
-      case "text":
-      case "longText":
-      case "shortText":
-      case "code":
-      case "enum":
-        fields[field.name] = import_zod6.z.string().describe("The " + field.name + " of the item to create");
-        break;
-      case "json":
-        fields[field.name] = import_zod6.z.string({}).describe(
-          "The " + field.name + " of the item to create, it should be a valid JSON string."
-        );
-        break;
-      case "markdown":
-        fields[field.name] = import_zod6.z.string().describe(
-          "The " + field.name + " of the item to create, it should be a valid Markdown string."
-        );
-        break;
-      case "number":
-        fields[field.name] = import_zod6.z.number().describe("The " + field.name + " of the item to create");
-        break;
-      case "boolean":
-        fields[field.name] = import_zod6.z.boolean().describe("The " + field.name + " of the item to create");
-        break;
-      case "file":
-      case "uuid":
-      case "date":
-        break;
-      default:
-        fields[field.name] = import_zod6.z.string().describe("The " + field.name + " of the item to create");
-        break;
-    }
-  }
-  return new ExuluTool({
-    id: "create_" + agent.name + "_memory_item",
-    name: "Create " + agent.name + " Memory Item",
-    category: agent.name + "_memory",
-    description: "Create a new memory item in the " + agent.name + " memory context",
-    type: "function",
-    inputSchema: import_zod6.z.object(fields),
-    config: [],
-    execute: async ({ name, description, mode, information, exuluConfig, user }) => {
-      let result = { result: "" };
-      switch (mode) {
-        case "learnings":
-          break;
-        case "knowledge":
-          const newItem = {
-            name,
-            description,
-            information,
-            rights_mode: "public"
-          };
-          const { item: createdItem, job: createdJob } = await context.createItem(
-            newItem,
-            exuluConfig,
-            user?.id,
-            user?.role?.id,
-            false
-          );
-          if (createdJob) {
-            result = {
-              result: `Created a Job to create the memory item with the following ID: ${createdJob}`
-            };
-          } else if (createdItem) {
-            result = {
-              result: `Created memory item with the following ID: ${createdItem.id}`
-            };
-          } else {
-            result = {
-              result: `Failed to create memory item`
-            };
-          }
-          break;
-        default:
-          throw new Error(`Invalid mode: ${mode}`);
-      }
-      return result;
-    }
-  });
-};
-
-// src/exulu/provider.ts
 var ExuluProvider = class {
   // Must begin with a letter (a-z) or underscore (_). Subsequent characters in a name can be letters, digits (0-9), or
   // underscores and be a max length of 80 characters and at least 5 characters long.
@@ -10270,13 +10316,6 @@ var ExuluProvider = class {
   
                   ${result.chunks.map((chunk) => chunk.chunk_content).join("\n\n")}`;
       }
-      const createNewMemoryTool = createNewMemoryItemTool(agent, context);
-      if (createNewMemoryTool) {
-        if (!currentTools) {
-          currentTools = [];
-        }
-        currentTools.push(createNewMemoryTool);
-      }
     }
     const personalizationInformation = exuluConfig?.privacy?.systemPromptPersonalization !== false ? `
                   ${user?.firstname ? `The users first name is "${user.firstname}"` : ""}
@@ -10340,6 +10379,10 @@ var ExuluProvider = class {
               Example: {url: https://www.google.com, title: Google, snippet: The result of the web search.}
               `;
     }
+    system += `
+
+When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
+    'Inform the user that the action was not performed.`;
     if (prompt) {
       let result = { object: null, text: "" };
       let inputTokens = 0;
@@ -10654,13 +10697,6 @@ ${extractedText}
   
                   ${result2.chunks.map((chunk) => chunk.chunk_content).join("\n\n")}`;
       }
-      const createNewMemoryTool = createNewMemoryItemTool(agent, context);
-      if (createNewMemoryTool) {
-        if (!currentTools) {
-          currentTools = [];
-        }
-        currentTools.push(createNewMemoryTool);
-      }
     }
     messages = messages.filter(
       (message2, index, self) => index === self.findLastIndex((t) => t.id === message2.id)
@@ -10719,6 +10755,10 @@ ${extractedText}
               Example: {url: https://www.google.com, title: Google, snippet: The result of the web search.}
               `;
     }
+    system += `
+
+When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
+    'Inform the user that the action was not performed.`;
     const result = (0, import_ai4.streamText)({
       model,
       // Should be a LanguageModelV1
@@ -10863,12 +10903,11 @@ var providerRateLimiter = async (key, windowSeconds, limit, points) => {
 
 // src/exulu/routes.ts
 var import_zod_from_json_schema = require("zod-from-json-schema");
-var import_zod8 = require("zod");
 var REQUEST_SIZE_LIMIT = "50mb";
 var getExuluVersionNumber = async () => {
   try {
     const path2 = process.cwd();
-    const packageJson = import_fs.default.readFileSync(path2 + "/package.json", "utf8");
+    const packageJson = import_fs2.default.readFileSync(path2 + "/package.json", "utf8");
     const packageData = JSON.parse(packageJson);
     const exuluVersion = packageData.dependencies["@exulu/backend"];
     console.log(`[EXULU] Installed exulu-backend version: ${exuluVersion}`);
@@ -11778,7 +11817,7 @@ var import_types2 = require("@modelcontextprotocol/sdk/types.js");
 var import_express4 = require("express");
 var import_api3 = require("@opentelemetry/api");
 var import_crypto_js7 = __toESM(require("crypto-js"), 1);
-var import_zod9 = require("zod");
+var import_zod8 = require("zod");
 var SESSION_ID_HEADER = "mcp-session-id";
 var ExuluMCP = class {
   server = {};
@@ -11861,7 +11900,7 @@ var ExuluMCP = class {
           title: tool3.name + " agent",
           description: tool3.description,
           inputSchema: {
-            inputs: tool3.inputSchema || import_zod9.z.object({})
+            inputs: tool3.inputSchema || import_zod8.z.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -11913,7 +11952,7 @@ var ExuluMCP = class {
           title: "Get List of Prompt Templates",
           description: "Retrieves a list of prompt templates available for this agent. Returns the name, description, and ID of each template.",
           inputSchema: {
-            inputs: import_zod9.z.object({})
+            inputs: import_zod8.z.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -11959,8 +11998,8 @@ var ExuluMCP = class {
           title: "Get Prompt Template Details",
           description: "Retrieves the full details of a specific prompt template by ID, including the actual template content with variables.",
           inputSchema: {
-            inputs: import_zod9.z.object({
-              id: import_zod9.z.string().describe("The ID of the prompt template to retrieve")
+            inputs: import_zod8.z.object({
+              id: import_zod8.z.string().describe("The ID of the prompt template to retrieve")
             })
           }
         },
@@ -12868,7 +12907,7 @@ var ExuluEval = class {
 };
 
 // src/templates/evals/index.ts
-var import_zod10 = require("zod");
+var import_zod9 = require("zod");
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
     return new ExuluEval({
@@ -12913,8 +12952,8 @@ var llmAsJudgeEval = () => {
           contexts: [],
           rerankers: [],
           prompt,
-          outputSchema: import_zod10.z.object({
-            score: import_zod10.z.number().min(0).max(100).describe("The score between 0 and 100.")
+          outputSchema: import_zod9.z.object({
+            score: import_zod9.z.number().min(0).max(100).describe("The score between 0 and 100.")
           }),
           providerapikey
         });
@@ -13142,12 +13181,12 @@ Usage:
 - If no todos exist yet, an empty list will be returned`;
 
 // src/templates/tools/todo/todo.ts
-var import_zod11 = __toESM(require("zod"), 1);
-var TodoSchema = import_zod11.default.object({
-  content: import_zod11.default.string().describe("Brief description of the task"),
-  status: import_zod11.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  priority: import_zod11.default.string().describe("Priority level of the task: high, medium, low"),
-  id: import_zod11.default.string().describe("Unique identifier for the todo item")
+var import_zod10 = __toESM(require("zod"), 1);
+var TodoSchema = import_zod10.default.object({
+  content: import_zod10.default.string().describe("Brief description of the task"),
+  status: import_zod10.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+  priority: import_zod10.default.string().describe("Priority level of the task: high, medium, low"),
+  id: import_zod10.default.string().describe("Unique identifier for the todo item")
 });
 var TodoWriteTool = new ExuluTool({
   id: "todo_write",
@@ -13163,8 +13202,8 @@ var TodoWriteTool = new ExuluTool({
       default: todowrite_default
     }
   ],
-  inputSchema: import_zod11.default.object({
-    todos: import_zod11.default.array(TodoSchema).describe("The updated todo list")
+  inputSchema: import_zod10.default.object({
+    todos: import_zod10.default.array(TodoSchema).describe("The updated todo list")
   }),
   execute: async (inputs) => {
     const { sessionID, todos, user } = inputs;
@@ -13199,7 +13238,7 @@ var TodoReadTool = new ExuluTool({
   id: "todo_read",
   name: "Todo Read",
   description: "Use this tool to read your todo list",
-  inputSchema: import_zod11.default.object({}),
+  inputSchema: import_zod10.default.object({}),
   type: "function",
   category: "todo",
   config: [
@@ -13237,6 +13276,222 @@ async function getTodos(sessionID) {
 }
 var todoTools = [TodoWriteTool, TodoReadTool];
 
+// src/templates/tools/question/questionask.txt
+var questionask_default = `Use this tool to ask the user a question with multiple choice answer options during your session. This helps you gather user input, clarify requirements, and make informed decisions based on user preferences.
+
+## When to Use This Tool
+
+Use this tool when you need to:
+
+1. Get user input on implementation choices - When there are multiple valid approaches and you need the user to decide
+2. Clarify ambiguous requirements - When the user's request could be interpreted in different ways
+3. Gather preferences - When you need to know the user's preference for styling, naming, architecture, etc.
+4. Validate assumptions - When you want to confirm your understanding before proceeding
+5. Offer options - When presenting multiple solutions and letting the user choose
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. The answer is clear from context or previous messages
+2. You're asking a yes/no question (use a simpler approach)
+3. The question requires a free-form text answer (this tool is for multiple choice only)
+4. You're asking for information that should be obvious from the codebase
+
+## How It Works
+
+- Provide a question and an array of answer option strings
+- The tool automatically adds "None of the above..." as a final option
+- Each answer option is assigned a unique ID
+- The question is stored with a "pending" status until the user answers
+- Use the Question Read tool to check if the question has been answered
+
+## Examples
+
+<example>
+User: Add authentication to my app
+Assistant: I need to ask the user which authentication method they prefer.
+*Uses Question Ask tool with:*
+question: "Which authentication method would you like to implement?"
+answerOptions: ["JWT tokens", "OAuth 2.0", "Session-based auth", "Firebase Auth"]
+
+<reasoning>
+The assistant used the question tool because there are multiple valid authentication approaches and the user's preference will significantly impact the implementation.
+</reasoning>
+</example>
+
+<example>
+User: Style this button
+Assistant: I need to know the user's styling preference.
+*Uses Question Ask tool with:*
+question: "What styling approach should I use for the button?"
+answerOptions: ["Tailwind CSS", "CSS Modules", "Styled Components", "Plain CSS"]
+
+<reasoning>
+The assistant used the question tool because the codebase could support multiple styling approaches and the user's preference matters for consistency.
+</reasoning>
+</example>
+
+<example>
+User: Add error handling
+Assistant: I'll implement comprehensive error handling with try-catch blocks and proper error messages.
+*Does not use the question tool*
+
+<reasoning>
+The assistant did not use the question tool because error handling is a standard practice and there's a clear best approach that doesn't require user input.
+</reasoning>
+</example>
+
+## Answer Format
+
+When you call this tool, answer options are automatically converted to this format:
+\`\`\`json
+[
+  { "id": "randomId1", "text": "First option" },
+  { "id": "randomId2", "text": "Second option" },
+  { "id": "randomId3", "text": "Third option" },
+  { "id": "randomId4", "text": "None of the above..." }
+]
+\`\`\`
+
+The "None of the above..." option is always added automatically, so you don't need to include it in your answerOptions array.
+
+## Reading Answers
+
+After asking a question, use the Question Read tool to check if the user has answered. The question status will change from "pending" to "answered" and the selectedAnswerId field will contain the ID of the chosen answer.
+`;
+
+// src/templates/tools/question/questionread.txt
+var questionread_default = 'Use this tool to read questions you\'ve asked and check if they\'ve been answered by the user. This tool helps you track the status of questions and retrieve the user\'s selected answers.\n\n## When to Use This Tool\n\nUse this tool proactively in these situations:\n- After asking a question to check if the user has responded\n- To retrieve the user\'s answer before proceeding with implementation\n- To review all questions and answers in the current session\n- When you need to reference a previous answer\n\n## How It Works\n\n- This tool takes no parameters (leave the input blank or empty)\n- Returns an array of all questions in the session\n- Each question includes:\n  - `id`: Unique identifier for the question\n  - `question`: The question text\n  - `answerOptions`: Array of answer options with their IDs and text\n  - `status`: Either "pending" (not answered) or "answered"\n  - `selectedAnswerId`: The ID of the chosen answer (only present if answered)\n\n## Usage Pattern\n\nTypically you\'ll:\n1. Use Question Ask to pose a question\n2. Wait for the user to respond\n3. Use Question Read to check the answer\n4. Find the selected answer by matching the `selectedAnswerId` with an option in `answerOptions`\n5. Proceed with implementation based on the user\'s choice\n\n## Example Response\n\n```json\n[\n  {\n    "id": "question123",\n    "question": "Which authentication method would you like to implement?",\n    "answerOptions": [\n      { "id": "ans1", "text": "JWT tokens" },\n      { "id": "ans2", "text": "OAuth 2.0" },\n      { "id": "ans3", "text": "Session-based auth" },\n      { "id": "ans4", "text": "None of the above..." }\n    ],\n    "status": "answered",\n    "selectedAnswerId": "ans1"\n  }\n]\n```\n\nIn this example, the user selected "JWT tokens" (id: ans1).\n\n## Important Notes\n\n- If no questions exist in the session, an empty array will be returned\n- Questions remain in the session even after being answered for reference\n- Use the `selectedAnswerId` to find which answer option the user chose by matching it against the `id` field in `answerOptions`\n';
+
+// src/templates/tools/question/question.ts
+var import_zod11 = __toESM(require("zod"), 1);
+var import_node_crypto6 = require("crypto");
+var AnswerOptionSchema = import_zod11.default.object({
+  id: import_zod11.default.string().describe("Unique identifier for the answer option"),
+  text: import_zod11.default.string().describe("The text of the answer option")
+});
+var _QuestionSchema = import_zod11.default.object({
+  id: import_zod11.default.string().describe("Unique identifier for the question"),
+  question: import_zod11.default.string().describe("The question to ask the user"),
+  answerOptions: import_zod11.default.array(AnswerOptionSchema).describe("Array of possible answer options"),
+  selectedAnswerId: import_zod11.default.string().optional().describe("The ID of the answer option selected by the user"),
+  status: import_zod11.default.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
+});
+var QuestionAskTool = new ExuluTool({
+  id: "question_ask",
+  name: "Question Ask",
+  description: "Use this tool to ask a question to the user with multiple choice answers",
+  type: "function",
+  category: "question",
+  config: [
+    {
+      name: "description",
+      description: "The description of the question tool, if set overwrites the default description.",
+      type: "string",
+      default: questionask_default
+    }
+  ],
+  inputSchema: import_zod11.default.object({
+    question: import_zod11.default.string().describe("The question to ask the user"),
+    answerOptions: import_zod11.default.array(import_zod11.default.string()).describe("Array of possible answer options (strings)")
+  }),
+  execute: async (inputs) => {
+    const { sessionID, question, answerOptions, user } = inputs;
+    if (!user) {
+      throw new Error(
+        "No authenticated user available, a user is required for the question ask tool, this likely means the tool was called outside a session like in an MCP or API call instead of as part of an authenticated session."
+      );
+    }
+    if (!sessionID) {
+      throw new Error(
+        "Session ID is required for the question ask tool, this likely means the tool was called outside a session like in an MCP or API call instead of as part of a conversation."
+      );
+    }
+    const session = await getSession({ sessionID });
+    if (!session?.id) {
+      throw new Error(
+        "Session with ID " + sessionID + " not found in the question ask tool."
+      );
+    }
+    const hasAccessToSession = await checkRecordAccess(session, "read", user);
+    if (!hasAccessToSession) {
+      throw new Error("You don't have access to this session " + session.id + ".");
+    }
+    const answerOptionsWithIds = answerOptions.map((text) => ({
+      id: (0, import_node_crypto6.randomUUID)(),
+      text
+    }));
+    answerOptionsWithIds.push({
+      id: (0, import_node_crypto6.randomUUID)(),
+      text: "None of the above..."
+    });
+    const newQuestion = {
+      id: (0, import_node_crypto6.randomUUID)(),
+      question,
+      answerOptions: answerOptionsWithIds,
+      status: "pending"
+    };
+    await addQuestion({
+      session,
+      question: newQuestion
+    });
+    return {
+      result: JSON.stringify(
+        {
+          questionId: newQuestion.id,
+          question: newQuestion.question,
+          answerOptions: newQuestion.answerOptions,
+          status: newQuestion.status
+        },
+        null,
+        2
+      )
+    };
+  }
+});
+var QuestionReadTool = new ExuluTool({
+  id: "question_read",
+  name: "Question Read",
+  description: "Use this tool to read questions and their answers",
+  inputSchema: import_zod11.default.object({}),
+  type: "function",
+  category: "question",
+  config: [
+    {
+      name: "description",
+      description: "The description of the question read tool, if set overwrites the default description.",
+      type: "string",
+      default: questionread_default
+    }
+  ],
+  execute: async (inputs) => {
+    const { sessionID } = inputs;
+    const questions = await getQuestions(sessionID);
+    return {
+      result: JSON.stringify(questions, null, 2)
+    };
+  }
+});
+async function addQuestion(input) {
+  const metadata = input.session.metadata ?? {};
+  metadata["questions"] ??= [];
+  metadata["questions"].push(input.question);
+  const { db: db2 } = await postgresClient();
+  await db2.from("agent_sessions").where({ id: input.session.id }).update({
+    metadata
+  });
+  return input.session;
+}
+async function getQuestions(sessionID) {
+  const { db: db2 } = await postgresClient();
+  const session = await db2.from("agent_sessions").where({ id: sessionID }).first();
+  if (!session) {
+    throw new Error("Session not found for session ID: " + sessionID);
+  }
+  return session.metadata?.questions ?? [];
+}
+var questionTools = [QuestionAskTool, QuestionReadTool];
+
 // src/templates/tools/perplexity.ts
 var import_zod12 = __toESM(require("zod"), 1);
 var import_perplexity_ai = __toESM(require("@perplexity-ai/perplexity_ai"), 1);
@@ -13347,14 +13602,29 @@ var isValidPostgresName = (id) => {
 
 // src/exulu/app/index.ts
 var isDev = process.env.NODE_ENV !== "production";
+var lineLimitFormat = import_winston2.default.format((info) => {
+  if (typeof info.message === "string") {
+    const lines = info.message.split("\n");
+    if (lines.length > 50) {
+      const truncatedLines = lines.slice(0, 50);
+      truncatedLines.push(`... (${lines.length - 50} more lines omitted)`);
+      info.message = truncatedLines.join("\n");
+    }
+  }
+  return info;
+});
 var consoleTransport = new import_winston2.default.transports.Console({
   format: isDev ? import_winston2.default.format.combine(
+    lineLimitFormat(),
     import_winston2.default.format.colorize(),
     import_winston2.default.format.timestamp({ format: "HH:mm:ss" }),
     import_winston2.default.format.printf(({ timestamp, level, message }) => {
       return `${timestamp} [${level}] ${message}`;
     })
-  ) : import_winston2.default.format.json()
+  ) : import_winston2.default.format.combine(
+    lineLimitFormat(),
+    import_winston2.default.format.json()
+  )
 });
 var formatArg = (arg) => typeof arg === "object" ? import_util.default.inspect(arg, { depth: null, colors: isDev }) : String(arg);
 var createLogMethod = (logger, logLevel) => {
@@ -13424,6 +13694,7 @@ var ExuluApp2 = class {
     this._tools = [
       ...tools ?? [],
       ...todoTools,
+      ...questionTools,
       ...perplexityTools,
       // Add contexts as tools
       ...Object.values(contexts || {}).map((context) => context.tool()).filter(Boolean)
@@ -16003,7 +16274,7 @@ var MarkdownChunker = class {
 var import_child_process = require("child_process");
 var import_util2 = require("util");
 var import_path = require("path");
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var import_url = require("url");
 var execAsync = (0, import_util2.promisify)(import_child_process.exec);
 function getPackageRoot() {
@@ -16013,9 +16284,9 @@ function getPackageRoot() {
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     const packageJsonPath = (0, import_path.join)(currentDir, "package.json");
-    if ((0, import_fs2.existsSync)(packageJsonPath)) {
+    if ((0, import_fs3.existsSync)(packageJsonPath)) {
       try {
-        const packageJson = JSON.parse((0, import_fs2.readFileSync)(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse((0, import_fs3.readFileSync)(packageJsonPath, "utf-8"));
         if (packageJson.name === "@exulu/backend") {
           return currentDir;
         }
@@ -16042,7 +16313,7 @@ function isPythonEnvironmentSetup(packageRoot) {
   const root = packageRoot ?? getPackageRoot();
   const venvPath = getVenvPath(root);
   const pythonPath = (0, import_path.join)(venvPath, "bin", "python");
-  return (0, import_fs2.existsSync)(venvPath) && (0, import_fs2.existsSync)(pythonPath);
+  return (0, import_fs3.existsSync)(venvPath) && (0, import_fs3.existsSync)(pythonPath);
 }
 async function setupPythonEnvironment(options = {}) {
   const {
@@ -16063,7 +16334,7 @@ async function setupPythonEnvironment(options = {}) {
     };
   }
   const setupScriptPath = getSetupScriptPath(packageRoot);
-  if (!(0, import_fs2.existsSync)(setupScriptPath)) {
+  if (!(0, import_fs3.existsSync)(setupScriptPath)) {
     return {
       success: false,
       message: `Setup script not found at: ${setupScriptPath}`,
@@ -16145,13 +16416,13 @@ async function validatePythonEnvironment(packageRoot, checkPackages = true) {
   const root = packageRoot ?? getPackageRoot();
   const venvPath = getVenvPath(root);
   const pythonPath = (0, import_path.join)(venvPath, "bin", "python");
-  if (!(0, import_fs2.existsSync)(venvPath)) {
+  if (!(0, import_fs3.existsSync)(venvPath)) {
     return {
       valid: false,
       message: getPythonSetupInstructions()
     };
   }
-  if (!(0, import_fs2.existsSync)(pythonPath)) {
+  if (!(0, import_fs3.existsSync)(pythonPath)) {
     return {
       valid: false,
       message: "Python virtual environment is corrupted. Please run:\n  await setupPythonEnvironment({ force: true })"
@@ -16203,7 +16474,7 @@ Or manually run the setup script:
 }
 
 // ee/python/documents/processing/doc_processor.ts
-var fs2 = __toESM(require("fs"), 1);
+var fs3 = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
 var import_ai7 = require("ai");
 var import_zod13 = require("zod");
@@ -16218,7 +16489,7 @@ var import_officeparser2 = require("officeparser");
 var import_child_process2 = require("child_process");
 var import_util3 = require("util");
 var import_path2 = require("path");
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var import_url2 = require("url");
 var execAsync2 = (0, import_util3.promisify)(import_child_process2.exec);
 function getPackageRoot2() {
@@ -16228,9 +16499,9 @@ function getPackageRoot2() {
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     const packageJsonPath = (0, import_path2.join)(currentDir, "package.json");
-    if ((0, import_fs3.existsSync)(packageJsonPath)) {
+    if ((0, import_fs4.existsSync)(packageJsonPath)) {
       try {
-        const packageJson = JSON.parse((0, import_fs3.readFileSync)(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse((0, import_fs4.readFileSync)(packageJsonPath, "utf-8"));
         if (packageJson.name === "@exulu/backend") {
           return currentDir;
         }
@@ -16292,7 +16563,7 @@ async function executePythonScript(config) {
     await validatePythonEnvironmentForExecution(packageRoot);
   }
   const resolvedScriptPath = (0, import_path2.resolve)(packageRoot, scriptPath);
-  if (!(0, import_fs3.existsSync)(resolvedScriptPath)) {
+  if (!(0, import_fs4.existsSync)(resolvedScriptPath)) {
     throw new PythonExecutionError(
       `Python script not found: ${resolvedScriptPath}`,
       "",
@@ -16428,7 +16699,7 @@ function reconstructHeadings(correctedText, headingsHierarchy) {
   return result;
 }
 async function validatePageWithVLM(page, imagePath, model) {
-  const imageBuffer = await fs2.promises.readFile(imagePath);
+  const imageBuffer = await fs3.promises.readFile(imagePath);
   const imageBase64 = imageBuffer.toString("base64");
   const mimeType = "image/png";
   const prompt = `You are a document validation assistant. Your task is to analyze a page image and correct the output of an OCR/parsing pipeline. The content may include tables, technical diagrams, schematics, and structured text.
@@ -16760,7 +17031,7 @@ ${setupResult.output || ""}`);
       if (!result.success) {
         throw new Error(`Document processing failed: ${result.stderr}`);
       }
-      const jsonContent = await fs2.promises.readFile(paths.json, "utf-8");
+      const jsonContent = await fs3.promises.readFile(paths.json, "utf-8");
       json = JSON.parse(jsonContent);
     } else if (config?.processor.name === "officeparser") {
       const text = await (0, import_officeparser2.parseOfficeAsync)(buffer, {
@@ -16793,9 +17064,9 @@ ${setupResult.output || ""}`);
       }, 10);
       const parser = new import_liteparse.LiteParse();
       const screenshots = await parser.screenshot(paths.source, void 0);
-      await fs2.promises.mkdir(paths.images, { recursive: true });
+      await fs3.promises.mkdir(paths.images, { recursive: true });
       for (const screenshot of screenshots) {
-        await fs2.promises.writeFile(
+        await fs3.promises.writeFile(
           path.join(
             paths.images,
             `${screenshot.pageNum}.png`
@@ -16810,15 +17081,15 @@ ${setupResult.output || ""}`);
         image: screenshots.find((s) => s.pageNum === page.index + 1)?.imagePath,
         headings: []
       }));
-      fs2.writeFileSync(paths.json, JSON.stringify(json, null, 2));
+      fs3.writeFileSync(paths.json, JSON.stringify(json, null, 2));
     } else if (config?.processor.name === "liteparse") {
       const parser = new import_liteparse.LiteParse();
       const result = await parser.parse(paths.source);
       const screenshots = await parser.screenshot(paths.source, void 0);
       console.log(`[EXULU] Liteparse screenshots: ${JSON.stringify(screenshots)}`);
-      await fs2.promises.mkdir(paths.images, { recursive: true });
+      await fs3.promises.mkdir(paths.images, { recursive: true });
       for (const screenshot of screenshots) {
-        await fs2.promises.writeFile(path.join(paths.images, `${screenshot.pageNum}.png`), screenshot.imageBuffer);
+        await fs3.promises.writeFile(path.join(paths.images, `${screenshot.pageNum}.png`), screenshot.imageBuffer);
         screenshot.imagePath = path.join(paths.images, `${screenshot.pageNum}.png`);
       }
       json = result.pages.map((page) => ({
@@ -16826,7 +17097,7 @@ ${setupResult.output || ""}`);
         content: page.text,
         image: screenshots.find((s) => s.pageNum === page.pageNum)?.imagePath
       }));
-      fs2.writeFileSync(paths.json, JSON.stringify(json, null, 2));
+      fs3.writeFileSync(paths.json, JSON.stringify(json, null, 2));
     }
     console.log(`[EXULU] 
 \u2713 Document processing completed successfully`);
@@ -16857,13 +17128,13 @@ ${setupResult.output || ""}`);
           console.log(`[EXULU]    Corrected: ${page.vlm_corrected_text.substring(0, 150)}...`);
         });
       }
-      await fs2.promises.writeFile(
+      await fs3.promises.writeFile(
         paths.json,
         JSON.stringify(json, null, 2),
         "utf-8"
       );
     }
-    const markdownStream = fs2.createWriteStream(paths.markdown, { encoding: "utf-8" });
+    const markdownStream = fs3.createWriteStream(paths.markdown, { encoding: "utf-8" });
     for (let i = 0; i < json.length; i++) {
       const p = json[i];
       if (!p) continue;
@@ -16879,7 +17150,7 @@ ${setupResult.output || ""}`);
     });
     console.log(`[EXULU] Validated output saved to: ${paths.json}`);
     console.log(`[EXULU] Validated markdown saved to: ${paths.markdown}`);
-    const markdown = await fs2.promises.readFile(paths.markdown, "utf-8");
+    const markdown = await fs3.promises.readFile(paths.markdown, "utf-8");
     const processedJson = json.map((e) => {
       const finalContent = e.vlm_corrected_text ?? e.content;
       return {
@@ -16910,7 +17181,7 @@ var loadFile = async (file, name, tempDir) => {
   let buffer;
   if (Buffer.isBuffer(file)) {
     filePath = path.join(tempDir, `${UUID}.${fileType}`);
-    await fs2.promises.writeFile(filePath, file);
+    await fs3.promises.writeFile(filePath, file);
     buffer = file;
   } else {
     filePath = filePath.trim();
@@ -16918,11 +17189,11 @@ var loadFile = async (file, name, tempDir) => {
       const response = await fetch(filePath);
       const array = await response.arrayBuffer();
       const tempFilePath = path.join(tempDir, `${UUID}.${fileType}`);
-      await fs2.promises.writeFile(tempFilePath, Buffer.from(array));
+      await fs3.promises.writeFile(tempFilePath, Buffer.from(array));
       buffer = Buffer.from(array);
       filePath = tempFilePath;
     } else {
-      buffer = await fs2.promises.readFile(file);
+      buffer = await fs3.promises.readFile(file);
     }
   }
   return { filePath, fileType, buffer };
@@ -16940,9 +17211,9 @@ async function documentProcessor({
   const tempDir = path.join(process.cwd(), "temp", uuid);
   const localFilesAndFoldersToDelete = [tempDir];
   console.log(`[EXULU] Temporary directory for processing document ${name}: ${tempDir}`);
-  await fs2.promises.mkdir(tempDir, { recursive: true });
+  await fs3.promises.mkdir(tempDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  await fs2.promises.writeFile(path.join(tempDir, "created_at.txt"), timestamp);
+  await fs3.promises.writeFile(path.join(tempDir, "created_at.txt"), timestamp);
   try {
     const {
       filePath,
@@ -16983,7 +17254,7 @@ async function documentProcessor({
     if (config?.debugging?.deleteTempFiles !== false) {
       for (const file2 of localFilesAndFoldersToDelete) {
         try {
-          await fs2.promises.rm(file2, { recursive: true });
+          await fs3.promises.rm(file2, { recursive: true });
           console.log(`[EXULU] Deleted file or folder: ${file2}`);
         } catch (error) {
           console.error(`[EXULU] Error deleting file or folder: ${file2}`, error);