@exulu/backend 1.52.0 → 1.53.1

package/dist/index.js

@@ -747,7 +747,7 @@ var JOB_STATUS_ENUM = {
 };
 
 // ee/agentic-retrieval/index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import {
   stepCountIs,
   tool as tool2,
@@ -3188,7 +3188,7 @@ var mapType = (t, type, name, defaultValue, unique) => {
 
 // src/exulu/tool.ts
 import { tool } from "ai";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 import CryptoJS2 from "crypto-js";
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
@@ -3404,6 +3404,102 @@ function sanitizeToolName(name) {
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/templates/tools/memory-tool.ts
+import { z as z3 } from "zod";
+import fs from "fs";
+var createNewMemoryItemTool = (agent, context) => {
+  const fields = {
+    name: z3.string().describe("The name of the item to create"),
+    description: z3.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] = z3.string().describe("The " + field.name + " of the item to create");
+        break;
+      case "json":
+        fields[field.name] = z3.string({}).describe(
+          "The " + field.name + " of the item to create, it should be a valid JSON string."
+        );
+        break;
+      case "markdown":
+        fields[field.name] = z3.string().describe(
+          "The " + field.name + " of the item to create, it should be a valid Markdown string."
+        );
+        break;
+      case "number":
+        fields[field.name] = z3.number().describe("The " + field.name + " of the item to create");
+        break;
+      case "boolean":
+        fields[field.name] = z3.boolean().describe("The " + field.name + " of the item to create");
+        break;
+      case "file":
+      case "uuid":
+      case "date":
+        break;
+      default:
+        fields[field.name] = z3.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: z3.object(fields),
+    config: [],
+    execute: async ({ name, description, mode, information, exuluConfig, user }) => {
+      let result = { result: "" };
+      fs.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
+        );
+        fs.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) {
+        fs.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) => `${randomUUID2()}-${filename}`;
 var s3Client2;
 var getMimeType = (type) => {
@@ -3507,6 +3603,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({
@@ -3752,7 +3863,7 @@ var ExuluTool = class {
     this.type = type;
     this.tool = tool({
       description,
-      inputSchema: inputSchema || z3.object({}),
+      inputSchema: inputSchema || z4.object({}),
       execute: execute2
     });
   }
@@ -3845,7 +3956,7 @@ var ExuluTool = class {
 };
 
 // src/exulu/context.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ee/queues/decorator.ts
 import "bullmq";
@@ -4003,6 +4114,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
@@ -4203,10 +4315,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();
@@ -4225,7 +4339,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",
@@ -4240,7 +4353,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
           });
@@ -4311,7 +4424,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
           });
@@ -4565,12 +4678,12 @@ var ExuluContext2 = class {
       category: "contexts",
       needsApproval: true,
       // todo make configurable
-      inputSchema: z4.object({
-        query: z4.string().describe("The original question that the user asked"),
-        keywords: z4.array(z4.string()).describe(
+      inputSchema: z5.object({
+        query: z5.string().describe("The original question that the user asked"),
+        keywords: z5.array(z5.string()).describe(
           "The keywords that are relevant to the user's question, for example names of specific products, systems or parts, IDs, etc."
         ),
-        method: z4.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
+        method: z5.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)"
         )
       }),
@@ -4781,11 +4894,11 @@ function createCustomAgenticRetrievalToolLoopAgent({
             return await generateText({
               model,
               output: Output.object({
-                schema: z5.object({
-                  reasoning: z5.string().describe(
+                schema: z6.object({
+                  reasoning: z6.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: z5.boolean().describe(
+                  finished: z6.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."
                   )
                 })
@@ -4915,9 +5028,9 @@ function createCustomAgenticRetrievalToolLoopAgent({
             if (chunksCount > 1) {
               dynamicTools[getMoreToolName] = tool2({
                 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: z5.object({
-                  from_index: z5.number().default(1).describe("The index of the chunk to start from."),
-                  to_index: z5.number().max(chunksCount).describe("The index of the chunk to end at, max is " + chunksCount)
+                inputSchema: z6.object({
+                  from_index: z6.number().default(1).describe("The index of the chunk to start from."),
+                  to_index: z6.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");
@@ -4945,8 +5058,8 @@ function createCustomAgenticRetrievalToolLoopAgent({
             );
             dynamicTools[getContentToolName] = tool2({
               description: `Get the content of the page ${chunk.chunk_index} for the item ${chunk.item_name}`,
-              inputSchema: z5.object({
-                reasoning: z5.string().describe("The reasoning for why you need to get the content of the page.")
+              inputSchema: z6.object({
+                reasoning: z6.string().describe("The reasoning for why you need to get the content of the page.")
               }),
               execute: async ({ reasoning }) => {
                 const { db: db3 } = await postgresClient();
@@ -5014,8 +5127,8 @@ var createAgenticRetrievalAgent = ({
     search_items_by_name: tool2({
       description: `
         Search for relevant items by name across the available knowledge bases.`,
-      inputSchema: z5.object({
-        knowledge_base_ids: z5.array(z5.enum(contexts.map((ctx) => ctx.id))).describe(`
+      inputSchema: z6.object({
+        knowledge_base_ids: z6.array(z6.enum(contexts.map((ctx) => ctx.id))).describe(`
                     The available knowledge bases are:
                     ${contexts.map(
           (ctx) => `
@@ -5027,8 +5140,8 @@ var createAgenticRetrievalAgent = ({
                     `
         ).join("\n")}
                 `),
-        item_name: z5.string().describe("The name of the item to search for."),
-        limit: z5.number().default(100).describe(
+        item_name: z6.string().describe("The name of the item to search for."),
+        limit: z6.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."
         )
       }),
@@ -5134,11 +5247,11 @@ var createAgenticRetrievalAgent = ({
             - You can always fetch content later if needed
             
             `,
-      inputSchema: z5.object({
-        query: z5.string().describe(
+      inputSchema: z6.object({
+        query: z6.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: z5.array(z5.enum(contexts.map((ctx) => ctx.id))).describe(`
+        knowledge_base_ids: z6.array(z6.enum(contexts.map((ctx) => ctx.id))).describe(`
                     The available knowledge bases are:
                     ${contexts.map(
           (ctx) => `
@@ -5150,25 +5263,25 @@ var createAgenticRetrievalAgent = ({
                     `
         ).join("\n")}
                 `),
-        keywords: z5.array(z5.string()).optional().describe(
+        keywords: z6.array(z6.string()).optional().describe(
           "Keywords to search for. Usually extracted from the query, allowing for more precise search results."
         ),
-        searchMethod: z5.enum(["keyword", "semantic", "hybrid"]).default("hybrid").describe(
+        searchMethod: z6.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: z5.boolean().default(true).describe(
+        includeContent: z6.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: z5.array(z5.string()).optional().describe(
+        item_ids: z6.array(z6.string()).optional().describe(
           "Use if you wish to retrieve content from specific items (documents) based on the item ID."
         ),
-        item_names: z5.array(z5.string()).optional().describe(
+        item_names: z6.array(z6.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: z5.array(z5.string()).optional().describe(
+        item_external_ids: z6.array(z6.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: z5.number().default(10).describe("Maximum number of chunks to return (max 10)")
+        limit: z6.number().default(10).describe("Maximum number of chunks to return (max 10)")
       }),
       execute: async ({
         query,
@@ -5359,9 +5472,9 @@ var createAgenticRetrievalTool = ({
         default: true
       }))
     ],
-    inputSchema: z5.object({
-      query: z5.string().describe("The question or query to answer using the knowledge bases"),
-      userInstructions: z5.string().optional().describe("Instructions provided by the user to customize the retrieval process.")
+    inputSchema: z6.object({
+      query: z6.string().describe("The question or query to answer using the knowledge bases"),
+      userInstructions: z6.string().optional().describe("Instructions provided by the user to customize the retrieval process.")
     }),
     execute: async function* ({
       query,
@@ -7379,7 +7492,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,
@@ -9829,7 +9967,7 @@ import { InMemoryLRUCache } from "@apollo/utils.keyvaluecache";
 import bodyParser from "body-parser";
 import CryptoJS6 from "crypto-js";
 import OpenAI from "openai";
-import fs from "fs";
+import fs2 from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 import "@opentelemetry/api";
 import Anthropic from "@anthropic-ai/sdk";
@@ -9885,98 +10023,6 @@ function generateSlug(name) {
 // src/exulu/provider.ts
 import CryptoJS5 from "crypto-js";
 import { parseOfficeAsync } from "officeparser";
-
-// src/templates/tools/memory-tool.ts
-import { z as z6 } from "zod";
-var createNewMemoryItemTool = (agent, context) => {
-  const fields = {
-    name: z6.string().describe("The name of the item to create"),
-    description: z6.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] = z6.string().describe("The " + field.name + " of the item to create");
-        break;
-      case "json":
-        fields[field.name] = z6.string({}).describe(
-          "The " + field.name + " of the item to create, it should be a valid JSON string."
-        );
-        break;
-      case "markdown":
-        fields[field.name] = z6.string().describe(
-          "The " + field.name + " of the item to create, it should be a valid Markdown string."
-        );
-        break;
-      case "number":
-        fields[field.name] = z6.number().describe("The " + field.name + " of the item to create");
-        break;
-      case "boolean":
-        fields[field.name] = z6.boolean().describe("The " + field.name + " of the item to create");
-        break;
-      case "file":
-      case "uuid":
-      case "date":
-        break;
-      default:
-        fields[field.name] = z6.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: z6.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.
@@ -10236,13 +10282,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}"` : ""}
@@ -10306,6 +10345,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;
@@ -10620,13 +10663,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)
@@ -10685,6 +10721,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 = streamText({
       model,
       // Should be a LanguageModelV1
@@ -10829,12 +10869,11 @@ var providerRateLimiter = async (key, windowSeconds, limit, points) => {
 
 // src/exulu/routes.ts
 import { convertJsonSchemaToZod } from "zod-from-json-schema";
-import "zod";
 var REQUEST_SIZE_LIMIT = "50mb";
 var getExuluVersionNumber = async () => {
   try {
     const path2 = process.cwd();
-    const packageJson = fs.readFileSync(path2 + "/package.json", "utf8");
+    const packageJson = fs2.readFileSync(path2 + "/package.json", "utf8");
     const packageData = JSON.parse(packageJson);
     const exuluVersion = packageData.dependencies["@exulu/backend"];
     console.log(`[EXULU] Installed exulu-backend version: ${exuluVersion}`);
@@ -11744,7 +11783,7 @@ import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import "express";
 import "@opentelemetry/api";
 import CryptoJS7 from "crypto-js";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var SESSION_ID_HEADER = "mcp-session-id";
 var ExuluMCP = class {
   server = {};
@@ -11827,7 +11866,7 @@ var ExuluMCP = class {
           title: tool3.name + " agent",
           description: tool3.description,
           inputSchema: {
-            inputs: tool3.inputSchema || z9.object({})
+            inputs: tool3.inputSchema || z8.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -11879,7 +11918,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: z9.object({})
+            inputs: z8.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -11925,8 +11964,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: z9.object({
-              id: z9.string().describe("The ID of the prompt template to retrieve")
+            inputs: z8.object({
+              id: z8.string().describe("The ID of the prompt template to retrieve")
             })
           }
         },
@@ -12834,7 +12873,7 @@ var ExuluEval = class {
 };
 
 // src/templates/evals/index.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
     return new ExuluEval({
@@ -12879,8 +12918,8 @@ var llmAsJudgeEval = () => {
           contexts: [],
           rerankers: [],
           prompt,
-          outputSchema: z10.object({
-            score: z10.number().min(0).max(100).describe("The score between 0 and 100.")
+          outputSchema: z9.object({
+            score: z9.number().min(0).max(100).describe("The score between 0 and 100.")
           }),
           providerapikey
         });
@@ -13108,12 +13147,12 @@ Usage:
 - If no todos exist yet, an empty list will be returned`;
 
 // src/templates/tools/todo/todo.ts
-import z11 from "zod";
-var TodoSchema = z11.object({
-  content: z11.string().describe("Brief description of the task"),
-  status: z11.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  priority: z11.string().describe("Priority level of the task: high, medium, low"),
-  id: z11.string().describe("Unique identifier for the todo item")
+import z10 from "zod";
+var TodoSchema = z10.object({
+  content: z10.string().describe("Brief description of the task"),
+  status: z10.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+  priority: z10.string().describe("Priority level of the task: high, medium, low"),
+  id: z10.string().describe("Unique identifier for the todo item")
 });
 var TodoWriteTool = new ExuluTool({
   id: "todo_write",
@@ -13129,8 +13168,8 @@ var TodoWriteTool = new ExuluTool({
       default: todowrite_default
     }
   ],
-  inputSchema: z11.object({
-    todos: z11.array(TodoSchema).describe("The updated todo list")
+  inputSchema: z10.object({
+    todos: z10.array(TodoSchema).describe("The updated todo list")
   }),
   execute: async (inputs) => {
     const { sessionID, todos, user } = inputs;
@@ -13165,7 +13204,7 @@ var TodoReadTool = new ExuluTool({
   id: "todo_read",
   name: "Todo Read",
   description: "Use this tool to read your todo list",
-  inputSchema: z11.object({}),
+  inputSchema: z10.object({}),
   type: "function",
   category: "todo",
   config: [
@@ -13203,6 +13242,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
+import z11 from "zod";
+import { randomUUID as randomUUID6 } from "crypto";
+var AnswerOptionSchema = z11.object({
+  id: z11.string().describe("Unique identifier for the answer option"),
+  text: z11.string().describe("The text of the answer option")
+});
+var _QuestionSchema = z11.object({
+  id: z11.string().describe("Unique identifier for the question"),
+  question: z11.string().describe("The question to ask the user"),
+  answerOptions: z11.array(AnswerOptionSchema).describe("Array of possible answer options"),
+  selectedAnswerId: z11.string().optional().describe("The ID of the answer option selected by the user"),
+  status: z11.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: z11.object({
+    question: z11.string().describe("The question to ask the user"),
+    answerOptions: z11.array(z11.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: randomUUID6(),
+      text
+    }));
+    answerOptionsWithIds.push({
+      id: randomUUID6(),
+      text: "None of the above..."
+    });
+    const newQuestion = {
+      id: randomUUID6(),
+      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: z11.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
 import z12 from "zod";
 import Perplexity from "@perplexity-ai/perplexity_ai";
@@ -13313,14 +13568,29 @@ var isValidPostgresName = (id) => {
 
 // src/exulu/app/index.ts
 var isDev = process.env.NODE_ENV !== "production";
+var lineLimitFormat = winston2.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 winston2.transports.Console({
   format: isDev ? winston2.format.combine(
+    lineLimitFormat(),
     winston2.format.colorize(),
     winston2.format.timestamp({ format: "HH:mm:ss" }),
     winston2.format.printf(({ timestamp, level, message }) => {
       return `${timestamp} [${level}] ${message}`;
     })
-  ) : winston2.format.json()
+  ) : winston2.format.combine(
+    lineLimitFormat(),
+    winston2.format.json()
+  )
 });
 var formatArg = (arg) => typeof arg === "object" ? util.inspect(arg, { depth: null, colors: isDev }) : String(arg);
 var createLogMethod = (logger, logLevel) => {
@@ -13390,6 +13660,7 @@ var ExuluApp2 = class {
     this._tools = [
       ...tools ?? [],
       ...todoTools,
+      ...questionTools,
       ...perplexityTools,
       // Add contexts as tools
       ...Object.values(contexts || {}).map((context) => context.tool()).filter(Boolean)
@@ -16169,12 +16440,12 @@ Or manually run the setup script:
 }
 
 // ee/python/documents/processing/doc_processor.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path from "path";
 import { generateText as generateText3, Output as Output3 } from "ai";
 import { z as z13 } from "zod";
 import pLimit from "p-limit";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import * as mammoth from "mammoth";
 import TurndownService from "turndown";
 import WordExtractor from "word-extractor";
@@ -16394,7 +16665,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.
@@ -16726,7 +16997,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 parseOfficeAsync2(buffer, {
@@ -16759,9 +17030,9 @@ ${setupResult.output || ""}`);
       }, 10);
       const parser = new 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`
@@ -16776,15 +17047,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 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) => ({
@@ -16792,7 +17063,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`);
@@ -16823,13 +17094,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;
@@ -16845,7 +17116,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 {
@@ -16872,11 +17143,11 @@ var loadFile = async (file, name, tempDir) => {
   if (!fileType) {
     throw new Error("[EXULU] File name does not include extension, extension is required for document processing.");
   }
-  const UUID = randomUUID6();
+  const UUID = randomUUID7();
   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();
@@ -16884,11 +17155,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 };
@@ -16902,13 +17173,13 @@ async function documentProcessor({
   if (!license["advanced-document-processing"]) {
     throw new Error("Advanced document processing is an enterprise feature, please add a valid Exulu enterprise license key to use it.");
   }
-  const uuid = randomUUID6();
+  const uuid = randomUUID7();
   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,
@@ -16949,7 +17220,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);