@exulu/backend 1.53.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");
@@ -4608,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)"
         )
       }),
@@ -4824,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."
                   )
                 })
@@ -4958,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");
@@ -4988,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();
@@ -5057,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) => `
@@ -5070,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."
         )
       }),
@@ -5177,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) => `
@@ -5193,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,
@@ -5402,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,
@@ -9897,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);
@@ -9946,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.
@@ -10297,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}"` : ""}
@@ -10367,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;
@@ -10681,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)
@@ -10746,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
@@ -10894,7 +10907,7 @@ 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}`);
@@ -16261,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() {
@@ -16271,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;
         }
@@ -16300,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 {
@@ -16321,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}`,
@@ -16403,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 })"
@@ -16461,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");
@@ -16476,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() {
@@ -16486,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;
         }
@@ -16550,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}`,
       "",
@@ -16686,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.
@@ -17018,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, {
@@ -17051,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`
@@ -17068,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) => ({
@@ -17084,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`);
@@ -17115,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;
@@ -17137,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 {
@@ -17168,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();
@@ -17176,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 };
@@ -17198,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,
@@ -17241,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);

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";
@@ -4567,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)"
         )
       }),
@@ -4783,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."
                   )
                 })
@@ -4917,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");
@@ -4947,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();
@@ -5016,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) => `
@@ -5029,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."
         )
       }),
@@ -5136,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) => `
@@ -5152,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,
@@ -5361,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,
@@ -9856,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";
@@ -9912,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.
@@ -10263,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}"` : ""}
@@ -10333,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;
@@ -10647,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)
@@ -10712,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
@@ -10860,7 +10873,7 @@ 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}`);
@@ -16427,7 +16440,7 @@ 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";
@@ -16652,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.
@@ -16984,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, {
@@ -17017,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`
@@ -17034,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) => ({
@@ -17050,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`);
@@ -17081,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;
@@ -17103,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 {
@@ -17134,7 +17147,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();
@@ -17142,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 };
@@ -17164,9 +17177,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,
@@ -17207,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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exulu/backend",
   "author": "Qventu Bv.",
-  "version": "1.53.0",
+  "version": "1.53.1",
   "main": "./dist/index.js",
   "private": false,
   "publishConfig": {