@exulu/backend 1.54.0 → 1.55.0

package/dist/index.cjs

@@ -101,10 +101,10 @@ async function redisClient() {
 }
 
 // src/exulu/app/index.ts
-var import_express6 = require("express");
+var import_express7 = require("express");
 
 // src/exulu/routes.ts
-var import_express2 = require("express");
+var import_express4 = require("express");
 
 // src/auth/get-token.ts
 var import_jose = require("jose");
@@ -548,7 +548,7 @@ var STATISTICS_TYPE_ENUM = {
 };
 
 // src/exulu/routes.ts
-var import_express3 = __toESM(require("express"), 1);
+var import_express5 = __toESM(require("express"), 1);
 var import_server4 = require("@apollo/server");
 var import_cors = __toESM(require("cors"), 1);
 var import_reflect_metadata = require("reflect-metadata");
@@ -807,7 +807,7 @@ var JOB_STATUS_ENUM = {
 };
 
 // ee/agentic-retrieval/v3/index.ts
-var import_zod10 = require("zod");
+var import_zod9 = require("zod");
 var import_bash_tool = require("bash-tool");
 
 // src/exulu/tool.ts
@@ -1041,10 +1041,25 @@ var createSessionItemsRetrievalTool = async ({
   return sessionItemsRetrievalTool;
 };
 
+// ee/agentic-retrieval/v3/session-tools-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerSessionTools(sessionId, tools) {
+  const existing = registry.get(sessionId) ?? /* @__PURE__ */ new Map();
+  for (const [name, toolDef] of Object.entries(tools)) {
+    existing.set(name, toolDef);
+  }
+  registry.set(sessionId, existing);
+}
+function getSessionTools(sessionId) {
+  const toolMap = registry.get(sessionId);
+  if (!toolMap || toolMap.size === 0) return {};
+  return Object.fromEntries(toolMap.entries());
+}
+
 // src/utils/sanitize-tool-name.ts
 function sanitizeToolName(name) {
   if (typeof name !== "string") return "";
-  let sanitized = name.replace(/[^a-zA-Z0-9_.\:-]+/g, "_");
+  let sanitized = name.replace(/[^a-zA-Z0-9_\:-]+/g, "_");
   if (sanitized.length > 0 && !/^[a-zA-Z_]/.test(sanitized)) {
     sanitized = "_" + sanitized;
   }
@@ -1066,7 +1081,6 @@ var import_node_crypto = require("crypto");
 
 // src/templates/tools/memory-tool.ts
 var import_zod3 = require("zod");
-var import_fs = require("fs");
 var createNewMemoryItemTool = (agent, context) => {
   const fields = {
     name: import_zod3.z.string().describe("The name of the item to create"),
@@ -1204,9 +1218,9 @@ var getMimeType = (type) => {
       return "";
   }
 };
-var hydrateVariables = async (tool6) => {
+var hydrateVariables = async (tool5) => {
   const { db: db2 } = await postgresClient();
-  const promises2 = tool6.config.map(async (toolConfig) => {
+  const promises2 = tool5.config.map(async (toolConfig) => {
     if (!toolConfig.variable) {
       return toolConfig;
     }
@@ -1237,9 +1251,9 @@ var hydrateVariables = async (tool6) => {
     return toolConfig;
   });
   await Promise.all(promises2);
-  return tool6;
+  return tool5;
 };
-var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExuluTools, configs, providerapikey, contexts, rerankers, user, exuluConfig, sessionID, req, project, items, model, agent) => {
+var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExuluTools, configs, providerapikey, contexts, rerankers, user, exuluConfig, sessionID, req, project, sessionItems, model, agent) => {
   if (!currentTools) return {};
   if (!allExuluTools) {
     allExuluTools = [];
@@ -1274,13 +1288,13 @@ var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExulu
       currentTools.push(createNewMemoryTool);
     }
   }
-  console.log("[EXULU] Convert tools array to object, session items", items);
-  if (items) {
+  console.log("[EXULU] Convert tools array to object, session items", sessionItems);
+  if (sessionItems) {
     const sessionItemsRetrievalTool = await createSessionItemsRetrievalTool({
       user,
       role: user?.role?.id,
       contexts,
-      items
+      items: sessionItems
     });
     if (sessionItemsRetrievalTool) {
       currentTools.push(sessionItemsRetrievalTool);
@@ -1294,10 +1308,11 @@ var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExulu
       rerankers: rerankers || [],
       user,
       role: user?.role?.id,
-      model
+      model,
+      preselectedItemIds: sessionItems
     });
     if (agenticSearchTool) {
-      const index = currentTools.findIndex((tool6) => tool6.id === "agentic_context_search");
+      const index = currentTools.findIndex((tool5) => tool5.id === "agentic_context_search");
       if (index !== -1) {
         currentTools[index] = {
           ...currentTools[index],
@@ -1307,21 +1322,26 @@ var convertExuluToolsToAiSdkTools = async (currentTools, approvedTools, allExulu
       }
     }
   } else {
-    const agenticSearchTool = currentTools.find((tool6) => tool6.id === "agentic_context_search");
+    const agenticSearchTool = currentTools.find((tool5) => tool5.id === "agentic_context_search");
     if (agenticSearchTool) {
       currentTools.splice(currentTools.indexOf(agenticSearchTool), 1);
     }
   }
-  const sanitizedTools = currentTools ? currentTools.map((tool6) => ({
-    ...tool6,
-    name: sanitizeToolName(tool6.name)
+  const sanitizedTools = currentTools ? currentTools.map((tool5) => ({
+    ...tool5,
+    name: sanitizeToolName(tool5.name)
   })) : [];
   console.log(
     "[EXULU] Sanitized tools",
     sanitizedTools.map((x) => x.name + " (" + x.id + ")")
   );
   console.log("[EXULU] Approved tools", approvedTools);
+  const sessionDynamicTools = sessionID ? Object.entries(getSessionTools(sessionID)).reduce((acc, [name, t]) => {
+    acc[name] = { ...t, needsApproval: false };
+    return acc;
+  }, {}) : {};
   return {
+    ...sessionDynamicTools,
     ...sanitizedTools?.reduce((prev, cur) => {
       let toolVariableConfig = configs?.find((config) => config.id === cur.id);
       const userDefinedConfigDescription = toolVariableConfig?.config.find(
@@ -1523,7 +1543,7 @@ var ExuluTool = class {
     });
   }
   execute = async ({
-    agent: agentId,
+    agent: agentId2,
     config,
     user,
     inputs,
@@ -1531,14 +1551,14 @@ var ExuluTool = class {
     items
   }) => {
     console.log("[EXULU] Calling tool execute directly", {
-      agentId,
+      agentId: agentId2,
       config,
       user,
       inputs,
       project,
       items
     });
-    const agent = await exuluApp.get().agent(agentId);
+    const agent = await exuluApp.get().agent(agentId2);
     if (!agent) {
       throw new Error("Agent not found.");
     }
@@ -1581,8 +1601,8 @@ var ExuluTool = class {
       void 0,
       agent
     );
-    const tool6 = tools[sanitizeName(this.name)] || tools[this.name] || tools[this.id];
-    if (!tool6?.execute) {
+    const tool5 = tools[sanitizeName(this.name)] || tools[this.name] || tools[this.id];
+    if (!tool5?.execute) {
       throw new Error("Tool " + sanitizeName(this.name) + " not found in " + JSON.stringify(tools));
     }
     console.log("[EXULU] Tool found", this.name);
@@ -1592,7 +1612,7 @@ var ExuluTool = class {
       toolCallId,
       messages: []
     });
-    const generator = tool6.execute(inputs, {
+    const generator = tool5.execute(inputs, {
       toolCallId,
       messages: []
     });
@@ -1722,7 +1742,7 @@ var uploadFile = async (file, fileName, config, options = {}, user, customBucket
       if (error.name === "SignatureDoesNotMatch" || error.name === "InvalidAccessKeyId" || error.name === "AccessDenied") {
         if (attempt < maxRetries) {
           const backoffMs = Math.pow(2, attempt) * 1e3;
-          await new Promise((resolve4) => setTimeout(resolve4, backoffMs));
+          await new Promise((resolve3) => setTimeout(resolve3, backoffMs));
           s3Client2 = void 0;
           getS3Client(config);
           continue;
@@ -1737,6 +1757,87 @@ var uploadFile = async (file, fileName, config, options = {}, user, customBucket
   }
   return addBucketPrefixToKey(key, customBucket || defaultBucket);
 };
+var listS3ObjectsByPrefix = async (prefix, config) => {
+  if (!config.fileUploads) {
+    throw new Error("File uploads are not configured");
+  }
+  const client2 = getS3Client(config);
+  const bucket = config.fileUploads.s3Bucket;
+  const fullPrefix = addGeneralPrefixToKey(prefix, config);
+  const results = [];
+  let continuationToken;
+  do {
+    const command = new import_client_s32.ListObjectsV2Command({
+      Bucket: bucket,
+      Prefix: fullPrefix,
+      ...continuationToken && { ContinuationToken: continuationToken }
+    });
+    const response = await client2.send(command);
+    for (const obj of response.Contents ?? []) {
+      if (obj.Key && obj.Size !== void 0 && obj.LastModified) {
+        results.push({
+          key: obj.Key,
+          size: obj.Size,
+          lastModified: obj.LastModified
+        });
+      }
+    }
+    continuationToken = response.IsTruncated ? response.NextContinuationToken : void 0;
+  } while (continuationToken);
+  return results;
+};
+var copyS3Object = async (sourceKey, destKey, config) => {
+  if (!config.fileUploads) {
+    throw new Error("File uploads are not configured");
+  }
+  const client2 = getS3Client(config);
+  const bucket = config.fileUploads.s3Bucket;
+  const command = new import_client_s32.CopyObjectCommand({
+    Bucket: bucket,
+    CopySource: `${bucket}/${sourceKey}`,
+    Key: destKey
+  });
+  await client2.send(command);
+};
+var getS3ObjectContent = async (key, config) => {
+  if (!config.fileUploads) {
+    throw new Error("File uploads are not configured");
+  }
+  const client2 = getS3Client(config);
+  const bucket = config.fileUploads.s3Bucket;
+  const command = new import_client_s32.GetObjectCommand({ Bucket: bucket, Key: key });
+  const response = await client2.send(command);
+  if (!response.Body) {
+    throw new Error(`Empty body for S3 key: ${key}`);
+  }
+  return response.Body.transformToString("utf-8");
+};
+var deleteS3Object = async (key, config) => {
+  if (!config.fileUploads) {
+    throw new Error("File uploads are not configured");
+  }
+  const client2 = getS3Client(config);
+  const bucket = config.fileUploads.s3Bucket;
+  const command = new import_client_s32.DeleteObjectCommand({ Bucket: bucket, Key: key });
+  await client2.send(command);
+};
+var getS3SignedUploadUrl = async (key, contentType, config) => {
+  if (!config.fileUploads) {
+    throw new Error("File uploads are not configured");
+  }
+  const client2 = getS3Client(config);
+  const bucket = config.fileUploads.s3Bucket;
+  const url = await (0, import_s3_request_presigner.getSignedUrl)(
+    client2,
+    new import_client_s32.PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      ContentType: contentType
+    }),
+    { expiresIn }
+  );
+  return url;
+};
 var createUppyRoutes = async (app, config) => {
   if (!config.fileUploads) {
     throw new Error("File uploads are not configured");
@@ -2995,6 +3096,53 @@ var agentSessionsSchema = {
     }
   ]
 };
+var skillsSchema = {
+  type: "skills",
+  name: {
+    plural: "skills",
+    singular: "skill"
+  },
+  RBAC: true,
+  fields: [
+    {
+      name: "name",
+      type: "text",
+      index: true,
+      unique: true
+    },
+    {
+      name: "description",
+      type: "text"
+    },
+    {
+      name: "s3folder",
+      type: "text"
+    },
+    {
+      name: "tags",
+      type: "json"
+    },
+    {
+      name: "usage_count",
+      type: "number",
+      default: 0
+    },
+    {
+      name: "favorite_count",
+      type: "number",
+      default: 0
+    },
+    {
+      name: "history",
+      type: "json"
+    },
+    {
+      name: "current_version",
+      type: "number",
+      default: 1
+    }
+  ]
+};
 var variablesSchema = {
   type: "variables",
   name: {
@@ -3113,6 +3261,10 @@ var agentsSchema = {
       name: "tools",
       type: "json"
     },
+    {
+      name: "skills",
+      type: "json"
+    },
     {
       name: "animation_idle",
       type: "text"
@@ -3372,6 +3524,7 @@ var coreSchemas = {
       agentSessionsSchema: () => addCoreFields(agentSessionsSchema),
       projectsSchema: () => addCoreFields(projectsSchema),
       usersSchema: () => addCoreFields(usersSchema),
+      skillsSchema: () => addCoreFields(skillsSchema),
       statisticsSchema: () => addCoreFields(statisticsSchema),
       variablesSchema: () => addCoreFields(variablesSchema),
       platformConfigurationsSchema: () => addCoreFields(platformConfigurationsSchema),
@@ -3993,9 +4146,6 @@ var mapType = (t, type, name, defaultValue, unique) => {
   throw new Error("Invalid field type for database: " + type);
 };
 
-// src/exulu/context.ts
-var import_zod5 = require("zod");
-
 // ee/queues/decorator.ts
 var import_bullmq2 = require("bullmq");
 var import_uuid = require("uuid");
@@ -4712,69 +4862,6 @@ var ExuluContext2 = class {
           `);
     return;
   };
-  // Exports the context as a tool that can be used by an agent
-  tool = () => {
-    if (this.configuration.enableAsTool === false) {
-      return null;
-    }
-    return new ExuluTool({
-      id: this.id,
-      name: `${this.name}_context_search`,
-      type: "context",
-      category: "contexts",
-      needsApproval: true,
-      // todo make configurable
-      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_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)"
-        )
-      }),
-      config: [],
-      description: `Gets information from the context called: ${this.name}. The context description is: ${this.description}.`,
-      execute: async ({ query, keywords, user, role, method }) => {
-        const { db: db2 } = await postgresClient();
-        const result = await vectorSearch({
-          page: 1,
-          limit: this.configuration.maxRetrievalResults ?? 10,
-          query,
-          keywords,
-          itemFilters: [],
-          chunkFilters: [],
-          user,
-          role,
-          method: method === "hybrid" ? "hybridSearch" : method === "keyword" ? "tsvector" : "cosineDistance",
-          context: this,
-          db: db2,
-          sort: void 0,
-          trigger: "agent"
-        });
-        await updateStatistic({
-          name: "count",
-          label: this.name,
-          type: STATISTICS_TYPE_ENUM.TOOL_CALL,
-          trigger: "tool",
-          count: 1,
-          user: user?.id,
-          role: user?.role?.id
-        });
-        return {
-          result: JSON.stringify(
-            result.chunks.map((chunk) => ({
-              ...chunk,
-              context: {
-                name: this.name,
-                id: this.id
-              }
-            }))
-          )
-        };
-      }
-    });
-  };
 };
 
 // ee/agentic-retrieval/v3/context-sampler.ts
@@ -4819,7 +4906,27 @@ var ContextSampler = class {
 
 // ee/agentic-retrieval/v3/classifier.ts
 var import_ai2 = require("ai");
-var import_zod6 = require("zod");
+var import_zod5 = require("zod");
+
+// src/utils/with-retry.ts
+async function withRetry(generateFn, maxRetries = 3) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await generateFn();
+    } catch (error) {
+      lastError = error;
+      console.error(`[EXULU] generateText attempt ${attempt} failed:`, error);
+      if (attempt === maxRetries) {
+        throw error;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, Math.pow(2, attempt) * 1e3));
+    }
+  }
+  throw lastError;
+}
+
+// ee/agentic-retrieval/v3/classifier.ts
 async function classifyQuery(query, contexts, samples, model) {
   const contextDescriptions = contexts.map((ctx) => {
     const sample = samples.find((s) => s.contextId === ctx.id);
@@ -4830,46 +4937,49 @@ async function classifyQuery(query, contexts, samples, model) {
     Description: ${ctx.description}
     Fields: ${fieldList}${exampleStr}`;
   }).join("\n\n");
-  const result = await (0, import_ai2.generateText)({
-    model,
-    temperature: 0,
-    output: import_ai2.Output.object({
-      schema: import_zod6.z.object({
-        queryType: import_zod6.z.enum(["aggregate", "list", "targeted", "exploratory"]).describe(
-          "aggregate: ONLY use when the user explicitly asks to COUNT how many documents/items/tickets exist in the knowledge base (e.g. 'how many documents about X?', 'total number of tickets'). NEVER use for: real-world statistics stored in a document, intent statements, how-to questions, error/fault descriptions, configuration questions, or any query that does not explicitly ask for a count of knowledge base entries. When in doubt, choose targeted. list: user wants to enumerate matching items/documents (show me all, list documents about). targeted: use for almost everything \u2014 specific fact, answer, configuration, how-to, error/fault, feature/behavior question. Also use for intent statements and short commands describing a desired state (phrases that state what the user wants to do or achieve, even without an explicit question word). Real-world statistics stored in documents also go here. When in doubt, choose targeted over aggregate or exploratory. exploratory: only for broad conceptual questions needing multi-source synthesis (what is the process for Z, explain how X works, general overview of topic Y)."
-        ),
-        language: import_zod6.z.string().describe("ISO 639-3 language code of the query (e.g. eng, deu, fra)"),
-        suggestedContextIds: import_zod6.z.array(import_zod6.z.string()).describe(
-          "IDs of knowledge bases most likely to contain the answer. Return empty array to search all contexts."
-        )
-      })
-    }),
-    toolChoice: "none",
-    system: `You are a query classifier for a multi-knowledge-base retrieval system.
-Classify the query and identify which knowledge bases are most relevant.
-
-Available knowledge bases:
-${contextDescriptions}
-
-Guidelines for queryType:
-- Use "aggregate" ONLY when the query contains explicit counting language (e.g., "how many", "count", "total number", "wie viele"). Short statements, commands, or phrases without a question word are NEVER aggregate \u2014 classify them as targeted.
-- When in doubt between aggregate and targeted: always choose targeted.
-
-Guidelines for suggestedContextIds:
-- Be conservative: only suggest contexts that are genuinely likely to contain the answer.
-  Aim for 2\u20133 focused suggestions rather than listing everything.
-- Use each knowledge base's name and description (shown above) to judge relevance.
-- Return an empty array only if you truly cannot determine which contexts are relevant.`,
-    prompt: `Query: ${query}`
-  });
-  return result.output;
+  const result = await withRetry(async () => {
+    const result2 = await (0, import_ai2.generateText)({
+      model,
+      temperature: 0,
+      output: import_ai2.Output.object({
+        schema: import_zod5.z.object({
+          queryType: import_zod5.z.enum(["aggregate", "list", "targeted", "exploratory"]).describe(
+            "aggregate: ONLY use when the user explicitly asks to COUNT how many documents/items/tickets exist in the knowledge base (e.g. 'how many documents about X?', 'total number of tickets'). NEVER use for: real-world statistics stored in a document, intent statements, how-to questions, error/fault descriptions, configuration questions, or any query that does not explicitly ask for a count of knowledge base entries. When in doubt, choose targeted. list: user wants to enumerate matching items/documents (show me all, list documents about). targeted: use for almost everything \u2014 specific fact, answer, configuration, how-to, error/fault, feature/behavior question. Also use for intent statements and short commands describing a desired state (phrases that state what the user wants to do or achieve, even without an explicit question word). Real-world statistics stored in documents also go here. When in doubt, choose targeted over aggregate or exploratory. exploratory: only for broad conceptual questions needing multi-source synthesis (what is the process for Z, explain how X works, general overview of topic Y)."
+          ),
+          language: import_zod5.z.string().describe("ISO 639-3 language code of the query (e.g. eng, deu, fra)"),
+          suggestedContextIds: import_zod5.z.array(import_zod5.z.enum(contexts.map((c) => c.id))).describe(
+            "IDs of knowledge bases most likely to contain the answer. Return empty array to search all contexts."
+          )
+        })
+      }),
+      toolChoice: "none",
+      system: `You are a query classifier for a multi-knowledge-base retrieval system.
+    Classify the query and identify which knowledge bases are most relevant.
+    
+    Available knowledge bases:
+    ${contextDescriptions}
+    
+    Guidelines for queryType:
+    - Use "aggregate" ONLY when the query contains explicit counting language (e.g., "how many", "count", "total number", "wie viele"). Short statements, commands, or phrases without a question word are NEVER aggregate \u2014 classify them as targeted.
+    - When in doubt between aggregate and targeted: always choose targeted.
+    
+    Guidelines for suggestedContextIds:
+    - Be conservative: only suggest contexts that are genuinely likely to contain the answer.
+      Aim for 2\u20133 focused suggestions rather than listing everything.
+    - Use each knowledge base's name and description (shown above) to judge relevance.
+    - Return an empty array only if you truly cannot determine which contexts are relevant.`,
+      prompt: `Query: ${query}`
+    });
+    return result2.output;
+  }, 3);
+  return result;
 }
 
 // ee/agentic-retrieval/v3/tools.ts
-var import_zod7 = require("zod");
+var import_zod6 = require("zod");
 var import_ai3 = require("ai");
 function buildContextEnum(contexts) {
-  return import_zod7.z.array(import_zod7.z.enum(contexts.map((c) => c.id))).describe(
+  return import_zod6.z.array(import_zod6.z.enum(contexts.map((c) => c.id))).describe(
     contexts.map(
       (c) => `<knowledge_base id="${c.id}" name="${c.name}">${c.description}</knowledge_base>`
     ).join("\n")
@@ -4890,16 +5000,34 @@ function mapSearchMethod(method) {
   if (method === "keyword") return "tsvector";
   return "cosineDistance";
 }
+function parseGlobalItemIds(globalIds) {
+  const map = /* @__PURE__ */ new Map();
+  for (const gid of globalIds) {
+    const slashIdx = gid.indexOf("/");
+    if (slashIdx === -1) {
+      if (gid) map.set(gid, null);
+      continue;
+    }
+    const contextId = gid.slice(0, slashIdx);
+    const itemId = gid.slice(slashIdx + 1);
+    if (!contextId || !itemId) continue;
+    if (map.get(contextId) === null) continue;
+    const existing = map.get(contextId) ?? [];
+    existing.push(itemId);
+    map.set(contextId, existing);
+  }
+  return map;
+}
 function createRetrievalTools(params) {
-  const { contexts, user, role, updateVirtualFiles } = params;
+  const { contexts, user, role, updateVirtualFiles, preselectedItemsByContext } = params;
   const ctxEnum = buildContextEnum(contexts);
   const count_items_or_chunks = (0, import_ai3.tool)({
     description: "Count items or chunks WITHOUT loading them into context. Use for 'how many', 'count', or 'total number of' queries.",
-    inputSchema: import_zod7.z.object({
+    inputSchema: import_zod6.z.object({
       knowledge_base_ids: ctxEnum,
-      count_what: import_zod7.z.enum(["items", "chunks"]).describe("Whether to count items (documents) or chunks (pages/sections)"),
-      name_contains: import_zod7.z.string().optional().describe("Only count items whose name contains this text (case-insensitive)"),
-      content_query: import_zod7.z.string().optional().describe(
+      count_what: import_zod6.z.enum(["items", "chunks"]).describe("Whether to count items (documents) or chunks (pages/sections)"),
+      name_contains: import_zod6.z.string().optional().describe("Only count items whose name contains this text (case-insensitive)"),
+      content_query: import_zod6.z.string().optional().describe(
         "Only count chunks matching this search query (uses hybrid search). Only used when count_what is 'chunks'."
       )
     }),
@@ -4908,6 +5036,10 @@ function createRetrievalTools(params) {
       const ctxList = resolveContexts(knowledge_base_ids, contexts);
       const counts = await Promise.all(
         ctxList.map(async (ctx) => {
+          const contextItemIds = preselectedItemsByContext?.get(ctx.id);
+          if (preselectedItemsByContext && contextItemIds === void 0) {
+            return { context: ctx.id, context_name: ctx.name, count: 0 };
+          }
           let count = 0;
           if (count_what === "items") {
             const tableName = getTableName(ctx.id);
@@ -4915,19 +5047,23 @@ function createRetrievalTools(params) {
             if (name_contains) {
               q = q.whereRaw("LOWER(name) LIKE ?", [`%${name_contains.toLowerCase()}%`]);
             }
+            if (Array.isArray(contextItemIds)) {
+              q = q.whereIn("id", contextItemIds);
+            }
             const tableDefinition = convertContextToTableDefinition(ctx);
             q = applyAccessControl(tableDefinition, q, user, tableName);
             const result = await q.first();
             count = Number(result?.count ?? 0);
           } else {
             const chunksTable = getChunksTableName(ctx.id);
+            const baseItemFilters = Array.isArray(contextItemIds) ? [{ id: { in: contextItemIds } }] : [];
             if (content_query) {
               const searchResults = await ctx.search({
                 query: content_query,
                 method: "hybridSearch",
                 limit: 1e4,
                 page: 1,
-                itemFilters: [],
+                itemFilters: baseItemFilters,
                 chunkFilters: [],
                 sort: { field: "updatedAt", direction: "desc" },
                 user,
@@ -4935,6 +5071,9 @@ function createRetrievalTools(params) {
                 trigger: "tool"
               });
               count = searchResults.chunks.length;
+            } else if (Array.isArray(contextItemIds)) {
+              const result = await db2(chunksTable).count("id as count").whereIn("source", contextItemIds).first();
+              count = Number(result?.count ?? 0);
             } else {
               const result = await db2(chunksTable).count("id as count").first();
               count = Number(result?.count ?? 0);
@@ -4950,11 +5089,13 @@ function createRetrievalTools(params) {
     }
   });
   const search_items_by_name = (0, import_ai3.tool)({
-    description: "Search for items by their name or external ID. Use only when the user is asking for documents BY TITLE, not by content topic.",
-    inputSchema: import_zod7.z.object({
+    description: "Search for items by their name or external ID. Use when:\n\u2022 The user asks for a document BY TITLE or NAME\n\u2022 The user asks whether a specific named document EXISTS (e.g. 'do you have the X manual?', 'is there a document for Y?')\n\u2022 Any query that references a specific document, manual, or resource by its name rather than by topic\nDo NOT use for topic-based content queries (e.g. 'what are the parameters for X?', 'how do I configure Y?').",
+    inputSchema: import_zod6.z.object({
       knowledge_base_ids: ctxEnum,
-      item_name: import_zod7.z.string().describe("The name or partial name to search for"),
-      limit: import_zod7.z.number().default(100).describe(
+      item_name: import_zod6.z.string().describe(
+        "The name or partial name to search for. Uses substring matching, so shorter and more specific terms work better than full phrases. Extract only the core identifying part \u2014 typically the product model, document title, or unique identifier. Do NOT include surrounding descriptors like type words ('manual', 'guide', 'document') or manufacturer names unless they are likely part of the actual document title."
+      ),
+      limit: import_zod6.z.number().default(100).describe(
         "Max items per knowledge base (max 400). Applies independently to each knowledge base."
       )
     }),
@@ -4962,9 +5103,12 @@ function createRetrievalTools(params) {
       const { db: db2 } = await postgresClient();
       const ctxList = resolveContexts(knowledge_base_ids, contexts);
       const safeLimit = Math.min(limit ?? 100, 400);
-      const itemFilters = item_name ? [{ name: { contains: item_name } }] : [];
       const results = await Promise.all(
         ctxList.map(async (ctx) => {
+          const contextItemIds = preselectedItemsByContext?.get(ctx.id);
+          if (preselectedItemsByContext && contextItemIds === void 0) return [];
+          const itemFilters = item_name ? [{ name: { contains: item_name } }] : [];
+          if (Array.isArray(contextItemIds)) itemFilters.push({ id: { in: contextItemIds } });
           const tableName = getTableName(ctx.id);
           const tableDefinition = convertContextToTableDefinition(ctx);
           let q = db2(`${tableName} as items`).select([
@@ -5000,30 +5144,35 @@ function createRetrievalTools(params) {
     }
   });
   const search_content = (0, import_ai3.tool)({
-    description: `Search across document content using hybrid, keyword, or semantic search.
+    description: `Search ONE knowledge base for document content using hybrid, keyword, or semantic search.
+Always make a separate call for each knowledge base you want to search \u2014 never bundle multiple in one call.
 
 Use includeContent: false when you only need to know WHICH documents match (listing, overview, navigation).
 Use includeContent: true when you need the ACTUAL text to answer a question.
 
 For listing queries: always start with includeContent: false, then use dynamic tools to fetch specific pages.`,
-    inputSchema: import_zod7.z.object({
-      query: import_zod7.z.string().describe("Search query about the content you're looking for"),
-      knowledge_base_ids: ctxEnum,
-      keywords: import_zod7.z.array(import_zod7.z.string()).optional().describe("Keywords extracted from the query"),
-      searchMethod: import_zod7.z.enum(["hybrid", "keyword", "semantic"]).default("hybrid").describe(
+    inputSchema: import_zod6.z.object({
+      query: import_zod6.z.string().describe("Search query about the content you're looking for"),
+      knowledge_base_id: import_zod6.z.enum(contexts.map((c) => c.id)).describe(
+        contexts.map(
+          (c) => `<knowledge_base id="${c.id}" name="${c.name}">${c.description}</knowledge_base>`
+        ).join("\n")
+      ),
+      keywords: import_zod6.z.array(import_zod6.z.string()).optional().describe("Keywords extracted from the query"),
+      searchMethod: import_zod6.z.enum(["hybrid", "keyword", "semantic"]).default("hybrid").describe(
         "hybrid: best default (semantic + keyword). keyword: exact terms, product codes, IDs. semantic: conceptual/synonyms."
       ),
-      includeContent: import_zod7.z.boolean().default(true).describe(
+      includeContent: import_zod6.z.boolean().default(true).describe(
         "false: returns metadata only (document names, scores) \u2014 use for listing/navigation. true: returns full chunk text \u2014 use when you need content to answer a question."
       ),
-      item_ids: import_zod7.z.array(import_zod7.z.string()).optional().describe("Filter results to specific item IDs"),
-      item_names: import_zod7.z.array(import_zod7.z.string()).optional().describe("Filter results to items whose name contains one of these strings"),
-      item_external_ids: import_zod7.z.array(import_zod7.z.string()).optional().describe("Filter results to specific external IDs"),
-      limit: import_zod7.z.number().default(10).describe("Max chunks with content (max 10). Without content, up to 200 are returned.")
+      item_ids: import_zod6.z.array(import_zod6.z.string()).optional().describe("Filter results to specific item IDs"),
+      item_names: import_zod6.z.array(import_zod6.z.string()).optional().describe("Filter results to items whose name contains one of these strings"),
+      item_external_ids: import_zod6.z.array(import_zod6.z.string()).optional().describe("Filter results to specific external IDs"),
+      limit: import_zod6.z.number().default(20).describe("Max chunks with content (max 20). Without content, up to 200 are returned.")
     }),
     execute: async ({
       query,
-      knowledge_base_ids,
+      knowledge_base_id,
       keywords,
       searchMethod,
       includeContent,
@@ -5032,67 +5181,81 @@ For listing queries: always start with includeContent: false, then use dynamic t
       item_external_ids,
       limit
     }) => {
-      const ctxList = resolveContexts(knowledge_base_ids, contexts);
-      const effectiveLimit = includeContent ? Math.min(limit ?? 10, 10) : Math.min((limit ?? 10) * 20, 400);
-      const results = await Promise.all(
-        ctxList.map(async (ctx) => {
-          const itemFilters = [];
-          if (item_ids) itemFilters.push({ id: { in: item_ids } });
-          if (item_names)
-            itemFilters.push({ name: { or: item_names.map((n) => ({ contains: n })) } });
-          if (item_external_ids) itemFilters.push({ external_id: { in: item_external_ids } });
-          const effectiveQuery = query || keywords?.join(" ") || "";
-          let method = mapSearchMethod(searchMethod ?? "hybrid");
-          if (method === "hybridSearch" || method === "cosineDistance") {
-            if (!ctx.embedder) {
-              console.error(`[EXULU] context "${ctx.id}" does not have an embedder, falling back to tsvector search`);
-              method = "tsvector";
-            }
-          }
-          try {
-            const { chunks } = await ctx.search({
-              query: effectiveQuery,
-              keywords,
-              method,
-              limit: effectiveLimit,
-              page: 1,
-              itemFilters,
-              chunkFilters: [],
-              sort: { field: "updatedAt", direction: "desc" },
-              user,
-              role,
-              trigger: "tool"
-            });
-            return chunks.map(
-              (chunk) => ({
-                item_name: chunk.item_name,
-                item_id: chunk.item_id,
-                context: chunk.context?.id ?? ctx.id,
-                chunk_id: chunk.chunk_id,
-                chunk_index: chunk.chunk_index,
-                chunk_content: includeContent ? chunk.chunk_content : void 0,
-                metadata: {
-                  ...chunk.chunk_metadata,
-                  cosine_distance: chunk.chunk_cosine_distance,
-                  fts_rank: chunk.chunk_fts_rank,
-                  hybrid_score: chunk.chunk_hybrid_score
-                }
-              })
-            );
-          } catch (err) {
-            console.error(`[EXULU] search_content failed for context "${ctx.id}":`, err);
-            return [];
+      const [ctx] = resolveContexts([knowledge_base_id], contexts);
+      const effectiveLimit = includeContent ? Math.min(limit ?? 20, 20) : Math.min((limit ?? 20) * 20, 400);
+      const itemFilters = [];
+      if (preselectedItemsByContext) {
+        const contextItemIds = preselectedItemsByContext.get(knowledge_base_id);
+        if (contextItemIds === void 0) {
+          return JSON.stringify([]);
+        }
+        if (Array.isArray(contextItemIds)) {
+          const intersection = item_ids?.length ? item_ids.filter((id) => contextItemIds.includes(id)) : contextItemIds;
+          if (!intersection.length) {
+            return JSON.stringify([]);
           }
-        })
-      );
-      return JSON.stringify(results.flat());
+          itemFilters.push({ id: { in: intersection } });
+        } else if (item_ids?.length) {
+          itemFilters.push({ id: { in: item_ids } });
+        }
+      } else if (item_ids?.length) {
+        itemFilters.push({ id: { in: item_ids } });
+      }
+      if (item_names)
+        itemFilters.push({ name: { or: item_names.map((n) => ({ contains: n })) } });
+      if (item_external_ids) itemFilters.push({ external_id: { in: item_external_ids } });
+      const effectiveQuery = query || keywords?.join(" ") || "";
+      let method = mapSearchMethod(searchMethod ?? "hybrid");
+      if (method === "hybridSearch" || method === "cosineDistance") {
+        if (!ctx.embedder) {
+          console.error(`[EXULU] context "${ctx.id}" does not have an embedder, falling back to tsvector search`);
+          method = "tsvector";
+        }
+      }
+      try {
+        const { chunks } = await ctx.search({
+          query: effectiveQuery,
+          keywords,
+          method,
+          limit: effectiveLimit,
+          page: 1,
+          itemFilters,
+          chunkFilters: [],
+          sort: { field: "updatedAt", direction: "desc" },
+          user,
+          role,
+          trigger: "tool"
+        });
+        return JSON.stringify(
+          chunks.map(
+            (chunk) => ({
+              item_name: chunk.item_name,
+              item_id: chunk.item_id,
+              context: chunk.context?.id ?? ctx.id,
+              chunk_id: chunk.chunk_id,
+              chunk_index: chunk.chunk_index,
+              chunk_content: includeContent ? chunk.chunk_content : void 0,
+              metadata: {
+                ...chunk.chunk_metadata,
+                cosine_distance: chunk.chunk_cosine_distance,
+                fts_rank: chunk.chunk_fts_rank,
+                hybrid_score: chunk.chunk_hybrid_score
+              }
+            })
+          )
+        );
+      } catch (err) {
+        console.error(`[EXULU] search_content failed for context "${ctx.id}":`, err);
+        return JSON.stringify([]);
+      }
     }
   });
   const save_search_results = (0, import_ai3.tool)({
-    description: `Execute a search and save ALL results to the virtual filesystem WITHOUT loading them into context.
+    description: `Execute a search on ONE knowledge base and save ALL results to the virtual filesystem WITHOUT loading them into context.
+Always make a separate call for each knowledge base you want to search.
 
 Use this when you expect many results (>20) and need to filter iteratively:
-1. Call save_search_results to save up to 1000 results to /search_results.txt
+1. Call save_search_results (once per knowledge base) to save up to 1000 results to /search_results_{knowledge_base_id}.txt
 2. Use bash grep/awk to identify relevant chunks by pattern
 3. Use dynamic get_content tools to load only the specific chunks you need
 
@@ -5107,40 +5270,49 @@ SCORE: ...
 ---CONTENT START---
 (content or placeholder)
 ---CONTENT END---`,
-    inputSchema: import_zod7.z.object({
-      knowledge_base_ids: ctxEnum,
-      query: import_zod7.z.string().describe("Search query"),
-      searchMethod: import_zod7.z.enum(["hybrid", "keyword", "semantic"]).default("hybrid"),
-      limit: import_zod7.z.number().max(1e3).default(100).describe("Max results to save (max 1000)"),
-      includeContent: import_zod7.z.boolean().default(true).describe(
+    inputSchema: import_zod6.z.object({
+      knowledge_base_id: import_zod6.z.enum(contexts.map((c) => c.id)).describe(
+        contexts.map(
+          (c) => `<knowledge_base id="${c.id}" name="${c.name}">${c.description}</knowledge_base>`
+        ).join("\n")
+      ),
+      query: import_zod6.z.string().describe("Search query"),
+      searchMethod: import_zod6.z.enum(["hybrid", "keyword", "semantic"]).default("hybrid"),
+      limit: import_zod6.z.number().max(1e3).default(100).describe("Max results to save (max 1000)"),
+      includeContent: import_zod6.z.boolean().default(true).describe(
         "Whether to include chunk text in the saved file. False saves tokens \u2014 use true only if you need to grep content."
       )
     }),
-    execute: async ({ query, knowledge_base_ids, searchMethod, limit, includeContent }) => {
-      const ctxList = resolveContexts(knowledge_base_ids, contexts);
-      const results = await Promise.all(
-        ctxList.map(async (ctx) => {
-          try {
-            const { chunks: chunks2 } = await ctx.search({
-              query,
-              method: mapSearchMethod(searchMethod ?? "hybrid"),
-              limit: Math.min(limit ?? 100, 1e3),
-              page: 1,
-              itemFilters: [],
-              chunkFilters: [],
-              sort: { field: "updatedAt", direction: "desc" },
-              user,
-              role,
-              trigger: "tool"
-            });
-            return chunks2;
-          } catch (err) {
-            console.error(`[EXULU] save_search_results failed for context "${ctx.id}":`, err);
-            return [];
-          }
-        })
-      );
-      const chunks = results.flat();
+    execute: async ({ query, knowledge_base_id, searchMethod, limit, includeContent }) => {
+      const [ctx] = resolveContexts([knowledge_base_id], contexts);
+      const contextItemIds = preselectedItemsByContext?.get(knowledge_base_id);
+      if (preselectedItemsByContext && contextItemIds === void 0) {
+        return JSON.stringify({
+          success: true,
+          results_count: 0,
+          message: `Context "${knowledge_base_id}" not in preselected scope \u2014 skipped.`
+        });
+      }
+      const itemFilters = Array.isArray(contextItemIds) ? [{ id: { in: contextItemIds } }] : [];
+      let chunks = [];
+      try {
+        const result = await ctx.search({
+          query,
+          method: mapSearchMethod(searchMethod ?? "hybrid"),
+          limit: Math.min(limit ?? 100, 1e3),
+          page: 1,
+          itemFilters,
+          chunkFilters: [],
+          sort: { field: "updatedAt", direction: "desc" },
+          user,
+          role,
+          trigger: "tool"
+        });
+        chunks = result.chunks;
+      } catch (err) {
+        console.error(`[EXULU] save_search_results failed for context "${ctx.id}":`, err);
+      }
+      const fileName = `search_results_${ctx.id}.txt`;
       const fileContent = chunks.map(
         (chunk, i) => `### RESULT ${i + 1} ###
 ITEM_NAME: ${chunk.item_name}
@@ -5155,14 +5327,14 @@ ${includeContent && chunk.chunk_content ? chunk.chunk_content : "[use includeCon
 `
       ).join("\n");
       await updateVirtualFiles([
-        { path: "search_results.txt", content: fileContent },
+        { path: fileName, content: fileContent },
         {
-          path: "search_metadata.json",
+          path: `search_metadata_${ctx.id}.json`,
           content: JSON.stringify({
             query,
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             results_count: chunks.length,
-            contexts: ctxList.map((c) => c.id),
+            context: ctx.id,
             method: searchMethod
           })
         }
@@ -5170,11 +5342,11 @@ ${includeContent && chunk.chunk_content ? chunk.chunk_content : "[use includeCon
       return JSON.stringify({
         success: true,
         results_count: chunks.length,
-        message: `Saved ${chunks.length} results to /search_results.txt`,
+        message: `Saved ${chunks.length} results to /${fileName}`,
         grep_examples: [
-          "grep -i 'keyword' search_results.txt | head -20",
-          "grep 'ITEM_NAME:' search_results.txt",
-          "grep -B 5 'pattern' search_results.txt | grep 'CHUNK_ID:'"
+          `grep -i 'keyword' ${fileName} | head -20`,
+          `grep 'ITEM_NAME:' ${fileName}`,
+          `grep -B 5 'pattern' ${fileName} | grep 'CHUNK_ID:'`
         ]
       });
     }
@@ -5196,9 +5368,10 @@ another component will do that based on what you retrieve.
 Always respond in the SAME LANGUAGE as the user's query.
 Always write search queries in the SAME LANGUAGE as the user's query \u2014 do NOT translate to English.
 
-SEARCH APPROACH \u2014 go wide first, then deep:
-1. First step: search broadly across all sources the system instructions indicate \u2014 do NOT
-   pre-filter to a single context on step 1.
+SEARCH APPROACH \u2014 one knowledge base at a time, then go deep:
+1. search_content and save_search_results accept ONE knowledge base per call. Make a separate
+   call for each knowledge base you need to cover \u2014 never skip one. Search all relevant
+   knowledge bases before concluding, even if the first one already returned good results.
 2. After finding a relevant document, use get_more_content_from_{item} dynamic tools to load
    additional pages/sections. The specific answer is often NOT in the first retrieved chunk \u2014
    always explore adjacent content before concluding.
@@ -5214,9 +5387,8 @@ var AGGREGATE_INSTRUCTIONS = `
 ${BASE_INSTRUCTIONS}
 
 STRATEGY: This is a COUNTING or AGGREGATION query.
-- Use count_items_or_chunks exclusively
+- Use count_items_or_chunks exclusively \u2014 it accepts multiple knowledge bases in one call for efficiency
 - Do NOT use search_content \u2014 it loads unnecessary data
-- Search ALL contexts in parallel in a single tool call
 - Return immediately after counting \u2014 one step is sufficient
 - If the count needs a content filter, use content_query parameter
 `.trim();
@@ -5249,9 +5421,23 @@ Search language:
 - Always write search queries in the SAME LANGUAGE as the user's query.
 - Do NOT translate the query to English \u2014 the documents are indexed in their original language.
 
-Step 1 \u2014 wide hybrid search (includeContent: true, limit 10):
-- Search broadly across all sources per the system instructions \u2014 do not limit to 1 context.
-- This gives you the best results from every relevant source at once.
+Step 1 \u2014 match the opening move to what the query actually needs:
+
+  Query references a SPECIFIC NAMED DOCUMENT (product manual, titled report, named file):
+  \u2192 ALWAYS start with search_items_by_name \u2014 searches document name/title directly
+  \u2192 Only proceed to load content if the document is found
+
+  Query asks WHETHER a topic EXISTS or WHAT documents cover a topic (no specific title given):
+  \u2192 search_content with includeContent: false
+  \u2192 Returns matching document names without loading chunk text \u2014 efficient and precise
+  \u2192 Load content with dynamic get_{item}_page_{n}_content tools only if needed in step 2
+
+  Query asks for CONTENT itself (procedures, parameters, explanations, how-to):
+  \u2192 search_content with includeContent: true, limit 20, searchMethod: "hybrid"
+  \u2192 Make one call per knowledge base \u2014 search each separately before concluding
+
+  Query provides an EXACT TERM (error code, product code, ID, parameter name):
+  \u2192 search_content with searchMethod: "keyword"
 
 Step 2+ \u2014 depth and follow-up:
 - For any relevant document found with fewer than 5 chunks, use get_more_content_from_{item}
@@ -5261,19 +5447,9 @@ Step 2+ \u2014 depth and follow-up:
 - Try alternative phrasings if the first query doesn't surface the right answer.
 
 Product-specific filtering:
-- When the query mentions a specific product (e.g., "FST-3", "ECO"), you MAY use
-  item_names: ["<product>"] on a follow-up search to narrow results \u2014 but only after an initial
+- When the query mentions a specific named entity (product, model, version), you MAY use
+  item_names: ["<entity>"] on a follow-up search to narrow results \u2014 but only after an initial
   wide search. Never start with item_names filtering alone.
-
-Two-step approach \u2014 use includeContent: false first:
-- Only when you expect many results (>20) and need to identify the right document first.
-- Step 1: search_content with includeContent: false \u2192 see which documents/chunks match.
-- Step 2: use dynamic get_{item}_page_{n}_content tools to load specific pages.
-
-Search method selection:
-- hybrid (default): best for most queries
-- keyword: exact product codes, document IDs, error codes
-- semantic: conceptual questions, synonyms, paraphrasing
 `.trim();
 var EXPLORATORY_INSTRUCTIONS = `
 ${BASE_INSTRUCTIONS}
@@ -5281,13 +5457,13 @@ ${BASE_INSTRUCTIONS}
 STRATEGY: This is an EXPLORATORY query \u2014 general question requiring broad search.
 
 Recommended approach:
-1. Start with a wide hybrid search across all relevant contexts (includeContent: true, limit: 10)
+1. Search each relevant knowledge base separately with hybrid search (includeContent: true, limit: 20) \u2014 one call per knowledge base
 2. If results are insufficient: try alternative search terms or different search method
 3. Use save_search_results + bash grep when you need to scan many results without context bloat
 4. Use dynamic get_more_content_from_{item} tools to read adjacent pages when a relevant item is found
 
 When to declare done:
-- You have retrieved chunks that cover the key aspects of the query
+- You have retrieved chunks that cover the key aspects of the query from all relevant knowledge bases
 - OR you have tried 3+ different search strategies and found nothing relevant
 
 Do NOT use count_items_or_chunks for exploratory queries \u2014 the user wants content, not statistics.
@@ -5302,7 +5478,7 @@ var STRATEGIES = {
   },
   list: {
     queryType: "list",
-    stepBudget: 2,
+    stepBudget: 3,
     retrieval_tools: ["count_items_or_chunks", "search_items_by_name", "search_content"],
     include_bash: false,
     instructions: LIST_INSTRUCTIONS
@@ -5316,7 +5492,7 @@ var STRATEGIES = {
   },
   exploratory: {
     queryType: "exploratory",
-    stepBudget: 4,
+    stepBudget: 5,
     retrieval_tools: [
       "count_items_or_chunks",
       "search_items_by_name",
@@ -5330,28 +5506,10 @@ var STRATEGIES = {
 
 // ee/agentic-retrieval/v3/agent-loop.ts
 var import_ai5 = require("ai");
-var import_zod9 = require("zod");
-
-// src/utils/with-retry.ts
-async function withRetry(generateFn, maxRetries = 3) {
-  let lastError;
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await generateFn();
-    } catch (error) {
-      lastError = error;
-      console.error(`[EXULU] generateText attempt ${attempt} failed:`, error);
-      if (attempt === maxRetries) {
-        throw error;
-      }
-      await new Promise((resolve4) => setTimeout(resolve4, Math.pow(2, attempt) * 1e3));
-    }
-  }
-  throw lastError;
-}
+var import_zod8 = require("zod");
 
 // ee/agentic-retrieval/v3/dynamic-tools.ts
-var import_zod8 = require("zod");
+var import_zod7 = require("zod");
 var import_ai4 = require("ai");
 async function createDynamicTools(chunks, hadExcludedContent) {
   const { db: db2 } = await postgresClient();
@@ -5370,9 +5528,9 @@ async function createDynamicTools(chunks, hadExcludedContent) {
           const capturedChunk = chunk;
           tools[browseToolName] = (0, import_ai4.tool)({
             description: `"${chunk.item_name}" has ${total} pages/chunks. Use this to read a range of pages from it.`,
-            inputSchema: import_zod8.z.object({
-              from_index: import_zod8.z.number().min(1).default(1).describe("Starting chunk index (1-based)"),
-              to_index: import_zod8.z.number().max(total).describe(`Ending chunk index (max ${total})`)
+            inputSchema: import_zod7.z.object({
+              from_index: import_zod7.z.number().min(1).default(1).describe("Starting chunk index (1-based)"),
+              to_index: import_zod7.z.number().max(total).describe(`Ending chunk index (max ${total})`)
             }),
             execute: async ({ from_index, to_index }) => {
               const { db: db22 } = await postgresClient();
@@ -5401,8 +5559,8 @@ async function createDynamicTools(chunks, hadExcludedContent) {
         const capturedChunk = chunk;
         tools[pageToolName] = (0, import_ai4.tool)({
           description: `Load the full text of page ${chunk.chunk_index} from "${chunk.item_name}"`,
-          inputSchema: import_zod8.z.object({
-            reasoning: import_zod8.z.string().describe("Why you need this specific page's content")
+          inputSchema: import_zod7.z.object({
+            reasoning: import_zod7.z.string().describe("Why you need this specific page's content")
           }),
           execute: async () => {
             const { db: db22 } = await postgresClient();
@@ -5429,8 +5587,8 @@ async function createDynamicTools(chunks, hadExcludedContent) {
 var FINISH_TOOL_NAME = "finish_retrieval";
 var finishRetrievalTool = (0, import_ai5.tool)({
   description: "Call this tool when you have retrieved sufficient information and no further searches are needed. You MUST call this tool to signal that retrieval is complete \u2014 do not write a text conclusion.",
-  inputSchema: import_zod9.z.object({
-    reasoning: import_zod9.z.string().describe("One sentence explaining why retrieval is complete")
+  inputSchema: import_zod8.z.object({
+    reasoning: import_zod8.z.string().describe("One sentence explaining why retrieval is complete")
   }),
   execute: async ({ reasoning }) => JSON.stringify({ finished: true, reasoning })
 });
@@ -5463,7 +5621,7 @@ function extractChunksFromToolResults(toolResults) {
   return chunks;
 }
 async function* runAgentLoop(params) {
-  const { query, strategy, tools, model, reranker, contextGuidance, customInstructions, onStepComplete } = params;
+  const { query, strategy, tools, model, reranker, contextGuidance, customInstructions, sessionId, onStepComplete, onTrajectoryStep } = params;
   const output = {
     steps: [],
     reasoning: [],
@@ -5519,6 +5677,13 @@ ${customInstructions}` : ""
     }
     messages.push(...result.response.messages);
     let stepChunks = extractChunksFromToolResults(result.toolResults);
+    const seenChunkIds = /* @__PURE__ */ new Set();
+    stepChunks = stepChunks.filter((c) => {
+      if (!c.chunk_id) return true;
+      if (seenChunkIds.has(c.chunk_id)) return false;
+      seenChunkIds.add(c.chunk_id);
+      return true;
+    });
     const hadExcludedContent = result.toolCalls?.some(
       (tc) => tc.toolName === "search_content" && tc.input?.includeContent === false || tc.toolName === "search_items_by_name"
     );
@@ -5528,9 +5693,15 @@ ${customInstructions}` : ""
     }
     const newDynamic = await createDynamicTools(stepChunks, hadExcludedContent);
     Object.assign(dynamicTools, newDynamic);
+    if (sessionId && Object.keys(newDynamic).length > 0) {
+      registerSessionTools(sessionId, newDynamic);
+    }
     forceDepthExploration = stepChunks.length > 0 && stepChunks.length < 5 && Object.keys(newDynamic).length > 0 && step < strategy.stepBudget - 2;
     for (const tc of result.toolCalls ?? []) {
       if (SEARCH_TOOL_NAMES.has(tc.toolName)) {
+        if (tc.input?.knowledge_base_id) {
+          searchedContextIds.add(tc.input.knowledge_base_id);
+        }
         for (const id of tc.input?.knowledge_base_ids ?? []) {
           searchedContextIds.add(id);
         }
@@ -5565,9 +5736,30 @@ ${customInstructions}` : ""
         output: stepChunks
       })) ?? []
     });
-    output.chunks.push(...stepChunks);
+    const existingChunkIds = new Set(output.chunks.map((c) => c.chunk_id).filter(Boolean));
+    output.chunks.push(...stepChunks.filter((c) => !c.chunk_id || !existingChunkIds.has(c.chunk_id)));
     output.usage.push(result.usage);
     onStepComplete?.(stepRecord);
+    if (onTrajectoryStep) {
+      const toolResultMap = /* @__PURE__ */ new Map();
+      for (const tr of result.toolResults ?? []) {
+        toolResultMap.set(tr.toolCallId, tr.output ?? tr.result);
+      }
+      onTrajectoryStep({
+        stepNumber: step + 1,
+        systemPrompt: stepSystemPrompt,
+        text: result.text ?? "",
+        toolCalls: result.toolCalls?.map((tc) => ({
+          name: tc.toolName,
+          id: tc.toolCallId,
+          input: tc.input,
+          output: toolResultMap.get(tc.toolCallId)
+        })) ?? [],
+        chunks: stepChunks,
+        dynamicToolsCreated: Object.keys(newDynamic),
+        tokens: result.usage?.totalTokens ?? 0
+      });
+    }
     yield { ...output };
     const calledFinish = result.toolCalls?.some(
       (tc) => tc.toolName === FINISH_TOOL_NAME
@@ -5585,21 +5777,23 @@ ${customInstructions}` : ""
 }
 
 // ee/agentic-retrieval/v3/trajectory.ts
-var fs2 = __toESM(require("fs/promises"), 1);
+var fs = __toESM(require("fs/promises"), 1);
 var path = __toESM(require("path"), 1);
 var trajectoryRegistry = {
   lastFile: void 0
 };
 var TrajectoryLogger = class {
   data;
+  richSteps = [];
   startTime = Date.now();
   logDir;
-  constructor(query, classification, logDir = path.join(process.cwd(), "ee/agentic-retrieval/logs")) {
+  constructor(query, classification, logDir = path.join(process.cwd(), "ee/agentic-retrieval/logs"), preselectedItemIds) {
     this.logDir = logDir;
     this.data = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       query,
       classification,
+      preselectedItemIds: preselectedItemIds?.length ? preselectedItemIds : void 0,
       steps: [],
       final: {
         total_chunks: 0,
@@ -5620,23 +5814,181 @@ var TrajectoryLogger = class {
       tokens: step.tokens
     });
   }
-  async finalize(output, success, error) {
+  recordRichStep(data) {
+    this.richSteps.push(data);
+  }
+  toMarkdown(durationMs, success, error) {
+    const totalTokens = this.richSteps.reduce((sum, s) => sum + s.tokens, 0);
+    const totalChunks = this.richSteps.reduce((sum, s) => sum + s.chunks.length, 0);
+    const status = success ? "\u2713 Success" : `\u2717 Failed${error ? `: ${error.message}` : ""}`;
+    const lines = [];
+    lines.push(`# Agentic Retrieval \u2014 ${this.data.timestamp}`);
+    lines.push("");
+    lines.push(`**Query:** ${this.data.query}  `);
+    lines.push(
+      `**Duration:** ${(durationMs / 1e3).toFixed(1)}s | **Tokens:** ${totalTokens} | **Status:** ${status}`
+    );
+    lines.push("");
+    lines.push("## Classification");
+    lines.push("");
+    lines.push(`- **Type:** \`${this.data.classification.queryType}\``);
+    lines.push(`- **Language:** \`${this.data.classification.language}\``);
+    const suggested = this.data.classification.suggestedContextIds;
+    lines.push(
+      `- **Suggested contexts:** ${suggested.length > 0 ? suggested.map((id) => `\`${id}\``).join(", ") : "*(all)*"}`
+    );
+    if (this.data.preselectedItemIds?.length) {
+      lines.push(
+        `- **Preselected item IDs:** ${this.data.preselectedItemIds.map((id) => `\`${id}\``).join(", ")}`
+      );
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    const firstStep = this.richSteps[0];
+    if (firstStep) {
+      lines.push("## System Prompt");
+      lines.push("");
+      lines.push("<details>");
+      lines.push("<summary>View system prompt</summary>");
+      lines.push("");
+      lines.push("```");
+      lines.push(firstStep.systemPrompt);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    for (const step of this.richSteps) {
+      const toolLabel = step.toolCalls.map((tc) => `\`${tc.name}\``).join(", ") || "*(no tool calls)*";
+      lines.push(`## Step ${step.stepNumber} \u2014 ${toolLabel}`);
+      lines.push("");
+      const dynLabel = step.dynamicToolsCreated.length > 0 ? step.dynamicToolsCreated.map((t) => `\`${t}\``).join(", ") : "none";
+      lines.push(
+        `**Tokens:** ${step.tokens} | **Chunks retrieved:** ${step.chunks.length} | **Dynamic tools created:** ${dynLabel}`
+      );
+      lines.push("");
+      if (step.text) {
+        lines.push("### Reasoning");
+        lines.push("");
+        lines.push(step.text);
+        lines.push("");
+      }
+      if (step.toolCalls.length > 0) {
+        lines.push("### Tool Calls");
+        lines.push("");
+        for (const [i, tc] of step.toolCalls.entries()) {
+          lines.push(`#### ${i + 1}. \`${tc.name}\``);
+          lines.push("");
+          lines.push("**Input:**");
+          lines.push("```json");
+          lines.push(JSON.stringify(tc.input, null, 2));
+          lines.push("```");
+          lines.push("");
+          if (tc.output !== void 0) {
+            let parsedOutput;
+            try {
+              parsedOutput = typeof tc.output === "string" ? JSON.parse(tc.output) : tc.output;
+            } catch {
+              parsedOutput = tc.output;
+            }
+            const outputStr = JSON.stringify(parsedOutput, null, 2);
+            const truncated = outputStr.length > 2e3;
+            lines.push("**Output:**");
+            lines.push("```json");
+            lines.push(truncated ? `${outputStr.slice(0, 2e3)}
+\u2026 (truncated)` : outputStr);
+            lines.push("```");
+            lines.push("");
+          }
+        }
+      }
+      if (step.chunks.length > 0) {
+        lines.push("### Chunks Retrieved");
+        lines.push("");
+        lines.push("| # | Item | Context | Chunk | Score |");
+        lines.push("|---|------|---------|-------|-------|");
+        for (const [i, c] of step.chunks.entries()) {
+          const score = c.metadata?.hybrid_score ?? c.metadata?.cosine_distance ?? c.metadata?.fts_rank ?? "\u2014";
+          const scoreStr = typeof score === "number" ? score.toFixed(4) : String(score);
+          lines.push(
+            `| ${i + 1} | ${c.item_name ?? "\u2014"} | \`${c.context}\` | ${c.chunk_index ?? "\u2014"} | ${scoreStr} |`
+          );
+        }
+        lines.push("");
+        const withContent = step.chunks.filter((c) => c.chunk_content);
+        if (withContent.length > 0) {
+          lines.push("<details>");
+          lines.push("<summary>View chunk content</summary>");
+          lines.push("");
+          for (const c of withContent) {
+            lines.push(`**${c.item_name} (chunk ${c.chunk_index}):**`);
+            lines.push("");
+            const content = (c.chunk_content ?? "").trim();
+            lines.push(`> ${content.split("\n").join("\n> ")}`);
+            lines.push("");
+          }
+          lines.push("</details>");
+          lines.push("");
+        }
+      }
+      if (firstStep && step.stepNumber > 1 && step.systemPrompt !== firstStep.systemPrompt) {
+        const addendum = step.systemPrompt.slice(firstStep.systemPrompt.length).trim();
+        if (addendum) {
+          lines.push("<details>");
+          lines.push("<summary>System prompt addendum (this step only)</summary>");
+          lines.push("");
+          lines.push("```");
+          lines.push(addendum);
+          lines.push("```");
+          lines.push("");
+          lines.push("</details>");
+          lines.push("");
+        }
+      }
+      lines.push("---");
+      lines.push("");
+    }
+    lines.push("## Summary");
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("|--------|-------|");
+    lines.push(`| Steps | ${this.richSteps.length} |`);
+    lines.push(`| Total chunks | ${totalChunks} |`);
+    lines.push(`| Total tokens | ${totalTokens} |`);
+    lines.push(`| Duration | ${(durationMs / 1e3).toFixed(1)}s |`);
+    lines.push(`| Status | ${status} |`);
+    if (error) {
+      lines.push(`| Error | ${error.message} |`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  async finalize(output, success, error, writeFiles = false) {
+    const durationMs = Date.now() - this.startTime;
     this.data.final = {
       total_chunks: output.chunks.length,
       total_steps: output.steps.length,
       total_tokens: output.totalTokens,
-      duration_ms: Date.now() - this.startTime,
+      duration_ms: durationMs,
       success,
       error: error?.message
     };
+    if (!writeFiles) return void 0;
     try {
-      await fs2.mkdir(this.logDir, { recursive: true });
-      const filename = `trajectory_${Date.now()}.json`;
-      const fullPath = path.join(this.logDir, filename);
-      await fs2.writeFile(fullPath, JSON.stringify(this.data, null, 2), "utf-8");
-      console.log(`[EXULU] v3 trajectory saved: ${filename}`);
-      trajectoryRegistry.lastFile = fullPath;
-      return fullPath;
+      await fs.mkdir(this.logDir, { recursive: true });
+      const ts = Date.now();
+      const jsonPath = path.join(this.logDir, `trajectory_${ts}.json`);
+      const mdPath = path.join(this.logDir, `trajectory_${ts}.md`);
+      await Promise.all([
+        fs.writeFile(jsonPath, JSON.stringify(this.data, null, 2), "utf-8"),
+        fs.writeFile(mdPath, this.toMarkdown(durationMs, success, error), "utf-8")
+      ]);
+      console.log(`[EXULU] v3 trajectory saved: trajectory_${ts}.json + trajectory_${ts}.md`);
+      trajectoryRegistry.lastFile = jsonPath;
+      return jsonPath;
     } catch (e) {
       console.error("[EXULU] v3 failed to write trajectory:", e);
       return void 0;
@@ -5653,14 +6005,19 @@ async function* executeV3({
   model,
   user,
   role,
-  customInstructions
+  customInstructions,
+  logTrajectory,
+  sessionId,
+  preselectedItemIds
 }) {
+  const preselectedByContext = preselectedItemIds?.length ? parseGlobalItemIds(preselectedItemIds) : void 0;
+  const activeContexts = preselectedByContext?.size ? contexts.filter((c) => preselectedByContext.has(c.id)) : contexts;
   console.log("[EXULU] v3 \u2014 sampling contexts");
-  const samples = await sampler.getSamples(contexts, user, role);
+  const samples = await sampler.getSamples(activeContexts, user, role);
   console.log("[EXULU] v3 \u2014 classifying query");
   let classification;
   try {
-    classification = await classifyQuery(query, contexts, samples, model);
+    classification = await classifyQuery(query, activeContexts, samples, model);
   } catch (err) {
     console.warn("[EXULU] v3 \u2014 classification failed, falling back to exploratory:", err);
     classification = {
@@ -5672,15 +6029,18 @@ async function* executeV3({
   console.log("[EXULU] v3 \u2014 classified as:", classification);
   const strategy = STRATEGIES[classification.queryType];
   const suggestedIds = classification.suggestedContextIds;
-  const fallbackIds = contexts.filter((c) => !suggestedIds.includes(c.id)).map((c) => c.id);
-  const contextGuidance = suggestedIds.length > 0 ? `Suggested priority contexts: [${suggestedIds.join(", ")}]. Also available: [${fallbackIds.join(", ")}]. Custom instructions may require searching additional or all contexts \u2014 follow them.` : `All contexts available: [${contexts.map((c) => c.id).join(", ")}].`;
+  const fallbackIds = activeContexts.filter((c) => !suggestedIds.includes(c.id)).map((c) => c.id);
+  const contextBase = suggestedIds.length > 0 ? `Suggested priority contexts: [${suggestedIds.join(", ")}]. Also available: [${fallbackIds.join(", ")}]. Custom instructions may require searching additional or all contexts \u2014 follow them.` : `All contexts available: [${activeContexts.map((c) => c.id).join(", ")}].`;
+  const preselectedNote = preselectedByContext?.size ? `
+SCOPE CONSTRAINT: Retrieval is scoped to preselected items/contexts. Per context: ${[...preselectedByContext.entries()].map(([ctx, ids]) => ids === null ? `${ctx} (full context)` : `${ctx} (${ids.length} item${ids.length === 1 ? "" : "s"})`).join(", ")}. All tools enforce this scope automatically. For full-context entries you may search freely; for item-restricted entries do NOT use search_items_by_name for discovery \u2014 go directly to search_content or save_search_results.` : "";
+  const contextGuidance = contextBase + preselectedNote;
   const bashToolkit = await (0, import_bash_tool.createBashTool)({ files: {} });
   const retrievalTools = createRetrievalTools({
-    contexts,
-    // ALL contexts — agent decides which to search based on context guidance
+    contexts: activeContexts,
     user,
     role,
-    updateVirtualFiles: (files) => bashToolkit.sandbox.writeFiles(files)
+    updateVirtualFiles: (files) => bashToolkit.sandbox.writeFiles(files),
+    preselectedItemsByContext: preselectedByContext
   });
   const activeTools = {};
   for (const name of strategy.retrieval_tools) {
@@ -5691,7 +6051,7 @@ async function* executeV3({
   if (strategy.include_bash) {
     Object.assign(activeTools, bashToolkit.tools);
   }
-  const trajectory = new TrajectoryLogger(query, classification);
+  const trajectory = new TrajectoryLogger(query, classification, void 0, preselectedItemIds);
   let finalOutput;
   let executionError;
   try {
@@ -5704,7 +6064,9 @@ async function* executeV3({
       contextGuidance,
       customInstructions,
       classification,
-      onStepComplete: (step) => trajectory.recordStep(step)
+      sessionId,
+      onStepComplete: (step) => trajectory.recordStep(step),
+      onTrajectoryStep: (data) => trajectory.recordRichStep(data)
     })) {
       finalOutput = output;
       yield output;
@@ -5715,7 +6077,7 @@ async function* executeV3({
     throw err;
   } finally {
     if (finalOutput) {
-      const trajectoryFile = await trajectory.finalize(finalOutput, !executionError, executionError);
+      const trajectoryFile = await trajectory.finalize(finalOutput, !executionError, executionError, logTrajectory);
       if (trajectoryFile) {
         finalOutput.trajectoryFile = trajectoryFile;
       }
@@ -5728,7 +6090,8 @@ function createAgenticRetrievalToolV3({
   rerankers,
   user,
   role,
-  model
+  model,
+  preselectedItemIds
 }) {
   const license = checkLicense();
   if (!license["agentic-retrieval"]) {
@@ -5756,6 +6119,12 @@ function createAgenticRetrievalToolV3({
         type: "string",
         default: "none"
       },
+      {
+        name: "managed_context",
+        description: "Makes sure the user defines which items from which contexts the agentic retrieval tool will search in",
+        type: "boolean",
+        default: false
+      },
       {
         name: "reasoning_model",
         description: "By default the agentic retrieval tool uses the model from the agent calling the tool, but you can overwrite this here for the reasoning phase",
@@ -5768,6 +6137,18 @@ function createAgenticRetrievalToolV3({
         type: "string",
         default: ""
       },
+      {
+        name: "require_preselected_contexts",
+        description: "Require the user to preselect contexts before executing the tool, meaning the user will be asked to select the contexts they want to search in",
+        type: "boolean",
+        default: false
+      },
+      {
+        name: "log_trajectories",
+        description: "Save a detailed markdown + JSON log of every retrieval execution to disk. Useful for debugging and evaluation.",
+        type: "boolean",
+        default: false
+      },
       ...contexts.map((ctx) => ({
         name: ctx.id,
         description: `Enable search in "${ctx.name}". ${ctx.description}`,
@@ -5775,32 +6156,61 @@ function createAgenticRetrievalToolV3({
         default: true
       }))
     ],
-    inputSchema: import_zod10.z.object({
-      query: import_zod10.z.string().describe("The question or query to answer"),
-      userInstructions: import_zod10.z.string().optional().describe("Additional instructions from the user to guide retrieval")
+    inputSchema: import_zod9.z.object({
+      query: import_zod9.z.string().describe("The question or query to answer"),
+      userInstructions: import_zod9.z.string().optional().describe("Additional instructions from the user to guide retrieval"),
+      confirmedContextIds: import_zod9.z.array(import_zod9.z.string()).optional().describe(
+        "Knowledge base IDs explicitly confirmed by the user to be used in the retrieval. When presen only searches these contexts. "
+      )
     }),
     execute: async function* ({
       query,
       userInstructions,
-      toolVariablesConfig
+      confirmedContextIds,
+      toolVariablesConfig,
+      sessionID
     }) {
       if (!model) {
-        throw new Error("Model is required for executing the agentic retrieval tool");
+        yield { result: "Model is required for executing the agentic retrieval tool" };
+        return;
       }
       let activeContexts = contexts;
       let configuredReranker;
       let configInstructions = "";
+      let logTrajectory = false;
+      let requiresPreselectedContexts = false;
+      let managedContextEnabled = false;
       if (toolVariablesConfig) {
         configInstructions = toolVariablesConfig["instructions"] ?? "";
+        logTrajectory = toolVariablesConfig["log_trajectories"] === true || toolVariablesConfig["log_trajectories"] === "true";
+        managedContextEnabled = toolVariablesConfig["managed_context"] === true || toolVariablesConfig["managed_context"] === "true";
         activeContexts = contexts.filter(
           (ctx) => toolVariablesConfig[ctx.id] === true || toolVariablesConfig[ctx.id] === "true" || toolVariablesConfig[ctx.id] === 1
         );
         if (activeContexts.length === 0) activeContexts = contexts;
+        requiresPreselectedContexts = toolVariablesConfig["require_preselected_contexts"] === true || toolVariablesConfig["require_preselected_contexts"] === "true";
         const rerankerId = toolVariablesConfig["reranker"];
         if (rerankerId && rerankerId !== "none") {
           configuredReranker = rerankers.find((r) => r.id === rerankerId);
         }
       }
+      console.log("[EXULU] Managed context enabled:", managedContextEnabled);
+      console.log("[EXULU] Preselected item IDs:", preselectedItemIds);
+      if (managedContextEnabled && !preselectedItemIds?.length) {
+        console.log("[EXULU] Managed context was enabled for the agentic retrieval tool. This means that the user must preselect items that the agentic retrieval tool will search in, please notify the user to preselect items before executing the tool.");
+        yield { result: "Managed context was enabled for the agentic retrieval tool. This means that the user must preselect items that the agentic retrieval tool will search in, please notify the user to preselect items before executing the tool." };
+        return;
+      }
+      if (requiresPreselectedContexts && !confirmedContextIds?.length && !preselectedItemIds?.length) {
+        console.log("[EXULU] The user must choose between the available contexts before executing the tool. The available contexts are: " + activeContexts.map((c) => c.id).join(", ") + ". If the question_ask tool is available use that to ask the user which contexts they want to search in, otherwise just ask them in plain text.");
+        yield { result: "The user must choose between the available contexts before executing the tool, the available contexts are: " + activeContexts.map((c) => c.id).join(", ") + ". If the question_ask tool is available use that to ask the user which contexts they want to search in, otherwise just ask them in plain text." };
+        return;
+      }
+      if (confirmedContextIds?.length) {
+        const confirmed = new Set(confirmedContextIds);
+        const filtered = activeContexts.filter((c) => confirmed.has(c.id));
+        if (filtered.length > 0) activeContexts = filtered;
+      }
       const combinedInstructions = [
         configInstructions ? `Configuration instructions: ${configInstructions}` : "",
         adminInstructions ? `Admin instructions: ${adminInstructions}` : "",
@@ -5813,10 +6223,14 @@ function createAgenticRetrievalToolV3({
         model,
         user,
         role,
-        customInstructions: combinedInstructions || void 0
+        customInstructions: combinedInstructions || void 0,
+        logTrajectory,
+        sessionId: sessionID,
+        preselectedItemIds
       })) {
         yield { result: JSON.stringify(output) };
       }
+      return;
     }
   });
 }
@@ -5971,9 +6385,9 @@ var addProviderFields = async (args, requestedFields, providers, result, tools,
     if (result.tools) {
       result.tools = await Promise.all(
         result.tools.map(
-          async (tool6) => {
+          async (tool5) => {
             let hydrated;
-            if (tool6.id === "agentic_context_search") {
+            if (tool5.id === "agentic_context_search") {
               const instance2 = createAgenticRetrievalToolV3({
                 contexts: [],
                 rerankers: [],
@@ -5989,23 +6403,23 @@ var addProviderFields = async (args, requestedFields, providers, result, tools,
                 name: instance2.name,
                 description: instance2.description,
                 category: instance2.category,
-                config: tool6.config
+                config: tool5.config
               };
             }
-            if (tool6.type === "agent") {
-              if (tool6.id === result.id) {
+            if (tool5.type === "agent") {
+              if (tool5.id === result.id) {
                 return null;
               }
-              const instance2 = await exuluApp.get().agent(tool6.id);
+              const instance2 = await exuluApp.get().agent(tool5.id);
               if (!instance2) {
                 throw new Error(
-                  "Trying to load a tool of type 'agent', but the associated agent with id " + tool6.id + " was not found in the database."
+                  "Trying to load a tool of type 'agent', but the associated agent with id " + tool5.id + " was not found in the database."
                 );
               }
               const provider2 = providers.find((a) => a.id === instance2.provider);
               if (!provider2) {
                 throw new Error(
-                  "Trying to load a tool of type 'agent', but the associated agent with id " + tool6.id + " does not have a provider set for it."
+                  "Trying to load a tool of type 'agent', but the associated agent with id " + tool5.id + " does not have a provider set for it."
                 );
               }
               const hasAccessToAgent = await checkRecordAccess(instance2, "read", user);
@@ -6014,13 +6428,13 @@ var addProviderFields = async (args, requestedFields, providers, result, tools,
               }
               hydrated = await provider2.tool(instance2.id, providers, contexts, rerankers);
             } else {
-              hydrated = tools.find((t) => t.id === tool6.id);
+              hydrated = tools.find((t) => t.id === tool5.id);
             }
             const hydratedTool = {
-              ...tool6,
+              ...tool5,
               name: hydrated?.name || "",
               description: hydrated?.description || "",
-              category: tool6?.category || "default"
+              category: tool5?.category || "default"
             };
             console.log("[EXULU] hydratedTool", hydratedTool);
             return hydratedTool;
@@ -6038,7 +6452,7 @@ var addProviderFields = async (args, requestedFields, providers, result, tools,
           result.tools.unshift(projectTool);
         }
       }
-      result.tools = result.tools.filter((tool6) => tool6 !== null);
+      result.tools = result.tools.filter((tool5) => tool5 !== null);
     } else {
       result.tools = [];
     }
@@ -7544,7 +7958,7 @@ var getEnabledTools = async (agent, allExuluTools, allContexts, allRerankers, di
   }
   console.log("[EXULU] available tools", enabledTools?.length);
   console.log("[EXULU] disabled tools", disabledTools?.length);
-  enabledTools = enabledTools.filter((tool6) => !disabledTools.includes(tool6.id));
+  enabledTools = enabledTools.filter((tool5) => !disabledTools.includes(tool5.id));
   return enabledTools;
 };
 
@@ -7689,7 +8103,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
             );
             if (attempt < retries) {
               const backoffMs = 500 * Math.pow(2, attempt - 1);
-              await new Promise((resolve4) => setTimeout(resolve4, backoffMs));
+              await new Promise((resolve3) => setTimeout(resolve3, backoffMs));
             }
           }
         }
@@ -7892,7 +8306,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
               } = await validateWorkflowPayload(data, providers);
               const retries2 = 3;
               let attempts = 0;
-              const promise = new Promise(async (resolve4, reject) => {
+              const promise = new Promise(async (resolve3, reject) => {
                 while (attempts < retries2) {
                   try {
                     const messages2 = await processUiMessagesFlow({
@@ -7907,7 +8321,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
                       config,
                       variables: data.inputs
                     });
-                    resolve4(messages2);
+                    resolve3(messages2);
                     break;
                   } catch (error) {
                     console.error(
@@ -7918,7 +8332,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
                     if (attempts >= retries2) {
                       reject(new Error(error instanceof Error ? error.message : String(error)));
                     }
-                    await new Promise((resolve5) => setTimeout((resolve6) => resolve6(true), 2e3));
+                    await new Promise((resolve4) => setTimeout((resolve5) => resolve5(true), 2e3));
                   }
                 }
               });
@@ -7968,7 +8382,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
               } = await validateEvalPayload(data, providers);
               const retries2 = 3;
               let attempts = 0;
-              const promise = new Promise(async (resolve4, reject) => {
+              const promise = new Promise(async (resolve3, reject) => {
                 while (attempts < retries2) {
                   try {
                     const messages2 = await processUiMessagesFlow({
@@ -7982,7 +8396,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
                       tools,
                       config
                     });
-                    resolve4(messages2);
+                    resolve3(messages2);
                     break;
                   } catch (error) {
                     console.error(
@@ -7993,7 +8407,7 @@ var createWorkers = async (providers, queues2, config, contexts, rerankers, eval
                     if (attempts >= retries2) {
                       reject(new Error(error instanceof Error ? error.message : String(error)));
                     }
-                    await new Promise((resolve5) => setTimeout((resolve6) => resolve6(true), 2e3));
+                    await new Promise((resolve4) => setTimeout((resolve5) => resolve5(true), 2e3));
                   }
                 }
               });
@@ -8468,7 +8882,7 @@ var pollJobResult = async ({
     attempts++;
     const job = await import_bullmq3.Job.fromId(queue.queue, jobId);
     if (!job) {
-      await new Promise((resolve4) => setTimeout((resolve5) => resolve5(true), 2e3));
+      await new Promise((resolve3) => setTimeout((resolve4) => resolve4(true), 2e3));
       continue;
     }
     const elapsedTime = Date.now() - startTime;
@@ -8498,7 +8912,7 @@ var pollJobResult = async ({
       console.log(`[EXULU] eval function ${job.id} result: ${result}`);
       break;
     }
-    await new Promise((resolve4) => setTimeout(() => resolve4(true), 2e3));
+    await new Promise((resolve3) => setTimeout(() => resolve3(true), 2e3));
   }
   return result;
 };
@@ -8606,7 +9020,7 @@ var processUiMessagesFlow = async ({
       label: agent.name,
       trigger: "agent"
     };
-    messageHistory = await new Promise(async (resolve4, reject) => {
+    messageHistory = await new Promise(async (resolve3, reject) => {
       const startTime = Date.now();
       try {
         const result = await provider.generateStream({
@@ -8614,7 +9028,7 @@ var processUiMessagesFlow = async ({
           rerankers,
           agent,
           user,
-          approvedTools: tools.map((tool6) => "tool-" + sanitizeToolName(tool6.name)),
+          approvedTools: tools.map((tool5) => "tool-" + sanitizeToolName(tool5.name)),
           instructions: agent.instructions,
           session: void 0,
           previousMessages: messageHistory.messages,
@@ -8683,7 +9097,7 @@ var processUiMessagesFlow = async ({
                 })
               ] : []
             ]);
-            resolve4({
+            resolve3({
               messages,
               metadata: {
                 tokens: {
@@ -9431,7 +9845,7 @@ type PageInfo {
         } = await validateWorkflowPayload(jobData, providers);
         const retries = 3;
         let attempts = 0;
-        const promise = new Promise(async (resolve4, reject) => {
+        const promise = new Promise(async (resolve3, reject) => {
           while (attempts < retries) {
             try {
               const messages2 = await processUiMessagesFlow({
@@ -9446,7 +9860,7 @@ type PageInfo {
                 config,
                 variables: args.variables
               });
-              resolve4(messages2);
+              resolve3(messages2);
               break;
             } catch (error) {
               console.error(
@@ -9460,7 +9874,7 @@ type PageInfo {
               if (attempts >= retries) {
                 reject(error instanceof Error ? error : new Error(String(error)));
               }
-              await new Promise((resolve5) => setTimeout((resolve6) => resolve6(true), 2e3));
+              await new Promise((resolve4) => setTimeout((resolve5) => resolve5(true), 2e3));
             }
           }
         });
@@ -9713,10 +10127,10 @@ type PageInfo {
       contexts.map(async (context2) => {
         let processor = null;
         if (context2.processor) {
-          processor = await new Promise(async (resolve4, reject) => {
+          processor = await new Promise(async (resolve3, reject) => {
             const config2 = context2.processor?.config;
             const queue = await config2?.queue;
-            resolve4({
+            resolve3({
               name: context2.processor.name,
               description: context2.processor.description,
               queue: queue?.queue?.name || void 0,
@@ -9797,10 +10211,10 @@ type PageInfo {
     }
     let processor = null;
     if (data.processor) {
-      processor = await new Promise(async (resolve4, reject) => {
+      processor = await new Promise(async (resolve3, reject) => {
         const config2 = data.processor?.config;
         const queue = await config2?.queue;
-        resolve4({
+        resolve3({
           name: data.processor.name,
           description: data.processor.description,
           queue: queue?.queue?.name || void 0,
@@ -9889,7 +10303,7 @@ type PageInfo {
       })
     );
     let agenticRetrievalTool = void 0;
-    const filtered = agentTools.filter((tool6) => tool6 !== null);
+    const filtered = agentTools.filter((tool5) => tool5 !== null);
     let allTools = [...filtered, ...tools];
     if (contexts?.length) {
       agenticRetrievalTool = createAgenticRetrievalToolV3({
@@ -9907,21 +10321,21 @@ type PageInfo {
     if (search && search.trim()) {
       const searchTerm = search.toLowerCase().trim();
       allTools = allTools.filter(
-        (tool6) => tool6.name?.toLowerCase().includes(searchTerm) || tool6.description?.toLowerCase().includes(searchTerm)
+        (tool5) => tool5.name?.toLowerCase().includes(searchTerm) || tool5.description?.toLowerCase().includes(searchTerm)
       );
     }
     if (category && category.trim()) {
-      allTools = allTools.filter((tool6) => tool6.category === category);
+      allTools = allTools.filter((tool5) => tool5.category === category);
     }
     const total = allTools.length;
     const start = page * limit;
     const end = start + limit;
     const paginatedTools = allTools.slice(start, end);
     return {
-      items: paginatedTools.map((tool6) => {
+      items: paginatedTools.map((tool5) => {
         const object = {};
         requestedFields.forEach((field) => {
-          object[field] = tool6[field];
+          object[field] = tool5[field];
         });
         return object;
       }),
@@ -9931,7 +10345,7 @@ type PageInfo {
     };
   };
   resolvers.Query["toolCategories"] = async () => {
-    const array = tools.map((tool6) => tool6.category).filter((category) => category && typeof category === "string");
+    const array = tools.map((tool5) => tool5.category).filter((category) => category && typeof category === "string");
     array.push("contexts");
     array.push("agents");
     return [...new Set(array)].sort();
@@ -10291,13 +10705,13 @@ type AgentWorldAgent {
 }
 
 // src/exulu/routes.ts
-var import_express5 = require("@as-integrations/express5");
+var import_express52 = require("@as-integrations/express5");
 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_crypto_js7 = __toESM(require("crypto-js"), 1);
 var import_openai = __toESM(require("openai"), 1);
-var import_fs3 = __toESM(require("fs"), 1);
-var import_node_crypto4 = require("crypto");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_node_crypto5 = require("crypto");
 var import_api2 = require("@opentelemetry/api");
 var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
 
@@ -10327,11 +10741,11 @@ var CLAUDE_MESSAGES = {
 };
 
 // src/exulu/routes.ts
-var import_ai9 = require("ai");
+var import_ai10 = require("ai");
 var import_cookie_parser = __toESM(require("cookie-parser"), 1);
 
 // src/exulu/provider.ts
-var import_zod11 = require("zod");
+var import_zod10 = require("zod");
 var import_ai8 = require("ai");
 
 // src/utils/generate-slug.ts
@@ -10389,7 +10803,7 @@ async function clearSessionCurrentTask(session) {
 }
 
 // src/exulu/provider.ts
-var import_fs2 = __toESM(require("fs"), 1);
+var import_fs = __toESM(require("fs"), 1);
 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.
@@ -10471,9 +10885,9 @@ var ExuluProvider = class {
       name: `${agent.name}`,
       type: "agent",
       category: "agents",
-      inputSchema: import_zod11.z.object({
-        prompt: import_zod11.z.string().describe("The prompt (usually a question for the agent) to send to the agent."),
-        information: import_zod11.z.string().describe("A summary of relevant context / information from the current session")
+      inputSchema: import_zod10.z.object({
+        prompt: import_zod10.z.string().describe("The prompt (usually a question for the agent) to send to the agent."),
+        information: import_zod10.z.string().describe("A summary of relevant context / information from the current session")
       }),
       description: `This tool calls an agent named: ${agent.name}. The agent does the following: ${agent.description}.`,
       config: [],
@@ -10676,12 +11090,12 @@ var ExuluProvider = class {
       system += "\n\n" + memoryContext;
     }
     const includesContextSearchTool = currentTools?.some(
-      (tool6) => tool6.name.toLowerCase().includes("context_search") || tool6.id.includes("context_search") || tool6.type === "context"
+      (tool5) => tool5.name.toLowerCase().includes("context_search") || tool5.id.includes("context_search") || tool5.type === "context"
     );
     const includesWebSearchTool = currentTools?.some(
-      (tool6) => tool6.name.toLowerCase().includes("web_search") || tool6.id.includes("web_search") || tool6.type === "web_search"
+      (tool5) => tool5.name.toLowerCase().includes("web_search") || tool5.id.includes("web_search") || tool5.type === "web_search"
     );
-    console.log("[EXULU] Current tools: " + currentTools?.map((tool6) => tool6.name).join("\n"));
+    console.log("[EXULU] Current tools: " + currentTools?.map((tool5) => tool5.name).join("\n"));
     console.log("[EXULU] Includes context search tool: " + includesContextSearchTool);
     if (includesContextSearchTool) {
       system += `
@@ -11054,7 +11468,7 @@ ${extractedText}
         // todo make this configurable?
         page: 1
       });
-      import_fs2.default.writeFileSync("pre-fetched-relevant-information.json", JSON.stringify(result2, null, 2));
+      import_fs.default.writeFileSync("pre-fetched-relevant-information.json", JSON.stringify(result2, null, 2));
       if (result2?.chunks?.length) {
         memoryContext = `
                   <pre-fetched relevant information for this query>:
@@ -11079,12 +11493,12 @@ ${extractedText}
       system += "\n\n" + memoryContext;
     }
     const includesContextSearchTool = currentTools?.some(
-      (tool6) => tool6.name.toLowerCase().includes("context_search") || tool6.id.includes("context_search") || tool6.type === "context"
+      (tool5) => tool5.name.toLowerCase().includes("context_search") || tool5.id.includes("context_search") || tool5.type === "context"
     );
     const includesWebSearchTool = currentTools?.some(
-      (tool6) => tool6.name.toLowerCase().includes("web_search") || tool6.id.includes("web_search") || tool6.type === "web_search"
+      (tool5) => tool5.name.toLowerCase().includes("web_search") || tool5.id.includes("web_search") || tool5.type === "web_search"
     );
-    console.log("[EXULU] Current tools: " + currentTools?.map((tool6) => tool6.name).join("\n"));
+    console.log("[EXULU] Current tools: " + currentTools?.map((tool5) => tool5.name).join("\n"));
     console.log("[EXULU] Includes context search tool: " + includesContextSearchTool);
     console.log("[EXULU] Includes web search tool: " + includesWebSearchTool);
     if (includesContextSearchTool) {
@@ -11129,7 +11543,7 @@ ${extractedText}
 
 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.`;
-    import_fs2.default.writeFileSync("system-prompt.txt", system);
+    import_fs.default.writeFileSync("system-prompt.txt", system);
     const result = (0, import_ai8.streamText)({
       temperature: 0,
       // TODO Make this configurable
@@ -11274,13 +11688,458 @@ var providerRateLimiter = async (key, windowSeconds, limit, points) => {
   }
 };
 
+// src/exulu/openai-gateway.ts
+var import_express2 = require("express");
+var import_ai9 = require("ai");
+var import_node_crypto4 = require("crypto");
+var import_crypto_js6 = __toESM(require("crypto-js"), 1);
+var import_express3 = __toESM(require("express"), 1);
+function convertOpenAIMessagesToCoreMessages(messages) {
+  const systemParts = [];
+  const coreMessages = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemParts.push(typeof msg.content === "string" ? msg.content : "");
+      continue;
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        coreMessages.push({ role: "user", content: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        const parts = msg.content.flatMap((part) => {
+          if (part.type === "text") return [{ type: "text", text: part.text }];
+          if (part.type === "image_url") return [{ type: "image", image: part.image_url.url }];
+          return [];
+        });
+        coreMessages.push({ role: "user", content: parts });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        const parts = [];
+        if (typeof msg.content === "string" && msg.content) {
+          parts.push({ type: "text", text: msg.content });
+        }
+        for (const tc of msg.tool_calls) {
+          parts.push({
+            type: "tool-call",
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            args: JSON.parse(tc.function.arguments || "{}")
+          });
+        }
+        coreMessages.push({ role: "assistant", content: parts });
+      } else {
+        coreMessages.push({
+          role: "assistant",
+          content: typeof msg.content === "string" ? msg.content : ""
+        });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      coreMessages.push({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: msg.tool_call_id ?? "",
+            result: msg.content
+          }
+        ]
+      });
+    }
+  }
+  return { systemPrompt: systemParts.join("\n\n"), coreMessages };
+}
+async function writeStatistics(agent, project, user, inputTokens, outputTokens) {
+  const label = agent.name;
+  const trigger = "agent";
+  const projectId = project?.id ? { project: project.id } : {};
+  await Promise.all([
+    updateStatistic({
+      name: "count",
+      label,
+      type: STATISTICS_TYPE_ENUM.AGENT_RUN,
+      trigger,
+      count: 1,
+      user: user.id,
+      role: user.role?.id,
+      ...projectId
+    }),
+    ...inputTokens ? [
+      updateStatistic({
+        name: "inputTokens",
+        label,
+        type: STATISTICS_TYPE_ENUM.AGENT_RUN,
+        trigger,
+        count: inputTokens,
+        user: user.id,
+        role: user.role?.id,
+        ...projectId
+      })
+    ] : [],
+    ...outputTokens ? [
+      updateStatistic({
+        name: "outputTokens",
+        label,
+        type: STATISTICS_TYPE_ENUM.AGENT_RUN,
+        trigger,
+        count: outputTokens,
+        user: user.id,
+        role: user.role?.id,
+        ...projectId
+      })
+    ] : []
+  ]);
+}
+var registerOpenAIGatewayRoutes = async (app, providers, tools, contexts, config, rerankers) => {
+  const { agentsSchema: agentsSchema4, projectsSchema: projectsSchema4 } = coreSchemas.get();
+  app.get(
+    "/gateway/open-ai/v1/models",
+    async (req, res) => {
+      try {
+        const authResult = await requestValidators.authenticate(req);
+        if (!authResult.user?.id) {
+          res.status(authResult.code || 401).json({ error: { message: authResult.message, type: "authentication_error" } });
+          return;
+        }
+        const { db: db2 } = await postgresClient();
+        let projectsQuery = db2("projects").select("id", "name");
+        projectsQuery = applyAccessControl(projectsSchema4(), projectsQuery, authResult.user);
+        const projects = await projectsQuery;
+        let agentsQuery = db2("agents").select("id", "name");
+        agentsQuery = applyAccessControl(agentsSchema4(), agentsQuery, authResult.user);
+        const agents = await agentsQuery;
+        const data = projects.flatMap(
+          (p) => agents.map((a) => ({
+            id: `${p.name}/${a.name}`,
+            object: "model",
+            created: 0,
+            owned_by: "exulu"
+          }))
+        );
+        res.json({ object: "list", data });
+      } catch (error) {
+        console.error("[OPENAI GATEWAY] /v1/models error:", error);
+        res.status(500).json({ error: { message: error.message, type: "server_error" } });
+      }
+    }
+  );
+  app.get(
+    "/gateway/open-ai/v1/models/:projectId/:agentId",
+    async (req, res) => {
+      try {
+        const authResult = await requestValidators.authenticate(req);
+        if (!authResult.user?.id) {
+          res.status(authResult.code || 401).json({ error: { message: authResult.message, type: "authentication_error" } });
+          return;
+        }
+        const { db: db2 } = await postgresClient();
+        let projectQuery = db2("projects").select("id", "name");
+        projectQuery = applyAccessControl(projectsSchema4(), projectQuery, authResult.user);
+        projectQuery.where({ id: req.params.projectId });
+        const project = await projectQuery.first();
+        let agentQuery = db2("agents").select("id", "name");
+        agentQuery = applyAccessControl(agentsSchema4(), agentQuery, authResult.user);
+        agentQuery.where({ id: req.params.agentId });
+        const agent = await agentQuery.first();
+        if (!project || !agent) {
+          res.status(404).json({ error: { message: "Model not found", type: "invalid_request_error" } });
+          return;
+        }
+        res.json({
+          id: `${project.name}/${agent.name}`,
+          object: "model",
+          created: 0,
+          owned_by: "exulu"
+        });
+      } catch (error) {
+        console.error("[OPENAI GATEWAY] /v1/models/:id error:", error);
+        res.status(500).json({ error: { message: error.message, type: "server_error" } });
+      }
+    }
+  );
+  app.post(
+    "/gateway/open-ai/v1/chat/completions",
+    import_express3.default.json({ limit: REQUEST_SIZE_LIMIT }),
+    async (req, res) => {
+      try {
+        const { db: db2 } = await postgresClient();
+        const authResult = await requestValidators.authenticate(req);
+        if (!authResult.user?.id) {
+          res.status(authResult.code || 401).json({ error: { message: authResult.message, type: "authentication_error" } });
+          return;
+        }
+        const user = authResult.user;
+        const modelId = req.body.model;
+        if (!modelId) {
+          res.status(400).json({
+            error: { message: "Missing required field: model", type: "invalid_request_error" }
+          });
+          return;
+        }
+        const separatorIndex = modelId.indexOf("/");
+        if (separatorIndex === -1) {
+          res.status(400).json({
+            error: { message: "Invalid model format. Expected: 'projectname/agentname'", type: "invalid_request_error" }
+          });
+          return;
+        }
+        const projectName = modelId.substring(0, separatorIndex);
+        const agentName = modelId.substring(separatorIndex + 1);
+        let agentQuery = db2("agents").select("*");
+        agentQuery = applyAccessControl(agentsSchema4(), agentQuery, user);
+        agentQuery.where({ name: agentName });
+        const agent = await agentQuery.first();
+        if (!agent) {
+          res.status(404).json({
+            error: {
+              message: `Agent '${agentName}' not found or you do not have access to it.`,
+              type: "invalid_request_error"
+            }
+          });
+          return;
+        }
+        let project = null;
+        if (projectName) {
+          let projectQuery = db2("projects").select("*");
+          projectQuery = applyAccessControl(projectsSchema4(), projectQuery, user);
+          projectQuery.where({ name: projectName });
+          project = await projectQuery.first();
+        }
+        if (!process.env.NEXTAUTH_SECRET) {
+          res.status(500).json({ error: { message: "Server configuration error", type: "server_error" } });
+          return;
+        }
+        if (!agent.providerapikey) {
+          res.status(400).json({
+            error: { message: "Agent has no API key configured", type: "invalid_request_error" }
+          });
+          return;
+        }
+        const variable = await db2.from("variables").where({ name: agent.providerapikey }).first();
+        if (!variable) {
+          res.status(400).json({
+            error: { message: "API key variable not found", type: "invalid_request_error" }
+          });
+          return;
+        }
+        if (!variable.encrypted) {
+          res.status(400).json({
+            error: { message: "API key variable must be encrypted", type: "invalid_request_error" }
+          });
+          return;
+        }
+        const bytes = import_crypto_js6.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+        const providerapikey = bytes.toString(import_crypto_js6.default.enc.Utf8);
+        const provider = providers.find((p) => p.id === agent.provider);
+        if (!provider?.config?.model?.create) {
+          res.status(400).json({
+            error: { message: "No provider configured for this agent", type: "invalid_request_error" }
+          });
+          return;
+        }
+        const languageModel = provider.config.model.create({ apiKey: providerapikey });
+        const disabledTools = req.body.disabledTools ?? [];
+        const enabledTools = await getEnabledTools(
+          agent,
+          tools,
+          contexts ?? [],
+          rerankers ?? [],
+          disabledTools,
+          providers,
+          user
+        );
+        const convertedTools = await convertExuluToolsToAiSdkTools(
+          enabledTools,
+          [],
+          tools,
+          agent.tools,
+          providerapikey,
+          contexts,
+          rerankers,
+          user,
+          config,
+          void 0,
+          req,
+          project?.id,
+          void 0,
+          languageModel,
+          agent
+        );
+        const openaiMessages = req.body.messages ?? [];
+        const { systemPrompt: requestSystemPrompt, coreMessages } = convertOpenAIMessagesToCoreMessages(openaiMessages);
+        const agentInstructions = agent.instructions ?? "";
+        const systemParts = [
+          agentInstructions ? `You are an agent named: ${agent.name}
+Here are your instructions: ${agentInstructions}` : `You are an agent named: ${agent.name}`,
+          project ? `The project you are working on is: ${project.name}${project.description ? `
+${project.description}` : ""}` : "",
+          requestSystemPrompt
+        ].filter(Boolean);
+        const systemPrompt = systemParts.join("\n\n");
+        const completionId = `chatcmpl-${(0, import_node_crypto4.randomUUID)()}`;
+        const created = Math.floor(Date.now() / 1e3);
+        const hasTools = Object.keys(convertedTools).length > 0;
+        if (req.body.stream === true) {
+          res.setHeader("Content-Type", "text/event-stream");
+          res.setHeader("Cache-Control", "no-cache");
+          res.setHeader("Connection", "keep-alive");
+          const result = (0, import_ai9.streamText)({
+            model: languageModel,
+            system: systemPrompt || void 0,
+            messages: coreMessages,
+            tools: hasTools ? convertedTools : void 0,
+            maxRetries: 2,
+            stopWhen: [(0, import_ai9.stepCountIs)(5)],
+            onError: (error) => {
+              console.error("[OPENAI GATEWAY] stream error:", error);
+            }
+          });
+          res.write(
+            `data: ${JSON.stringify({
+              id: completionId,
+              object: "chat.completion.chunk",
+              created,
+              model: modelId,
+              choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]
+            })}
+
+`
+          );
+          let inputTokens = 0;
+          let outputTokens = 0;
+          for await (const chunk of result.fullStream) {
+            if (chunk.type === "text-delta") {
+              res.write(
+                `data: ${JSON.stringify({
+                  id: completionId,
+                  object: "chat.completion.chunk",
+                  created,
+                  model: modelId,
+                  choices: [{ index: 0, delta: { content: chunk.text }, finish_reason: null }]
+                })}
+
+`
+              );
+            } else if (chunk.type === "tool-input-start") {
+              res.write(
+                `data: ${JSON.stringify({
+                  id: completionId,
+                  object: "chat.completion.chunk",
+                  created,
+                  model: modelId,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: {
+                        tool_calls: [
+                          {
+                            index: 0,
+                            id: chunk.id,
+                            type: "function",
+                            function: { name: chunk.toolName, arguments: "" }
+                          }
+                        ]
+                      },
+                      finish_reason: null
+                    }
+                  ]
+                })}
+
+`
+              );
+            } else if (chunk.type === "tool-input-delta") {
+              res.write(
+                `data: ${JSON.stringify({
+                  id: completionId,
+                  object: "chat.completion.chunk",
+                  created,
+                  model: modelId,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: { tool_calls: [{ index: 0, function: { arguments: chunk.delta } }] },
+                      finish_reason: null
+                    }
+                  ]
+                })}
+
+`
+              );
+            } else if (chunk.type === "finish") {
+              inputTokens = chunk.usage?.inputTokens ?? 0;
+              outputTokens = chunk.usage?.outputTokens ?? 0;
+              const finishReason = chunk.finishReason === "tool-calls" ? "tool_calls" : "stop";
+              res.write(
+                `data: ${JSON.stringify({
+                  id: completionId,
+                  object: "chat.completion.chunk",
+                  created,
+                  model: modelId,
+                  choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+                  usage: {
+                    prompt_tokens: inputTokens,
+                    completion_tokens: outputTokens,
+                    total_tokens: inputTokens + outputTokens
+                  }
+                })}
+
+`
+              );
+            }
+          }
+          res.write("data: [DONE]\n\n");
+          res.end();
+          await writeStatistics(agent, project, user, inputTokens, outputTokens);
+        } else {
+          const { text, usage } = await (0, import_ai9.generateText)({
+            model: languageModel,
+            system: systemPrompt || void 0,
+            messages: coreMessages,
+            tools: hasTools ? convertedTools : void 0,
+            maxRetries: 2,
+            stopWhen: [(0, import_ai9.stepCountIs)(5)]
+          });
+          res.json({
+            id: completionId,
+            object: "chat.completion",
+            created,
+            model: agentId,
+            choices: [
+              {
+                index: 0,
+                message: { role: "assistant", content: text },
+                finish_reason: "stop"
+              }
+            ],
+            usage: {
+              prompt_tokens: usage.promptTokens,
+              completion_tokens: usage.completionTokens,
+              total_tokens: usage.totalTokens
+            }
+          });
+          await writeStatistics(agent, project, user, usage.promptTokens, usage.completionTokens);
+        }
+      } catch (error) {
+        console.error("[OPENAI GATEWAY] /v1/chat/completions error:", error);
+        if (!res.headersSent) {
+          res.status(500).json({ error: { message: error.message, type: "server_error" } });
+        }
+      }
+    }
+  );
+};
+
 // src/exulu/routes.ts
 var import_zod_from_json_schema = require("zod-from-json-schema");
 var REQUEST_SIZE_LIMIT = "50mb";
 var getExuluVersionNumber = async () => {
   try {
-    const path5 = process.cwd();
-    const packageJson = import_fs3.default.readFileSync(path5 + "/package.json", "utf8");
+    const path3 = process.cwd();
+    const packageJson = import_fs2.default.readFileSync(path3 + "/package.json", "utf8");
     const packageData = JSON.parse(packageJson);
     const exuluVersion = packageData.dependencies["@exulu/backend"];
     console.log(`[EXULU] Installed exulu-backend version: ${exuluVersion}`);
@@ -11305,6 +12164,7 @@ var {
   agentMessagesSchema: agentMessagesSchema2,
   rolesSchema: rolesSchema2,
   usersSchema: usersSchema2,
+  skillsSchema: skillsSchema2,
   variablesSchema: variablesSchema2,
   workflowTemplatesSchema: workflowTemplatesSchema2,
   rbacSchema: rbacSchema2,
@@ -11324,7 +12184,7 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
   if (tracer) {
     console.log("[EXULU] tracer configured", tracer);
   }
-  app.use(import_express3.default.json({ limit: REQUEST_SIZE_LIMIT }));
+  app.use(import_express5.default.json({ limit: REQUEST_SIZE_LIMIT }));
   app.use((0, import_cors.default)(corsOptions));
   app.use(import_body_parser.default.urlencoded({ extended: true, limit: REQUEST_SIZE_LIMIT }));
   app.use(import_body_parser.default.json({ limit: REQUEST_SIZE_LIMIT }));
@@ -11349,6 +12209,7 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
   const schema = createSDL(
     [
       usersSchema2(),
+      skillsSchema2(),
       rolesSchema2(),
       agentsSchema2(),
       feedbackSchema2(),
@@ -11384,8 +12245,8 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
   app.use(
     "/graphql",
     (0, import_cors.default)(corsOptions),
-    import_express3.default.json({ limit: REQUEST_SIZE_LIMIT }),
-    (0, import_express5.expressMiddleware)(server, {
+    import_express5.default.json({ limit: REQUEST_SIZE_LIMIT }),
+    (0, import_express52.expressMiddleware)(server, {
       context: async ({ req }) => {
         const authenticationResult = await requestValidators.authenticate(req);
         if (!authenticationResult.user?.id) {
@@ -11506,8 +12367,8 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
       return;
     }
     if (variable.encrypted) {
-      const bytes = import_crypto_js6.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-      providerapikey = bytes.toString(import_crypto_js6.default.enc.Utf8);
+      const bytes = import_crypto_js7.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+      providerapikey = bytes.toString(import_crypto_js7.default.enc.Utf8);
     }
     const openai = new import_openai.default({
       apiKey: providerapikey
@@ -11556,7 +12417,7 @@ Mood: friendly and intelligent.
       });
       return;
     }
-    const uuid = (0, import_node_crypto4.randomUUID)();
+    const uuid = (0, import_node_crypto5.randomUUID)();
     const image_url = await uploadFile(Buffer.from(image_base64, "base64"), `${uuid}.png`, config, {
       contentType: "image/png"
     }, authenticationResult.user?.id, void 0, true);
@@ -11725,8 +12586,8 @@ Mood: friendly and intelligent.
           return;
         }
         if (variable.encrypted) {
-          const bytes = import_crypto_js6.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-          providerapikey = bytes.toString(import_crypto_js6.default.enc.Utf8);
+          const bytes = import_crypto_js7.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+          providerapikey = bytes.toString(import_crypto_js7.default.enc.Utf8);
         }
       }
       if (!!headers.stream) {
@@ -11794,7 +12655,7 @@ ${customInstructions}` : agent.instructions;
             }
             return JSON.stringify(error);
           },
-          generateMessageId: (0, import_ai9.createIdGenerator)({
+          generateMessageId: (0, import_ai10.createIdGenerator)({
             prefix: "msg_",
             size: 16
           }),
@@ -11903,7 +12764,7 @@ ${customInstructions}` : agent.instructions;
   });
   app.use(
     "/gateway/anthropic/:agent/:project",
-    import_express3.default.raw({ type: "*/*", limit: REQUEST_SIZE_LIMIT }),
+    import_express5.default.raw({ type: "*/*", limit: REQUEST_SIZE_LIMIT }),
     async (req, res) => {
       try {
         if (!req.body.tools) {
@@ -11987,8 +12848,8 @@ ${customInstructions}` : agent.instructions;
           return;
         }
         if (variable.encrypted) {
-          const bytes = import_crypto_js6.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-          anthropicApiKey = bytes.toString(import_crypto_js6.default.enc.Utf8);
+          const bytes = import_crypto_js7.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+          anthropicApiKey = bytes.toString(import_crypto_js7.default.enc.Utf8);
         }
         const headers = {
           "x-api-key": anthropicApiKey,
@@ -12067,14 +12928,14 @@ ${customInstructions}` : agent?.instructions;
             console.log("[EXULU] Using tool", toolName);
             const inputs = event.message?.input;
             const id = event.message?.id;
-            const tool6 = enabledTools.find(
-              (tool7) => tool7.id === toolName.replace("exulu_", "")
+            const tool5 = enabledTools.find(
+              (tool6) => tool6.id === toolName.replace("exulu_", "")
             );
-            if (!tool6 || !tool6.tool.execute) {
+            if (!tool5 || !tool5.tool.execute) {
               console.error("[EXULU] Tool not found or not enabled.", toolName);
               continue;
             }
-            const toolResult = await tool6.tool.execute(inputs, {
+            const toolResult = await tool5.tool.execute(inputs, {
               toolCallId: id,
               messages: [
                 {
@@ -12166,33 +13027,437 @@ data: ${JSON.stringify(event)}
       }
     }
   );
-  app.use(import_express3.default.static("public"));
-  return app;
-};
-var createCustomAnthropicStreamingMessage = (message) => {
-  const responseData = {
-    type: "message",
-    content: [
-      {
-        type: "text",
-        text: message
+  function buildFileTree(files, stripPrefix) {
+    const root = { name: "/", path: "/", key: "", type: "folder", children: [] };
+    for (const file of files) {
+      const relativePath = file.key.startsWith(stripPrefix) ? file.key.slice(stripPrefix.length) : file.key;
+      const parts = relativePath.split("/").filter(Boolean);
+      let current = root;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        const existingChild = current.children?.find((c) => c.name === part);
+        if (existingChild) {
+          current = existingChild;
+        } else {
+          const nodePath = "/" + parts.slice(0, i + 1).join("/");
+          const node = isFile ? {
+            name: part,
+            path: nodePath,
+            key: file.key,
+            type: "file",
+            size: file.size,
+            lastModified: file.lastModified
+          } : { name: part, path: nodePath, key: "", type: "folder", children: [] };
+          current.children = current.children ?? [];
+          current.children.push(node);
+          current = node;
+        }
       }
-    ]
-  };
-  const jsonString = JSON.stringify(responseData);
-  const arrayBuffer = new TextEncoder().encode(jsonString).buffer;
-  return arrayBuffer;
-};
-
-// src/mcp/index.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_node_crypto5 = require("crypto");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-var import_types2 = require("@modelcontextprotocol/sdk/types.js");
-var import_express4 = require("express");
-var import_api3 = require("@opentelemetry/api");
-var import_crypto_js7 = __toESM(require("crypto-js"), 1);
-var import_zod12 = require("zod");
+    }
+    return root;
+  }
+  app.post("/skills/:skillId/init", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { name = "Skill", description = "" } = req.body;
+    const skillMdContent = [
+      `# ${name}`,
+      "",
+      description || "Describe what this skill does and when to use it.",
+      "",
+      "## Overview",
+      "",
+      "...",
+      "",
+      "## Usage",
+      "",
+      "..."
+    ].join("\n");
+    const s3Key = `skills/${skillId}/v1/SKILL.md`;
+    try {
+      await uploadFile(Buffer.from(skillMdContent, "utf-8"), s3Key, config, { contentType: "text/markdown" }, void 0, void 0, true);
+    } catch (err) {
+      console.error("[SKILLS] Failed to create SKILL.md in S3", err);
+      res.status(500).json({ detail: "Failed to initialise skill folder in S3." });
+      return;
+    }
+    const { db: db2 } = await postgresClient();
+    await db2("skills").where({ id: skillId }).update({
+      s3folder: `skills/${skillId}`,
+      current_version: 1,
+      history: JSON.stringify([
+        { version: 1, created_at: (/* @__PURE__ */ new Date()).toISOString(), label: "Initial" }
+      ])
+    });
+    res.json({ version: 1, skillMdKey: s3Key });
+  });
+  app.get("/skills/:skillId/files", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const version = req.query.version ? Number(req.query.version) : skill.current_version ?? 1;
+    const prefix = `skills/${skillId}/v${version}/`;
+    const files = await listS3ObjectsByPrefix(prefix, config);
+    const tree = buildFileTree(files, config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/` + prefix : prefix);
+    res.json({ version, tree, fileCount: files.length });
+  });
+  app.post("/skills/:skillId/sign", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { filePath, contentType = "application/octet-stream" } = req.body;
+    if (!filePath || typeof filePath !== "string") {
+      res.status(400).json({ detail: "Missing filePath in request body." });
+      return;
+    }
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const version = skill.current_version ?? 1;
+    const safePath = filePath.replace(/^\/+/, "").replace(/\.\.\//g, "");
+    const s3Key = `skills/${skillId}/v${version}/${safePath}`;
+    const fullKey = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/${s3Key}` : s3Key;
+    const url = await getS3SignedUploadUrl(fullKey, contentType, config);
+    res.json({ key: s3Key, url, method: "PUT" });
+  });
+  app.get("/skills/:skillId/file", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { key } = req.query;
+    if (!key || typeof key !== "string") {
+      res.status(400).json({ detail: "Missing key query parameter." });
+      return;
+    }
+    if (!key.startsWith(`skills/${skillId}/`)) {
+      res.status(403).json({ detail: "Key does not belong to this skill." });
+      return;
+    }
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const fullKey = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/${key}` : key;
+    const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".py", ".js", ".ts", ".json", ".yaml", ".yml", ".sh", ".env", ".toml", ".xml", ".html", ".css"]);
+    const ext = key.slice(key.lastIndexOf(".")).toLowerCase();
+    const isText = TEXT_EXTENSIONS.has(ext);
+    const MAX_INLINE_BYTES = 200 * 1024;
+    let content;
+    if (isText) {
+      try {
+        const raw = await getS3ObjectContent(fullKey, config);
+        if (raw.length <= MAX_INLINE_BYTES) {
+          content = raw;
+        }
+      } catch {
+      }
+    }
+    const bucket = config.fileUploads?.s3Bucket ?? "";
+    const url = await getPresignedUrl(bucket, fullKey, config);
+    res.json({ url, content, key });
+  });
+  app.delete("/skills/:skillId/file", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { key, prefix } = req.query;
+    if (!key && !prefix) {
+      res.status(400).json({ detail: "Provide either key or prefix query parameter." });
+      return;
+    }
+    const guard = (s) => !s.startsWith(`skills/${skillId}/`);
+    if (key && typeof key === "string") {
+      if (guard(key)) {
+        res.status(403).json({ detail: "Key does not belong to this skill." });
+        return;
+      }
+    }
+    if (prefix && typeof prefix === "string") {
+      if (guard(prefix)) {
+        res.status(403).json({ detail: "Prefix does not belong to this skill." });
+        return;
+      }
+    }
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const s3Prefix = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
+    if (key && typeof key === "string") {
+      const fullKey = s3Prefix + key;
+      await deleteS3Object(fullKey, config);
+      res.json({ deleted: 1 });
+      return;
+    }
+    if (prefix && typeof prefix === "string") {
+      const files = await listS3ObjectsByPrefix(prefix, config);
+      await Promise.all(files.map((f) => deleteS3Object(f.key, config)));
+      res.json({ deleted: files.length });
+      return;
+    }
+  });
+  app.post("/skills/:skillId/version", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { label } = req.body;
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const currentVersion = skill.current_version ?? 1;
+    const newVersion = currentVersion + 1;
+    const currentPrefix = `skills/${skillId}/v${currentVersion}/`;
+    const newPrefix = `skills/${skillId}/v${newVersion}/`;
+    const files = await listS3ObjectsByPrefix(currentPrefix, config);
+    if (files.length === 0) {
+      res.status(400).json({ detail: "No files found in current version to snapshot." });
+      return;
+    }
+    const s3GeneralPrefix = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
+    for (const file of files) {
+      const destKey = file.key.replace(s3GeneralPrefix + currentPrefix, s3GeneralPrefix + newPrefix);
+      await copyS3Object(file.key, destKey, config);
+    }
+    const existingHistory = Array.isArray(skill.history) ? skill.history : [];
+    const newHistory = [
+      ...existingHistory,
+      { version: newVersion, created_at: (/* @__PURE__ */ new Date()).toISOString(), label: label ?? `v${newVersion}` }
+    ];
+    await db2("skills").where({ id: skillId }).update({
+      current_version: newVersion,
+      history: JSON.stringify(newHistory)
+    });
+    res.json({ newVersion, fileCount: files.length });
+  });
+  app.post("/skills/:skillId/rename", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const { sourceKey, destPath } = req.body;
+    if (!sourceKey || !destPath) {
+      res.status(400).json({ detail: "sourceKey and destPath are required." });
+      return;
+    }
+    if (!sourceKey.startsWith(`skills/${skillId}/`)) {
+      res.status(403).json({ detail: "sourceKey does not belong to this skill." });
+      return;
+    }
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const version = skill.current_version ?? 1;
+    const safeDest = destPath.replace(/^\/+/, "").replace(/\.\.\//g, "");
+    const destKey = `skills/${skillId}/v${version}/${safeDest}`;
+    const s3Prefix = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
+    const fullSourceKey = s3Prefix + sourceKey;
+    const fullDestKey = s3Prefix + destKey;
+    await copyS3Object(fullSourceKey, fullDestKey, config);
+    await deleteS3Object(fullSourceKey, config);
+    res.json({ newKey: destKey });
+  });
+  app.get("/skills/:skillId/diff", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const { skillId } = req.params;
+    const fromVersion = Number(req.query.fromVersion);
+    const toVersion = Number(req.query.toVersion);
+    if (!fromVersion || !toVersion) {
+      res.status(400).json({ detail: "fromVersion and toVersion query params are required." });
+      return;
+    }
+    const { db: db2 } = await postgresClient();
+    const skill = await db2("skills").where({ id: skillId }).first();
+    if (!skill) {
+      res.status(404).json({ detail: "Skill not found." });
+      return;
+    }
+    const s3Prefix = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
+    const fromPrefix = `skills/${skillId}/v${fromVersion}/`;
+    const toPrefix = `skills/${skillId}/v${toVersion}/`;
+    const [fromFiles, toFiles] = await Promise.all([
+      listS3ObjectsByPrefix(fromPrefix, config),
+      listS3ObjectsByPrefix(toPrefix, config)
+    ]);
+    const relativise = (files, prefix) => {
+      const full = s3Prefix + prefix;
+      return new Map(files.map((f) => [f.key.replace(full, ""), f]));
+    };
+    const fromMap = relativise(fromFiles, fromPrefix);
+    const toMap = relativise(toFiles, toPrefix);
+    const allPaths = /* @__PURE__ */ new Set([...fromMap.keys(), ...toMap.keys()]);
+    const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".py", ".js", ".ts", ".json", ".yaml", ".yml", ".sh", ".toml"]);
+    const MAX_DIFF_BYTES = 500 * 1024;
+    const fileDiffs = await Promise.all(
+      [...allPaths].map(async (path3) => {
+        const inFrom = fromMap.has(path3);
+        const inTo = toMap.has(path3);
+        const status = !inFrom ? "added" : !inTo ? "removed" : "modified";
+        if (status === "modified") {
+          const ext = path3.slice(path3.lastIndexOf(".")).toLowerCase();
+          if (!TEXT_EXTENSIONS.has(ext)) {
+            return { path: path3, status };
+          }
+          try {
+            const [fromContent, toContent] = await Promise.all([
+              getS3ObjectContent(s3Prefix + fromPrefix + path3, config),
+              getS3ObjectContent(s3Prefix + toPrefix + path3, config)
+            ]);
+            if (fromContent === toContent) {
+              return { path: path3, status: "unchanged" };
+            }
+            if (fromContent.length + toContent.length > MAX_DIFF_BYTES) {
+              return { path: path3, status };
+            }
+            const fromLines = fromContent.split("\n");
+            const toLines = toContent.split("\n");
+            const diff = buildUnifiedDiff(fromLines, toLines, `v${fromVersion}/${path3}`, `v${toVersion}/${path3}`);
+            return { path: path3, status, diff };
+          } catch {
+            return { path: path3, status };
+          }
+        }
+        return { path: path3, status };
+      })
+    );
+    res.json({
+      fromVersion,
+      toVersion,
+      files: fileDiffs.filter((f) => f.status !== "unchanged")
+    });
+  });
+  app.use(import_express5.default.static("public"));
+  await registerOpenAIGatewayRoutes(app, providers, tools, contexts, config, rerankers);
+  return app;
+};
+function buildUnifiedDiff(fromLines, toLines, fromLabel, toLabel) {
+  function lcs(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        dp[i][j] = a[i - 1] === b[j - 1] ? (dp[i - 1][j - 1] ?? 0) + 1 : Math.max(dp[i - 1][j] ?? 0, dp[i][j - 1] ?? 0);
+      }
+    }
+    return dp;
+  }
+  function diff(a, b) {
+    const table = lcs(a, b);
+    const result = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+      if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+        result.unshift({ op: "=", line: a[i - 1] });
+        i--;
+        j--;
+      } else if (j > 0 && (i === 0 || (table[i][j - 1] ?? 0) >= (table[i - 1][j] ?? 0))) {
+        result.unshift({ op: "+", line: b[j - 1] });
+        j--;
+      } else {
+        result.unshift({ op: "-", line: a[i - 1] });
+        i--;
+      }
+    }
+    return result;
+  }
+  const CONTEXT = 3;
+  const hunks = diff(fromLines, toLines);
+  const lines = [`--- ${fromLabel}`, `+++ ${toLabel}`];
+  let hunkStart = -1;
+  for (let idx = 0; idx < hunks.length; idx++) {
+    const h = hunks[idx];
+    if (h.op !== "=") {
+      if (hunkStart < 0) {
+        hunkStart = Math.max(0, idx - CONTEXT);
+      }
+    } else if (hunkStart >= 0 && idx - hunkStart > CONTEXT * 2) {
+      const slice = hunks.slice(hunkStart, Math.min(idx, hunkStart + (idx - hunkStart)));
+      lines.push(`@@ -${hunkStart + 1} +${hunkStart + 1} @@`);
+      for (const s of slice) {
+        lines.push((s.op === "=" ? " " : s.op) + s.line);
+      }
+      hunkStart = -1;
+    }
+  }
+  if (hunkStart >= 0) {
+    const slice = hunks.slice(hunkStart, Math.min(hunks.length, hunkStart + hunks.length));
+    lines.push(`@@ -${hunkStart + 1} +${hunkStart + 1} @@`);
+    for (const s of slice) {
+      lines.push((s.op === "=" ? " " : s.op) + s.line);
+    }
+  }
+  return lines.join("\n");
+}
+var createCustomAnthropicStreamingMessage = (message) => {
+  const responseData = {
+    type: "message",
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
+  };
+  const jsonString = JSON.stringify(responseData);
+  const arrayBuffer = new TextEncoder().encode(jsonString).buffer;
+  return arrayBuffer;
+};
+
+// src/mcp/index.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_node_crypto6 = require("crypto");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+var import_express6 = require("express");
+var import_api3 = require("@opentelemetry/api");
+var import_crypto_js8 = __toESM(require("crypto-js"), 1);
+var import_zod11 = require("zod");
 var SESSION_ID_HEADER = "mcp-session-id";
 var ExuluMCP = class {
   server = {};
@@ -12257,34 +13522,34 @@ var ExuluMCP = class {
         );
       }
       if (variable.encrypted) {
-        const bytes = import_crypto_js7.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-        providerapikey = bytes.toString(import_crypto_js7.default.enc.Utf8);
+        const bytes = import_crypto_js8.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+        providerapikey = bytes.toString(import_crypto_js8.default.enc.Utf8);
       }
     }
     console.log(
       "[EXULU] Enabled tools",
       enabledTools?.map((x) => x.name + " (" + x.id + ")")
     );
-    for (const tool6 of enabledTools || []) {
-      if (server.tools[tool6.id]) {
+    for (const tool5 of enabledTools || []) {
+      if (server.tools[tool5.id]) {
         continue;
       }
       server.mcp.registerTool(
-        sanitizeToolName(tool6.name + "_agent_" + tool6.id),
+        sanitizeToolName(tool5.name + "_agent_" + tool5.id),
         {
-          title: tool6.name + " agent",
-          description: tool6.description,
+          title: tool5.name + " agent",
+          description: tool5.description,
           inputSchema: {
-            inputs: tool6.inputSchema || import_zod12.z.object({})
+            inputs: tool5.inputSchema || import_zod11.z.object({})
           }
         },
         async ({ inputs }, args) => {
-          console.log("[EXULU] MCP tool name", tool6.name);
+          console.log("[EXULU] MCP tool name", tool5.name);
           console.log("[EXULU] MCP tool inputs", inputs);
           console.log("[EXULU] MCP tool args", args);
           const configValues = agent.tools;
           const tools = await convertExuluToolsToAiSdkTools(
-            [tool6],
+            [tool5],
             [],
             allTools,
             configValues,
@@ -12297,13 +13562,13 @@ var ExuluMCP = class {
             void 0,
             void 0
           );
-          const convertedTool = tools[sanitizeToolName(tool6.name)];
+          const convertedTool = tools[sanitizeToolName(tool5.name)];
           if (!convertedTool?.execute) {
             console.error("[EXULU] Tool not found in converted tools array.", tools);
             throw new Error("Tool not found in converted tools array.");
           }
           const iterator = await convertedTool.execute(inputs, {
-            toolCallId: tool6.id + "_" + (0, import_node_crypto5.randomUUID)(),
+            toolCallId: tool5.id + "_" + (0, import_node_crypto6.randomUUID)(),
             messages: []
           });
           let result;
@@ -12317,7 +13582,7 @@ var ExuluMCP = class {
           };
         }
       );
-      server.tools[tool6.id] = tool6.name;
+      server.tools[tool5.id] = tool5.name;
     }
     const getListOfPromptTemplatesName = "getListOfPromptTemplates";
     if (!server.tools[getListOfPromptTemplatesName]) {
@@ -12327,7 +13592,7 @@ var ExuluMCP = class {
           title: "Get List of Prompt Templates",
           description: "Retrieves a list of prompt templates available for this agent. Returns the name, description, and ID of each template.",
           inputSchema: {
-            inputs: import_zod12.z.object({})
+            inputs: import_zod11.z.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -12373,8 +13638,8 @@ var ExuluMCP = class {
           title: "Get Prompt Template Details",
           description: "Retrieves the full details of a specific prompt template by ID, including the actual template content with variables.",
           inputSchema: {
-            inputs: import_zod12.z.object({
-              id: import_zod12.z.string().describe("The ID of the prompt template to retrieve")
+            inputs: import_zod11.z.object({
+              id: import_zod11.z.string().describe("The ID of the prompt template to retrieve")
             })
           }
         },
@@ -12437,20 +13702,20 @@ var ExuluMCP = class {
     return server.mcp;
   };
   create = async ({
-    express: express3,
+    express: express4,
     allTools,
     allProviders,
     allContexts,
     allRerankers,
     config
   }) => {
-    if (!express3) {
+    if (!express4) {
       throw new Error("Express not initialized.");
     }
     if (!this.server) {
       throw new Error("MCP server not initialized.");
     }
-    express3.post("/mcp/:agent", async (req, res) => {
+    express4.post("/mcp/:agent", async (req, res) => {
       console.log("[EXULU] MCP request received.", req.params.agent);
       if (!req.params.agent) {
         res.status(400).json({
@@ -12497,7 +13762,7 @@ var ExuluMCP = class {
         transport = this.transports[sessionId];
       } else if (!sessionId && (0, import_types2.isInitializeRequest)(req.body)) {
         transport = new import_streamableHttp.StreamableHTTPServerTransport({
-          sessionIdGenerator: () => (0, import_node_crypto5.randomUUID)(),
+          sessionIdGenerator: () => (0, import_node_crypto6.randomUUID)(),
           onsessioninitialized: (sessionId2) => {
             this.transports[sessionId2] = transport;
           }
@@ -12531,15 +13796,15 @@ var ExuluMCP = class {
       const transport = this.transports[sessionId];
       await transport.handleRequest(req, res);
     };
-    express3.get("/mcp/:agent", handleSessionRequest);
-    express3.delete("/mcp/:agent", handleSessionRequest);
+    express4.get("/mcp/:agent", handleSessionRequest);
+    express4.delete("/mcp/:agent", handleSessionRequest);
     console.log("[EXULU] MCP server created.");
-    return express3;
+    return express4;
   };
 };
 
 // src/exulu/app/index.ts
-var import_express7 = __toESM(require("express"), 1);
+var import_express8 = __toESM(require("express"), 1);
 
 // src/templates/providers/anthropic/claude.ts
 var import_anthropic = require("@ai-sdk/anthropic");
@@ -13245,7 +14510,7 @@ var import_winston2 = __toESM(require("winston"), 1);
 var import_util = __toESM(require("util"), 1);
 
 // src/exulu/evals.ts
-var import_ai10 = require("ai");
+var import_ai11 = require("ai");
 var ExuluEval = class {
   id;
   name;
@@ -13282,7 +14547,7 @@ var ExuluEval = class {
 };
 
 // src/templates/evals/index.ts
-var import_zod13 = require("zod");
+var import_zod12 = require("zod");
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
     return new ExuluEval({
@@ -13327,8 +14592,8 @@ var llmAsJudgeEval = () => {
           contexts: [],
           rerankers: [],
           prompt,
-          outputSchema: import_zod13.z.object({
-            score: import_zod13.z.number().min(0).max(100).describe("The score between 0 and 100.")
+          outputSchema: import_zod12.z.object({
+            score: import_zod12.z.number().min(0).max(100).describe("The score between 0 and 100.")
           }),
           providerapikey
         });
@@ -13556,12 +14821,12 @@ Usage:
 - If no todos exist yet, an empty list will be returned`;
 
 // src/templates/tools/todo/todo.ts
-var import_zod14 = __toESM(require("zod"), 1);
-var TodoSchema = import_zod14.default.object({
-  content: import_zod14.default.string().describe("Brief description of the task"),
-  status: import_zod14.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  priority: import_zod14.default.string().describe("Priority level of the task: high, medium, low"),
-  id: import_zod14.default.string().describe("Unique identifier for the todo item")
+var import_zod13 = __toESM(require("zod"), 1);
+var TodoSchema = import_zod13.default.object({
+  content: import_zod13.default.string().describe("Brief description of the task"),
+  status: import_zod13.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+  priority: import_zod13.default.string().describe("Priority level of the task: high, medium, low"),
+  id: import_zod13.default.string().describe("Unique identifier for the todo item")
 });
 var TodoWriteTool = new ExuluTool({
   id: "todo_write",
@@ -13577,8 +14842,8 @@ var TodoWriteTool = new ExuluTool({
       default: todowrite_default
     }
   ],
-  inputSchema: import_zod14.default.object({
-    todos: import_zod14.default.array(TodoSchema).describe("The updated todo list")
+  inputSchema: import_zod13.default.object({
+    todos: import_zod13.default.array(TodoSchema).describe("The updated todo list")
   }),
   execute: async (inputs) => {
     const { sessionID, todos, user } = inputs;
@@ -13613,7 +14878,7 @@ var TodoReadTool = new ExuluTool({
   id: "todo_read",
   name: "Todo Read",
   description: "Use this tool to read your todo list",
-  inputSchema: import_zod14.default.object({}),
+  inputSchema: import_zod13.default.object({}),
   type: "function",
   category: "todo",
   config: [
@@ -13739,18 +15004,18 @@ After asking a question, use the Question Read tool to check if the user has ans
 var questionread_default = 'Use this tool to read questions you\'ve asked and check if they\'ve been answered by the user. This tool helps you track the status of questions and retrieve the user\'s selected answers.\n\n## When to Use This Tool\n\nUse this tool proactively in these situations:\n- After asking a question to check if the user has responded\n- To retrieve the user\'s answer before proceeding with implementation\n- To review all questions and answers in the current session\n- When you need to reference a previous answer\n\n## How It Works\n\n- This tool takes no parameters (leave the input blank or empty)\n- Returns an array of all questions in the session\n- Each question includes:\n  - `id`: Unique identifier for the question\n  - `question`: The question text\n  - `answerOptions`: Array of answer options with their IDs and text\n  - `status`: Either "pending" (not answered) or "answered"\n  - `selectedAnswerId`: The ID of the chosen answer (only present if answered)\n\n## Usage Pattern\n\nTypically you\'ll:\n1. Use Question Ask to pose a question\n2. Wait for the user to respond\n3. Use Question Read to check the answer\n4. Find the selected answer by matching the `selectedAnswerId` with an option in `answerOptions`\n5. Proceed with implementation based on the user\'s choice\n\n## Example Response\n\n```json\n[\n  {\n    "id": "question123",\n    "question": "Which authentication method would you like to implement?",\n    "answerOptions": [\n      { "id": "ans1", "text": "JWT tokens" },\n      { "id": "ans2", "text": "OAuth 2.0" },\n      { "id": "ans3", "text": "Session-based auth" },\n      { "id": "ans4", "text": "None of the above..." }\n    ],\n    "status": "answered",\n    "selectedAnswerId": "ans1"\n  }\n]\n```\n\nIn this example, the user selected "JWT tokens" (id: ans1).\n\n## Important Notes\n\n- If no questions exist in the session, an empty array will be returned\n- Questions remain in the session even after being answered for reference\n- Use the `selectedAnswerId` to find which answer option the user chose by matching it against the `id` field in `answerOptions`\n';
 
 // src/templates/tools/question/question.ts
-var import_zod15 = __toESM(require("zod"), 1);
-var import_node_crypto6 = require("crypto");
-var AnswerOptionSchema = import_zod15.default.object({
-  id: import_zod15.default.string().describe("Unique identifier for the answer option"),
-  text: import_zod15.default.string().describe("The text of the answer option")
+var import_zod14 = __toESM(require("zod"), 1);
+var import_node_crypto7 = require("crypto");
+var AnswerOptionSchema = import_zod14.default.object({
+  id: import_zod14.default.string().describe("Unique identifier for the answer option"),
+  text: import_zod14.default.string().describe("The text of the answer option")
 });
-var _QuestionSchema = import_zod15.default.object({
-  id: import_zod15.default.string().describe("Unique identifier for the question"),
-  question: import_zod15.default.string().describe("The question to ask the user"),
-  answerOptions: import_zod15.default.array(AnswerOptionSchema).describe("Array of possible answer options"),
-  selectedAnswerId: import_zod15.default.string().optional().describe("The ID of the answer option selected by the user"),
-  status: import_zod15.default.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
+var _QuestionSchema = import_zod14.default.object({
+  id: import_zod14.default.string().describe("Unique identifier for the question"),
+  question: import_zod14.default.string().describe("The question to ask the user"),
+  answerOptions: import_zod14.default.array(AnswerOptionSchema).describe("Array of possible answer options"),
+  selectedAnswerId: import_zod14.default.string().optional().describe("The ID of the answer option selected by the user"),
+  status: import_zod14.default.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
 });
 var QuestionAskTool = new ExuluTool({
   id: "question_ask",
@@ -13758,6 +15023,7 @@ var QuestionAskTool = new ExuluTool({
   description: "Use this tool to ask a question to the user with multiple choice answers",
   type: "function",
   category: "question",
+  needsApproval: false,
   config: [
     {
       name: "description",
@@ -13766,9 +15032,9 @@ var QuestionAskTool = new ExuluTool({
       default: questionask_default
     }
   ],
-  inputSchema: import_zod15.default.object({
-    question: import_zod15.default.string().describe("The question to ask the user"),
-    answerOptions: import_zod15.default.array(import_zod15.default.string()).describe("Array of possible answer options (strings)")
+  inputSchema: import_zod14.default.object({
+    question: import_zod14.default.string().describe("The question to ask the user"),
+    answerOptions: import_zod14.default.array(import_zod14.default.string()).describe("Array of possible answer options (strings)")
   }),
   execute: async (inputs) => {
     const { sessionID, question, answerOptions, user } = inputs;
@@ -13793,15 +15059,15 @@ var QuestionAskTool = new ExuluTool({
       throw new Error("You don't have access to this session " + session.id + ".");
     }
     const answerOptionsWithIds = answerOptions.map((text) => ({
-      id: (0, import_node_crypto6.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       text
     }));
     answerOptionsWithIds.push({
-      id: (0, import_node_crypto6.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       text: "None of the above..."
     });
     const newQuestion = {
-      id: (0, import_node_crypto6.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       question,
       answerOptions: answerOptionsWithIds,
       status: "pending"
@@ -13827,8 +15093,9 @@ var QuestionAskTool = new ExuluTool({
 var QuestionReadTool = new ExuluTool({
   id: "question_read",
   name: "Question Read",
+  needsApproval: false,
   description: "Use this tool to read questions and their answers",
-  inputSchema: import_zod15.default.object({}),
+  inputSchema: import_zod14.default.object({}),
   type: "function",
   category: "question",
   config: [
@@ -13868,15 +15135,15 @@ async function getQuestions(sessionID) {
 var questionTools = [QuestionAskTool, QuestionReadTool];
 
 // src/templates/tools/perplexity.ts
-var import_zod16 = __toESM(require("zod"), 1);
+var import_zod15 = __toESM(require("zod"), 1);
 var import_perplexity_ai = __toESM(require("@perplexity-ai/perplexity_ai"), 1);
 var internetSearchTool = new ExuluTool({
   id: "internet_search",
-  name: "Perplexity Live Internet Search",
+  name: "Internet Search",
   description: "Search the internet for information.",
-  inputSchema: import_zod16.default.object({
-    query: import_zod16.default.string().describe("The query to the tool."),
-    search_recency_filter: import_zod16.default.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
+  inputSchema: import_zod15.default.object({
+    query: import_zod15.default.string().describe("The query to the tool."),
+    search_recency_filter: import_zod15.default.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
   }),
   category: "internet_search",
   type: "web_search",
@@ -13954,7 +15221,7 @@ var internetSearchTool = new ExuluTool({
       } catch (error) {
         if (error instanceof import_perplexity_ai.default.RateLimitError && attempt < maxRetries - 1) {
           const delay = Math.pow(2, attempt) * 1e3 + Math.random() * 1e3;
-          await new Promise((resolve4) => setTimeout(resolve4, delay));
+          await new Promise((resolve3) => setTimeout(resolve3, delay));
           continue;
         }
         throw error;
@@ -13967,6 +15234,101 @@ var internetSearchTool = new ExuluTool({
 });
 var perplexityTools = [internetSearchTool];
 
+// src/templates/tools/email.ts
+var nodemailer = __toESM(require("nodemailer"), 1);
+var import_zod16 = require("zod");
+var transporter = null;
+function getTransporter(config) {
+  if (!transporter) {
+    transporter = nodemailer.createTransport(config);
+  }
+  return transporter;
+}
+async function sendEmail(recipient, subject, html, text, config) {
+  const transport = getTransporter(config);
+  html = html.trim();
+  text = text.trim();
+  await transport.sendMail({
+    from: config.from,
+    to: recipient,
+    subject,
+    text,
+    html
+  });
+}
+var emailTool = new ExuluTool({
+  id: "email",
+  name: "Email",
+  description: "Send an email.",
+  inputSchema: import_zod16.z.object({
+    recipient: import_zod16.z.string().describe("The recipient of the email."),
+    subject: import_zod16.z.string().describe("The subject of the email."),
+    html: import_zod16.z.string().describe("The HTML body of the email."),
+    text: import_zod16.z.string().describe("The text body of the email.")
+  }),
+  type: "function",
+  config: [{
+    name: "smtp_host",
+    description: "The SMTP host to send the email from.",
+    type: "variable",
+    default: void 0
+  }, {
+    name: "smtp_port",
+    description: "The SMTP port to send the email from.",
+    type: "variable",
+    default: void 0
+  }, {
+    name: "smtp_user",
+    description: "The SMTP user to send the email from.",
+    type: "variable",
+    default: void 0
+  }, {
+    name: "smtp_password",
+    description: "The SMTP password to send the email from.",
+    type: "variable",
+    default: void 0
+  }, {
+    name: "smtp_from",
+    description: "The SMTP from address to send the email from.",
+    type: "variable",
+    default: void 0
+  }, {
+    name: "allowed_recipient_domains",
+    description: "A comma seperated list of allowed recipient domains to send emails to.",
+    type: "string",
+    default: void 0
+  }],
+  execute: async ({ recipient, subject, html, text, toolVariablesConfig }) => {
+    const EMAIL_CONFIG = {
+      host: toolVariablesConfig.smtp_host || process.env.SMTP_HOST || "",
+      port: parseInt(toolVariablesConfig.smtp_port || process.env.SMTP_PORT || "587", 10),
+      secure: toolVariablesConfig.smtp_secure === "true" || process.env.SMTP_SECURE === "true",
+      // true for 465, false for other ports
+      auth: {
+        user: toolVariablesConfig.smtp_user || process.env.SMTP_USER || "",
+        pass: toolVariablesConfig.smtp_password || process.env.SMTP_PASSWORD || ""
+      },
+      from: toolVariablesConfig.smtp_from || process.env.SMTP_FROM || "",
+      // Allow self-signed certificates if SMTP_REJECT_UNAUTHORIZED is set to 'false'
+      tls: {
+        rejectUnauthorized: false
+      }
+    };
+    if (toolVariablesConfig.allowed_recipient_domains) {
+      const allowedRecipientDomains = toolVariablesConfig.allowed_recipient_domains.split(",");
+      if (!allowedRecipientDomains.some((domain) => recipient.endsWith(`@${domain}`))) {
+        return {
+          result: "Recipient domain not allowed to send emails to."
+        };
+      }
+    }
+    await sendEmail(recipient, subject, html, text, EMAIL_CONFIG);
+    return {
+      result: "Email sent successfully to " + recipient + " with subject " + subject + "."
+    };
+  }
+});
+
 // src/validators/postgres-name.ts
 var isValidPostgresName = (id) => {
   const regex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -14071,8 +15433,7 @@ var ExuluApp2 = class {
       ...todoTools,
       ...questionTools,
       ...perplexityTools,
-      // Add contexts as tools
-      ...Object.values(contexts || {}).map((context) => context.tool()).filter(Boolean)
+      emailTool
       // Because agents are stored in the database, we add those as tools
       // at request time, not during ExuluApp initialization. We add them
       // in the grahql tools resolver.
@@ -14089,9 +15450,9 @@ var ExuluApp2 = class {
         id: provider.id ?? "",
         type: "agent"
       })),
-      ...this._tools.map((tool6) => ({
-        name: tool6.name ?? "",
-        id: tool6.id ?? "",
+      ...this._tools.map((tool5) => ({
+        name: tool5.name ?? "",
+        id: tool5.id ?? "",
         type: "tool"
       })),
       ...this._rerankers.map((reranker) => ({
@@ -14137,7 +15498,7 @@ var ExuluApp2 = class {
   express = {
     init: async () => {
       if (!this._expressApp) {
-        this._expressApp = (0, import_express7.default)();
+        this._expressApp = (0, import_express8.default)();
         await this.server.express.init();
         console.log("[EXULU] Express app initialized.");
       }
@@ -15353,7 +16714,7 @@ var RecursiveChunker = class _RecursiveChunker extends BaseChunker {
 };
 
 // src/exulu/embedder.ts
-var import_crypto_js8 = __toESM(require("crypto-js"), 1);
+var import_crypto_js9 = __toESM(require("crypto-js"), 1);
 var ExuluEmbedder = class {
   id;
   name;
@@ -15424,8 +16785,8 @@ var ExuluEmbedder = class {
           );
         }
         try {
-          const bytes = import_crypto_js8.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-          const decrypted = bytes.toString(import_crypto_js8.default.enc.Utf8);
+          const bytes = import_crypto_js9.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+          const decrypted = bytes.toString(import_crypto_js9.default.enc.Utf8);
           if (!decrypted) {
             throw new Error("Decryption returned empty string - invalid key or corrupted data");
           }
@@ -15913,6 +17274,7 @@ var {
   agentMessagesSchema: agentMessagesSchema3,
   rolesSchema: rolesSchema3,
   usersSchema: usersSchema3,
+  skillsSchema: skillsSchema3,
   statisticsSchema: statisticsSchema3,
   variablesSchema: variablesSchema3,
   workflowTemplatesSchema: workflowTemplatesSchema3,
@@ -15963,6 +17325,7 @@ var up = async function(knex) {
     agentsSchema3(),
     feedbackSchema3(),
     variablesSchema3(),
+    skillsSchema3(),
     workflowTemplatesSchema3()
   ];
   const createTable = async (schema) => {
@@ -16165,7 +17528,7 @@ var create = ({
 };
 
 // src/index.ts
-var import_crypto_js9 = __toESM(require("crypto-js"), 1);
+var import_crypto_js10 = __toESM(require("crypto-js"), 1);
 
 // ee/chunking/markdown.ts
 var extractPageTag = (text) => {
@@ -16649,7 +18012,7 @@ var MarkdownChunker = class {
 var import_child_process = require("child_process");
 var import_util2 = require("util");
 var import_path = require("path");
-var import_fs4 = require("fs");
+var import_fs3 = require("fs");
 var import_url = require("url");
 var execAsync = (0, import_util2.promisify)(import_child_process.exec);
 function getPackageRoot() {
@@ -16659,9 +18022,9 @@ function getPackageRoot() {
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     const packageJsonPath = (0, import_path.join)(currentDir, "package.json");
-    if ((0, import_fs4.existsSync)(packageJsonPath)) {
+    if ((0, import_fs3.existsSync)(packageJsonPath)) {
       try {
-        const packageJson = JSON.parse((0, import_fs4.readFileSync)(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse((0, import_fs3.readFileSync)(packageJsonPath, "utf-8"));
         if (packageJson.name === "@exulu/backend") {
           return currentDir;
         }
@@ -16688,7 +18051,7 @@ function isPythonEnvironmentSetup(packageRoot) {
   const root = packageRoot ?? getPackageRoot();
   const venvPath = getVenvPath(root);
   const pythonPath = (0, import_path.join)(venvPath, "bin", "python");
-  return (0, import_fs4.existsSync)(venvPath) && (0, import_fs4.existsSync)(pythonPath);
+  return (0, import_fs3.existsSync)(venvPath) && (0, import_fs3.existsSync)(pythonPath);
 }
 async function setupPythonEnvironment(options = {}) {
   const {
@@ -16709,7 +18072,7 @@ async function setupPythonEnvironment(options = {}) {
     };
   }
   const setupScriptPath = getSetupScriptPath(packageRoot);
-  if (!(0, import_fs4.existsSync)(setupScriptPath)) {
+  if (!(0, import_fs3.existsSync)(setupScriptPath)) {
     return {
       success: false,
       message: `Setup script not found at: ${setupScriptPath}`,
@@ -16791,13 +18154,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_fs4.existsSync)(venvPath)) {
+  if (!(0, import_fs3.existsSync)(venvPath)) {
     return {
       valid: false,
       message: getPythonSetupInstructions()
     };
   }
-  if (!(0, import_fs4.existsSync)(pythonPath)) {
+  if (!(0, import_fs3.existsSync)(pythonPath)) {
     return {
       valid: false,
       message: "Python virtual environment is corrupted. Please run:\n  await setupPythonEnvironment({ force: true })"
@@ -16849,9 +18212,9 @@ Or manually run the setup script:
 }
 
 // ee/python/documents/processing/doc_processor.ts
-var fs5 = __toESM(require("fs"), 1);
+var fs4 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
-var import_ai11 = require("ai");
+var import_ai12 = require("ai");
 var import_zod17 = require("zod");
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_crypto = require("crypto");
@@ -16864,7 +18227,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_fs5 = require("fs");
+var import_fs4 = require("fs");
 var import_url2 = require("url");
 var execAsync2 = (0, import_util3.promisify)(import_child_process2.exec);
 function getPackageRoot2() {
@@ -16874,9 +18237,9 @@ function getPackageRoot2() {
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     const packageJsonPath = (0, import_path2.join)(currentDir, "package.json");
-    if ((0, import_fs5.existsSync)(packageJsonPath)) {
+    if ((0, import_fs4.existsSync)(packageJsonPath)) {
       try {
-        const packageJson = JSON.parse((0, import_fs5.readFileSync)(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse((0, import_fs4.readFileSync)(packageJsonPath, "utf-8"));
         if (packageJson.name === "@exulu/backend") {
           return currentDir;
         }
@@ -16938,7 +18301,7 @@ async function executePythonScript(config) {
     await validatePythonEnvironmentForExecution(packageRoot);
   }
   const resolvedScriptPath = (0, import_path2.resolve)(packageRoot, scriptPath);
-  if (!(0, import_fs5.existsSync)(resolvedScriptPath)) {
+  if (!(0, import_fs4.existsSync)(resolvedScriptPath)) {
     throw new PythonExecutionError(
       `Python script not found: ${resolvedScriptPath}`,
       "",
@@ -17031,6 +18394,55 @@ async function processWord(file) {
     markdown: content
   };
 }
+async function processImage(buffer, paths, config, verbose = false) {
+  try {
+    await fs4.promises.mkdir(paths.images, { recursive: true });
+    const imagePath = path2.join(paths.images, "1.png");
+    await fs4.promises.writeFile(imagePath, buffer);
+    console.log(`[EXULU] Image saved to: ${imagePath}`);
+    let json = [{
+      page: 1,
+      content: "",
+      // Empty initially, will be populated by VLM if enabled
+      image: imagePath,
+      headings: []
+    }];
+    if (config?.vlm?.model) {
+      console.log("[EXULU] Extracting content from image using VLM...");
+      json = await validateWithVLM(
+        json,
+        config.vlm.model,
+        verbose,
+        config.vlm.concurrency
+      );
+      await fs4.promises.writeFile(
+        paths.json,
+        JSON.stringify(json, null, 2),
+        "utf-8"
+      );
+      console.log("[EXULU] VLM content extraction complete");
+      const correctedCount = json.filter((p) => p.vlm_corrected_text).length;
+      console.log(`[EXULU] Content extracted: ${correctedCount > 0 ? "Yes" : "No"}`);
+    } else {
+      console.log("[EXULU] No VLM configured, image saved without content extraction");
+      console.log("[EXULU] Note: Enable VLM in config to extract text/content from images");
+      await fs4.promises.writeFile(
+        paths.json,
+        JSON.stringify(json, null, 2),
+        "utf-8"
+      );
+    }
+    const markdown = json.map((p) => p.vlm_corrected_text ?? p.content).join("\n\n\n<!-- END_OF_PAGE -->\n\n\n");
+    await fs4.promises.writeFile(paths.markdown, markdown, "utf-8");
+    return {
+      markdown,
+      json
+    };
+  } catch (error) {
+    console.error("[EXULU] Error processing image:", error);
+    throw error;
+  }
+}
 function normalizeMarkdownContent(content) {
   const lines = content.split("\n");
   const normalizedLines = [];
@@ -17074,7 +18486,7 @@ function reconstructHeadings(correctedText, headingsHierarchy) {
   return result;
 }
 async function validatePageWithVLM(page, imagePath, model) {
-  const imageBuffer = await fs5.promises.readFile(imagePath);
+  const imageBuffer = await fs4.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.
@@ -17152,9 +18564,9 @@ If the page contains a flow-chart, schematic, technical drawing or control board
 
 ### 7. Only populate \`corrected_text\` when \`needs_correction\` is true. If the OCR output is accurate, return \`needs_correction: false\` and \`corrected_content: null\`.
 `;
-  const result = await (0, import_ai11.generateText)({
+  const result = await (0, import_ai12.generateText)({
     model,
-    output: import_ai11.Output.object({
+    output: import_ai12.Output.object({
       schema: import_zod17.z.object({
         needs_correction: import_zod17.z.boolean(),
         corrected_text: import_zod17.z.string().nullable(),
@@ -17187,6 +18599,7 @@ If the page contains a flow-chart, schematic, technical drawing or control board
     current_page_table: parsedOutput.current_page_table || void 0,
     reasoning: parsedOutput.reasoning
   };
+  console.log(`[EXULU] VLM validation result: ${JSON.stringify(validation)}`);
   return validation;
 }
 function reconstructTableHeaders(document2, validationResults, verbose = false) {
@@ -17242,26 +18655,29 @@ async function validateWithVLM(document2, model, verbose = false, concurrency =
   let correctedCount = 0;
   const validationTasks = document2.map(
     (page) => limit(async () => {
-      await new Promise((resolve4) => setImmediate(resolve4));
+      await new Promise((resolve3) => setImmediate(resolve3));
       const imagePath = page.image;
-      if (!page.content) {
-        console.warn(`[EXULU] Page ${page.page}: No content found, skipping validation`);
-        return;
-      }
       if (!imagePath) {
         console.warn(`[EXULU] Page ${page.page}: No image found, skipping validation`);
         return;
       }
-      const hasImage = page.content.match(/\.(jpeg|jpg|png|gif|webp)/i);
-      const hasTable = (page.content.match(/\|/g)?.length || 0) > 1;
-      if (!hasImage && !hasTable) {
+      if (page.content) {
+        const hasImage = page.content.match(/\.(jpeg|jpg|png|gif|webp)/i);
+        const hasTable = (page.content.match(/\|/g)?.length || 0) > 1;
+        if (!hasImage && !hasTable) {
+          if (verbose) {
+            console.log(`[EXULU] Page ${page.page}: No image or table found, SKIPPING VLM validation`);
+          }
+          return;
+        }
+      } else {
         if (verbose) {
-          console.log(`[EXULU] Page ${page.page}: No image or table found, SKIPPING VLM validation`);
+          console.log(`[EXULU] Page ${page.page}: Standalone image, proceeding with VLM content extraction`);
         }
-        return;
       }
       let validation;
       try {
+        console.log(`[EXULU] Validating page ${page.page} with VLM`);
         validation = await withRetry(async () => {
           return await validatePageWithVLM(page, imagePath, model);
         }, 3);
@@ -17344,6 +18760,13 @@ async function processDocument(filePath, fileType, buffer, tempDir, config, verb
     case "doc":
       result = await processWord(buffer);
       break;
+    case "jpg":
+    case "jpeg":
+    case "png":
+    case "gif":
+    case "webp":
+      result = await processImage(buffer, paths, config, verbose);
+      break;
     // Todo other file types with docx and officeparser
     default:
       throw new Error(`[EXULU] Unsupported file type: ${fileType}`);
@@ -17406,7 +18829,7 @@ ${setupResult.output || ""}`);
       if (!result.success) {
         throw new Error(`Document processing failed: ${result.stderr}`);
       }
-      const jsonContent = await fs5.promises.readFile(paths.json, "utf-8");
+      const jsonContent = await fs4.promises.readFile(paths.json, "utf-8");
       json = JSON.parse(jsonContent);
     } else if (config?.processor.name === "officeparser") {
       const text = await (0, import_officeparser2.parseOfficeAsync)(buffer, {
@@ -17423,7 +18846,7 @@ ${setupResult.output || ""}`);
       if (!MISTRAL_API_KEY) {
         throw new Error('[EXULU] MISTRAL_API_KEY is not set, please set it in the environment variable via process.env or via an Exulu variable named "MISTRAL_API_KEY".');
       }
-      await new Promise((resolve4) => setTimeout(resolve4, Math.floor(Math.random() * 4e3) + 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, Math.floor(Math.random() * 4e3) + 1e3));
       const base64Pdf = buffer.toString("base64");
       const client2 = new import_mistralai.Mistral({ apiKey: MISTRAL_API_KEY });
       const ocrResponse = await withRetry(async () => {
@@ -17439,9 +18862,9 @@ ${setupResult.output || ""}`);
       }, 10);
       const parser = new import_liteparse.LiteParse();
       const screenshots = await parser.screenshot(paths.source, void 0);
-      await fs5.promises.mkdir(paths.images, { recursive: true });
+      await fs4.promises.mkdir(paths.images, { recursive: true });
       for (const screenshot of screenshots) {
-        await fs5.promises.writeFile(
+        await fs4.promises.writeFile(
           path2.join(
             paths.images,
             `${screenshot.pageNum}.png`
@@ -17456,15 +18879,15 @@ ${setupResult.output || ""}`);
         image: screenshots.find((s) => s.pageNum === page.index + 1)?.imagePath,
         headings: []
       }));
-      fs5.writeFileSync(paths.json, JSON.stringify(json, null, 2));
+      fs4.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 fs5.promises.mkdir(paths.images, { recursive: true });
+      await fs4.promises.mkdir(paths.images, { recursive: true });
       for (const screenshot of screenshots) {
-        await fs5.promises.writeFile(path2.join(paths.images, `${screenshot.pageNum}.png`), screenshot.imageBuffer);
+        await fs4.promises.writeFile(path2.join(paths.images, `${screenshot.pageNum}.png`), screenshot.imageBuffer);
         screenshot.imagePath = path2.join(paths.images, `${screenshot.pageNum}.png`);
       }
       json = result.pages.map((page) => ({
@@ -17472,7 +18895,7 @@ ${setupResult.output || ""}`);
         content: page.text,
         image: screenshots.find((s) => s.pageNum === page.pageNum)?.imagePath
       }));
-      fs5.writeFileSync(paths.json, JSON.stringify(json, null, 2));
+      fs4.writeFileSync(paths.json, JSON.stringify(json, null, 2));
     }
     console.log(`[EXULU] 
 \u2713 Document processing completed successfully`);
@@ -17503,13 +18926,13 @@ ${setupResult.output || ""}`);
           console.log(`[EXULU]    Corrected: ${page.vlm_corrected_text.substring(0, 150)}...`);
         });
       }
-      await fs5.promises.writeFile(
+      await fs4.promises.writeFile(
         paths.json,
         JSON.stringify(json, null, 2),
         "utf-8"
       );
     }
-    const markdownStream = fs5.createWriteStream(paths.markdown, { encoding: "utf-8" });
+    const markdownStream = fs4.createWriteStream(paths.markdown, { encoding: "utf-8" });
     for (let i = 0; i < json.length; i++) {
       const p = json[i];
       if (!p) continue;
@@ -17519,13 +18942,13 @@ ${setupResult.output || ""}`);
         markdownStream.write("\n\n\n<!-- END_OF_PAGE -->\n\n\n");
       }
     }
-    await new Promise((resolve4, reject) => {
-      markdownStream.end(() => resolve4());
+    await new Promise((resolve3, reject) => {
+      markdownStream.end(() => resolve3());
       markdownStream.on("error", reject);
     });
     console.log(`[EXULU] Validated output saved to: ${paths.json}`);
     console.log(`[EXULU] Validated markdown saved to: ${paths.markdown}`);
-    const markdown = await fs5.promises.readFile(paths.markdown, "utf-8");
+    const markdown = await fs4.promises.readFile(paths.markdown, "utf-8");
     const processedJson = json.map((e) => {
       const finalContent = e.vlm_corrected_text ?? e.content;
       return {
@@ -17556,7 +18979,7 @@ var loadFile = async (file, name, tempDir) => {
   let buffer;
   if (Buffer.isBuffer(file)) {
     filePath = path2.join(tempDir, `${UUID}.${fileType}`);
-    await fs5.promises.writeFile(filePath, file);
+    await fs4.promises.writeFile(filePath, file);
     buffer = file;
   } else {
     filePath = filePath.trim();
@@ -17564,11 +18987,11 @@ var loadFile = async (file, name, tempDir) => {
       const response = await fetch(filePath);
       const array = await response.arrayBuffer();
       const tempFilePath = path2.join(tempDir, `${UUID}.${fileType}`);
-      await fs5.promises.writeFile(tempFilePath, Buffer.from(array));
+      await fs4.promises.writeFile(tempFilePath, Buffer.from(array));
       buffer = Buffer.from(array);
       filePath = tempFilePath;
     } else {
-      buffer = await fs5.promises.readFile(file);
+      buffer = await fs4.promises.readFile(file);
     }
   }
   return { filePath, fileType, buffer };
@@ -17586,9 +19009,9 @@ async function documentProcessor({
   const tempDir = path2.join(process.cwd(), "temp", uuid);
   const localFilesAndFoldersToDelete = [tempDir];
   console.log(`[EXULU] Temporary directory for processing document ${name}: ${tempDir}`);
-  await fs5.promises.mkdir(tempDir, { recursive: true });
+  await fs4.promises.mkdir(tempDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  await fs5.promises.writeFile(path2.join(tempDir, "created_at.txt"), timestamp);
+  await fs4.promises.writeFile(path2.join(tempDir, "created_at.txt"), timestamp);
   try {
     const {
       filePath,
@@ -17598,7 +19021,7 @@ async function documentProcessor({
     let supportedTypes = [];
     switch (config?.processor.name) {
       case "docling":
-        supportedTypes = ["pdf", "docx", "doc", "txt", "md"];
+        supportedTypes = ["pdf", "docx", "doc", "txt", "md", "jpg", "jpeg", "png", "gif", "webp"];
         break;
       case "officeparser":
         supportedTypes = [];
@@ -17607,7 +19030,7 @@ async function documentProcessor({
         supportedTypes = ["pdf", "doc", "docx", "docm", "odt", "rtf", "ppt", "pptx", "pptm", "odp", "xls", "xlsx", "xlsm", "ods", "csv", "tsv"];
         break;
       case "mistral":
-        supportedTypes = ["pdf", "docx", "doc", "txt", "md"];
+        supportedTypes = ["pdf", "docx", "doc", "txt", "md", "jpg", "jpeg", "png", "gif", "webp"];
         break;
     }
     if (!supportedTypes.includes(fileType)) {
@@ -17629,7 +19052,7 @@ async function documentProcessor({
     if (config?.debugging?.deleteTempFiles !== false) {
       for (const file2 of localFilesAndFoldersToDelete) {
         try {
-          await fs5.promises.rm(file2, { recursive: true });
+          await fs4.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);
@@ -17640,634 +19063,6 @@ async function documentProcessor({
   }
 }
 
-// ee/agentic-retrieval/v4/index.ts
-var os = __toESM(require("os"), 1);
-var path4 = __toESM(require("path"), 1);
-var fs7 = __toESM(require("fs/promises"), 1);
-var import_zod19 = require("zod");
-var import_crypto2 = require("crypto");
-
-// ee/agentic-retrieval/v4/tools.ts
-var fs6 = __toESM(require("fs/promises"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_child_process3 = require("child_process");
-var import_util4 = require("util");
-var import_zod18 = require("zod");
-var import_ai12 = require("ai");
-
-// ee/agentic-retrieval/v4/embed-preprocessor.ts
-async function preprocessEmbedCalls(sql, contexts, user, role) {
-  const EMBED_RE = /embed\('((?:[^'\\]|\\.)*)'\s*(?:,\s*'((?:[^'\\]|\\.)*)')?\)/gi;
-  const matches = [];
-  let m;
-  while ((m = EMBED_RE.exec(sql)) !== null) {
-    matches.push({
-      fullMatch: m[0],
-      text: m[1],
-      contextId: m[2] || void 0,
-      index: m.index
-    });
-  }
-  if (matches.length === 0) return sql;
-  const substitutions = await Promise.all(
-    matches.map(async ({ text, contextId }) => {
-      const context = contextId ? contexts.find((c) => c.id === contextId) : contexts.find((c) => c.embedder != null);
-      if (!context?.embedder) {
-        throw new Error(
-          `No embedder available${contextId ? ` for context "${contextId}"` : ""}. Available contexts with embedders: [${contexts.filter((c) => c.embedder).map((c) => c.id).join(", ")}]`
-        );
-      }
-      const result2 = await context.embedder.generateFromQuery(
-        context.id,
-        text,
-        void 0,
-        user?.id,
-        role
-      );
-      const vector = result2?.chunks?.[0]?.vector;
-      if (!vector?.length) {
-        throw new Error(`Embedder returned no vector for text: "${text}"`);
-      }
-      return `ARRAY[${vector.join(",")}]::vector`;
-    })
-  );
-  let result = sql;
-  for (let i = matches.length - 1; i >= 0; i--) {
-    const { fullMatch, index } = matches[i];
-    result = result.slice(0, index) + substitutions[i] + result.slice(index + fullMatch.length);
-  }
-  return result;
-}
-
-// ee/agentic-retrieval/v4/tools.ts
-var execAsync3 = (0, import_util4.promisify)(import_child_process3.exec);
-var MAX_INLINE_CHARS = 2e4;
-var MAX_GREP_OUTPUT_CHARS = 5e3;
-var WRITE_PATTERN = /^\s*(INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|GRANT|REVOKE|VACUUM|ANALYZE|EXPLAIN\s+ANALYZE)\b/i;
-function assertReadOnly(sql) {
-  if (WRITE_PATTERN.test(sql)) {
-    throw new Error(
-      "Only SELECT queries are allowed. Write operations (INSERT, UPDATE, DELETE, DROP, etc.) are not permitted."
-    );
-  }
-}
-function rowToChunkResult(row) {
-  const chunkId = row.chunk_id ?? row.id;
-  const chunkContent = row.chunk_content ?? row.content;
-  const itemId = row.item_id ?? row.source;
-  const context = row.context ?? row.context_id;
-  const itemName = row.item_name ?? row.name;
-  if (!chunkId || !chunkContent && !itemId) return null;
-  return {
-    item_name: itemName ?? "",
-    item_id: itemId ?? "",
-    context: context ?? "",
-    chunk_id: chunkId,
-    chunk_index: row.chunk_index ?? void 0,
-    chunk_content: chunkContent ?? void 0,
-    metadata: row.metadata ?? row.chunk_metadata ?? void 0
-  };
-}
-function createTools(params) {
-  const { contexts, user, role, sessionDir } = params;
-  let queryCount = 0;
-  const execute_query = (0, import_ai12.tool)({
-    description: `Execute a read-only PostgreSQL SELECT query against the knowledge base.
-
-Use this to search, filter, aggregate, and explore content. The database contains items
-and chunks tables for each knowledge base (see schema in the system prompt).
-
-Use embed('your text') anywhere in the query to generate a semantic search vector:
-  embedding <=> embed('machine learning') AS distance
-
-If the result exceeds ${(MAX_INLINE_CHARS / 1e3).toFixed(0)}k characters it is saved to a file.
-Use the grep tool to iteratively search the file for relevant information.`,
-    inputSchema: import_zod18.z.object({
-      sql: import_zod18.z.string().describe("A read-only SELECT (or WITH ... SELECT) PostgreSQL query")
-    }),
-    execute: async ({ sql }) => {
-      assertReadOnly(sql);
-      let processedSql;
-      try {
-        processedSql = await preprocessEmbedCalls(sql, contexts, user, role);
-      } catch (err) {
-        return JSON.stringify({ error: `embed() preprocessing failed: ${err.message}` });
-      }
-      let rows;
-      try {
-        const { db: db2 } = await postgresClient();
-        const result = await db2.raw(processedSql);
-        rows = result.rows ?? [];
-      } catch (err) {
-        return JSON.stringify({ error: `Query failed: ${err.message}` });
-      }
-      const json = JSON.stringify(rows, null, 2);
-      if (json.length <= MAX_INLINE_CHARS) {
-        return json;
-      }
-      await fs6.mkdir(sessionDir, { recursive: true });
-      const filename = `query_${++queryCount}.json`;
-      const filePath = path3.join(sessionDir, filename);
-      await fs6.writeFile(filePath, json, "utf-8");
-      return JSON.stringify({
-        stored: true,
-        file: filePath,
-        row_count: rows.length,
-        message: `Results too large to display (${rows.length} rows, ${(json.length / 1e3).toFixed(1)}k chars). Stored at ${filePath}. Use the grep tool to search for relevant information.`,
-        grep_hint: `grep -i "keyword" ${filePath}`
-      });
-    }
-  });
-  const grep = (0, import_ai12.tool)({
-    description: `Search a stored query result file using grep.
-
-Use this after execute_query returns a file path because results were too large.
-Iteratively narrow down the results with multiple grep calls.`,
-    inputSchema: import_zod18.z.object({
-      pattern: import_zod18.z.string().describe("Regular expression or literal string to search for"),
-      file: import_zod18.z.string().describe("Absolute path to the file returned by execute_query"),
-      context_lines: import_zod18.z.number().int().min(0).max(10).default(2).describe("Number of lines of context to show around each match (default 2)"),
-      case_insensitive: import_zod18.z.boolean().default(true).describe("Case-insensitive matching (default true)")
-    }),
-    execute: async ({ pattern, file, context_lines, case_insensitive }) => {
-      const resolvedFile = path3.resolve(file);
-      const resolvedSession = path3.resolve(sessionDir);
-      if (!resolvedFile.startsWith(resolvedSession)) {
-        return JSON.stringify({
-          error: `Access denied. Only files within the session directory (${sessionDir}) can be searched.`
-        });
-      }
-      try {
-        await fs6.access(resolvedFile);
-      } catch {
-        return JSON.stringify({ error: `File not found: ${file}` });
-      }
-      const flags = [
-        "-n",
-        context_lines > 0 ? `-C${context_lines}` : "",
-        case_insensitive ? "-i" : ""
-      ].filter(Boolean).join(" ");
-      const escapedPattern = pattern.replace(/'/g, `'\\''`);
-      const cmd = `grep ${flags} '${escapedPattern}' '${resolvedFile}'`;
-      let output;
-      try {
-        const { stdout } = await execAsync3(cmd, { maxBuffer: 10 * 1024 * 1024 });
-        output = stdout;
-      } catch (err) {
-        if (err.code === 1) {
-          return JSON.stringify({ matches: 0, output: "No matches found." });
-        }
-        return JSON.stringify({ error: `grep failed: ${err.message}` });
-      }
-      if (output.length > MAX_GREP_OUTPUT_CHARS) {
-        output = output.slice(0, MAX_GREP_OUTPUT_CHARS) + `
-... (output truncated at ${MAX_GREP_OUTPUT_CHARS} chars \u2014 refine your pattern to narrow results)`;
-      }
-      const lineCount = output.split("\n").filter(Boolean).length;
-      return JSON.stringify({ matches: lineCount, output });
-    }
-  });
-  return { execute_query, grep };
-}
-function harvestChunks(toolResults) {
-  const chunks = [];
-  for (const result of toolResults ?? []) {
-    const rawOutput = result.output ?? result.result;
-    let parsed;
-    try {
-      parsed = typeof rawOutput === "string" ? JSON.parse(rawOutput) : rawOutput;
-    } catch {
-      continue;
-    }
-    if (Array.isArray(parsed)) {
-      for (const row of parsed) {
-        if (row && typeof row === "object") {
-          const chunk = rowToChunkResult(row);
-          if (chunk) chunks.push(chunk);
-        }
-      }
-    }
-  }
-  return chunks;
-}
-
-// ee/agentic-retrieval/v4/system-prompt.ts
-function buildSystemPrompt(contexts, customInstructions) {
-  const schemaBlock = buildSchemaBlock(contexts);
-  const hasEmbedder = contexts.some((c) => c.embedder != null);
-  return `You are a knowledge base retrieval agent. Your job is to find all information relevant to the user's query.
-
-## Approach: Observe \u2192 Infer \u2192 Act
-
-Work iteratively:
-1. **Observe** \u2014 examine what data you have and what the query asks for
-2. **Infer** \u2014 decide what SQL query will best surface relevant information
-3. **Act** \u2014 execute the query and study the results
-4. Repeat until you have found sufficient information, then write your final answer.
-
-Do NOT guess or hallucinate. If results are empty, try alternative queries (different keywords,
-broader filters, semantic search). Exhaust the available search strategies before concluding
-that no relevant data exists.
-
----
-
-## Database Schema
-
-${schemaBlock}
-
----
-
-## Query Patterns
-
-### Keyword / Full-Text Search
-\`\`\`sql
-SELECT
-  c.id          AS chunk_id,
-  c.chunk_index,
-  c.content     AS chunk_content,
-  c.metadata,
-  c.source      AS item_id,
-  i.name        AS item_name,
-  '<context_id>' AS context
-FROM <context_id>_chunks c
-JOIN <context_id>_items i ON c.source = i.id
-WHERE c.fts @@ plainto_tsquery('english', 'your search terms')
-  AND (i.archived IS FALSE OR i.archived IS NULL)
-ORDER BY ts_rank(c.fts, plainto_tsquery('english', 'your search terms')) DESC
-LIMIT 20;
-\`\`\`
-
-For German text use \`'german'\` instead of \`'english'\`.
-For multi-language, use \`websearch_to_tsquery\` or UNION both languages.
-${hasEmbedder ? `
-### Semantic Search (use embed() helper)
-\`\`\`sql
-SELECT
-  c.id          AS chunk_id,
-  c.chunk_index,
-  c.content     AS chunk_content,
-  c.metadata,
-  c.source      AS item_id,
-  i.name        AS item_name,
-  '<context_id>' AS context,
-  c.embedding <=> embed('your concept here') AS distance
-FROM <context_id>_chunks c
-JOIN <context_id>_items i ON c.source = i.id
-WHERE (i.archived IS FALSE OR i.archived IS NULL)
-ORDER BY distance ASC
-LIMIT 20;
-\`\`\`
-
-### Hybrid Search (keyword + semantic combined via RRF)
-\`\`\`sql
-WITH fts AS (
-  SELECT id, ROW_NUMBER() OVER (ORDER BY ts_rank(fts, q) DESC) AS rank
-  FROM <context_id>_chunks, plainto_tsquery('english', 'your query') q
-  WHERE fts @@ q
-  LIMIT 500
-),
-sem AS (
-  SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> embed('your query') ASC) AS rank
-  FROM <context_id>_chunks
-  LIMIT 500
-),
-rrf AS (
-  SELECT
-    COALESCE(fts.id, sem.id) AS id,
-    (COALESCE(1.0 / (50 + fts.rank), 0) * 2 + COALESCE(1.0 / (50 + sem.rank), 0)) AS score
-  FROM fts FULL OUTER JOIN sem ON fts.id = sem.id
-)
-SELECT
-  c.id          AS chunk_id,
-  c.chunk_index,
-  c.content     AS chunk_content,
-  c.metadata,
-  c.source      AS item_id,
-  i.name        AS item_name,
-  '<context_id>' AS context,
-  rrf.score
-FROM rrf
-JOIN <context_id>_chunks c ON c.id = rrf.id
-JOIN <context_id>_items i ON c.source = i.id
-WHERE (i.archived IS FALSE OR i.archived IS NULL)
-ORDER BY rrf.score DESC
-LIMIT 20;
-\`\`\`
-` : `
-Note: No embedder is configured for these contexts. Use keyword/full-text search only.
-`}
-### Browse all chunks of a specific document (in order)
-\`\`\`sql
-SELECT
-  c.id          AS chunk_id,
-  c.chunk_index,
-  c.content     AS chunk_content,
-  c.metadata,
-  c.source      AS item_id,
-  i.name        AS item_name,
-  '<context_id>' AS context
-FROM <context_id>_chunks c
-JOIN <context_id>_items i ON c.source = i.id
-WHERE c.source = '<item_id>'
-ORDER BY c.chunk_index;
-\`\`\`
-
-### Count / aggregate
-\`\`\`sql
-SELECT COUNT(*) FROM <context_id>_items WHERE archived IS FALSE;
-SELECT COUNT(*) FROM <context_id>_chunks;
-\`\`\`
-
-### Explore item names (when query is about a specific document)
-\`\`\`sql
-SELECT id, name, external_id, "createdAt"
-FROM <context_id>_items
-WHERE (archived IS FALSE OR archived IS NULL)
-  AND LOWER(name) LIKE '%keyword%'
-LIMIT 50;
-\`\`\`
-
-### Filter by custom metadata on chunks
-\`\`\`sql
-SELECT chunk_id, chunk_content, item_name, context
-FROM ...
-WHERE c.metadata->>'page' = '5'
-   OR c.metadata @> '{"category": "finance"}'
-\`\`\`
-
----
-
-## Column Alias Convention
-
-**Always use these aliases** in queries that return chunks so results are collected correctly:
-
-| Alias          | Source column           |
-|----------------|-------------------------|
-| \`chunk_id\`     | \`c.id\`                  |
-| \`chunk_index\`  | \`c.chunk_index\`         |
-| \`chunk_content\`| \`c.content\`             |
-| \`item_id\`      | \`c.source\`              |
-| \`item_name\`    | \`i.name\`                |
-| \`context\`      | literal context id string |
-| \`metadata\`     | \`c.metadata\`            |
-
----
-
-## Handling Large Results
-
-When execute_query returns a file path (results > 20k chars):
-1. Use \`grep\` with a specific pattern to find relevant sections
-2. Multiple grep calls are fine \u2014 narrow down iteratively
-3. Once you know specific \`item_id\` or \`chunk_id\` values, run a targeted SELECT to get full content
-
----
-
-## Search Strategy
-
-- **Start broad**: use keyword or hybrid search with your main terms, LIMIT 30\u201350
-- **Go deeper**: if results are sparse, try alternative phrasings, synonyms, or semantic search
-- **Drill into documents**: once you find a relevant item, fetch its chunks in order to get full context
-- **Cross-context**: search multiple contexts when the query could span knowledge bases
-- **Aggregate last**: use COUNT queries only for "how many" questions
-
----
-${customInstructions ? `## Additional Instructions
-
-${customInstructions}
-
----
-` : ""}
-When you have gathered sufficient information, write a clear answer. Do not call any more tools once you have what you need.`;
-}
-function buildSchemaBlock(contexts) {
-  return contexts.map((ctx) => {
-    const itemsTable = getTableName(ctx.id);
-    const chunksTable = getChunksTableName(ctx.id);
-    const customFields = ctx.fields.length > 0 ? ctx.fields.map((f) => `  ${f.name} (${f.type})`).join("\n") : "  (no custom fields)";
-    const embedderNote = ctx.embedder ? `Embedder: ${ctx.embedder.name} \u2014 semantic search and embed() are available` : "No embedder \u2014 use keyword search only";
-    return `### Context: "${ctx.name}" (id: \`${ctx.id}\`)
-${ctx.description || ""}
-${embedderNote}
-
-**${itemsTable}** \u2014 documents / items
-  id           (uuid, primary key)
-  name         (text)
-  external_id  (text, nullable)
-  archived     (boolean, nullable)
-  created_by   (integer, nullable)
-  rights_mode  (text, nullable)
-  "createdAt"  (timestamp)
-  "updatedAt"  (timestamp)
-  -- Custom fields:
-${customFields}
-
-**${chunksTable}** \u2014 text chunks (source FK \u2192 ${itemsTable}.id)
-  id           (uuid, primary key)
-  source       (uuid, FK \u2192 ${itemsTable}.id)
-  content      (text)
-  chunk_index  (integer)
-  fts          (tsvector \u2014 full-text search index)
-  embedding    (vector \u2014 pgvector, nullable)
-  metadata     (jsonb, nullable)
-  "createdAt"  (timestamp)
-  "updatedAt"  (timestamp)`;
-  }).join("\n\n");
-}
-
-// ee/agentic-retrieval/v4/agent-loop.ts
-var import_ai13 = require("ai");
-var MAX_STEPS = 10;
-async function* runAgentLoop2(params) {
-  const { query, systemPrompt, tools, model, onStepComplete } = params;
-  const output = {
-    steps: [],
-    reasoning: [],
-    chunks: [],
-    usage: [],
-    totalTokens: 0
-  };
-  const seenChunkIds = /* @__PURE__ */ new Set();
-  const messages = [{ role: "user", content: query }];
-  for (let step = 0; step < MAX_STEPS; step++) {
-    console.log(`[EXULU] v4 agent loop \u2014 step ${step + 1}/${MAX_STEPS}`);
-    let result;
-    try {
-      result = await withRetry(
-        () => (0, import_ai13.generateText)({
-          model,
-          temperature: 0,
-          system: systemPrompt,
-          messages,
-          tools,
-          toolChoice: "auto",
-          stopWhen: (0, import_ai13.stepCountIs)(1)
-        })
-      );
-    } catch (err) {
-      console.error("[EXULU] v4 generateText failed:", err);
-      throw err;
-    }
-    messages.push(...result.response.messages);
-    const rawToolResults = result.toolResults ?? [];
-    const stepChunks = [];
-    for (const chunk of harvestChunks(rawToolResults)) {
-      if (!chunk.chunk_id || !seenChunkIds.has(chunk.chunk_id)) {
-        if (chunk.chunk_id) seenChunkIds.add(chunk.chunk_id);
-        stepChunks.push(chunk);
-      }
-    }
-    const stepRecord = {
-      stepNumber: step + 1,
-      text: result.text ?? "",
-      toolCalls: result.toolCalls?.map((tc) => ({
-        name: tc.toolName,
-        id: tc.toolCallId,
-        input: tc.input
-      })) ?? [],
-      chunks: stepChunks,
-      tokens: result.usage?.totalTokens ?? 0
-    };
-    output.steps.push(stepRecord);
-    output.reasoning.push({
-      text: result.text ?? "",
-      tools: result.toolCalls?.map((tc) => ({
-        name: tc.toolName,
-        id: tc.toolCallId,
-        input: tc.input,
-        output: rawToolResults.find(
-          (r) => (r.toolCallId ?? r.id) === tc.toolCallId
-        )?.output
-      })) ?? []
-    });
-    output.chunks.push(...stepChunks);
-    output.usage.push(result.usage);
-    onStepComplete?.(stepRecord);
-    yield { ...output };
-    const calledTools = result.toolCalls?.length > 0;
-    if (!calledTools) {
-      console.log(`[EXULU] v4 \u2014 model finished after step ${step + 1} (no tool calls)`);
-      break;
-    }
-  }
-  output.totalTokens = output.usage.reduce((sum, u) => sum + (u?.totalTokens ?? 0), 0);
-}
-
-// ee/agentic-retrieval/v4/index.ts
-async function* executeV4({
-  query,
-  contexts,
-  model,
-  user,
-  role,
-  customInstructions
-}) {
-  const sessionId = (0, import_crypto2.randomUUID)();
-  const sessionDir = path4.join(os.tmpdir(), `exulu-v4-${sessionId}`);
-  console.log("[EXULU] v4 \u2014 starting observe-infer-act retrieval");
-  const tools = createTools({ contexts, user, role, sessionDir });
-  const systemPrompt = buildSystemPrompt(contexts, customInstructions);
-  let finalOutput;
-  try {
-    for await (const output of runAgentLoop2({
-      query,
-      systemPrompt,
-      tools,
-      model
-    })) {
-      finalOutput = output;
-      yield output;
-    }
-  } finally {
-    fs7.rm(sessionDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-  if (finalOutput) {
-    console.log(
-      `[EXULU] v4 \u2014 done. steps=${finalOutput.steps.length} chunks=${finalOutput.chunks.length} tokens=${finalOutput.totalTokens}`
-    );
-  }
-}
-function createAgenticRetrievalToolV4({
-  contexts,
-  instructions: adminInstructions,
-  rerankers,
-  user,
-  role,
-  model
-}) {
-  const license = checkLicense();
-  if (!license["agentic-retrieval"]) {
-    console.warn("[EXULU] Not licensed for agentic retrieval");
-    return void 0;
-  }
-  const contextNames = contexts.map((c) => c.id).join(", ");
-  return new ExuluTool({
-    id: "agentic_context_search_v4",
-    name: "Agentic Context Search (V4)",
-    description: `Observe-infer-act retrieval using raw SQL. Searches: ${contextNames}`,
-    category: "contexts",
-    needsApproval: false,
-    type: "context",
-    config: [
-      {
-        name: "instructions",
-        description: "Custom instructions for the retrieval agent",
-        type: "string",
-        default: ""
-      },
-      {
-        name: "reasoning_model",
-        description: "Override the model used by the retrieval agent (default: inherits from calling agent)",
-        type: "string",
-        default: ""
-      },
-      ...contexts.map((ctx) => ({
-        name: ctx.id,
-        description: `Enable search in "${ctx.name}". ${ctx.description}`,
-        type: "boolean",
-        default: true
-      }))
-    ],
-    inputSchema: import_zod19.z.object({
-      query: import_zod19.z.string().describe("The question or query to answer"),
-      userInstructions: import_zod19.z.string().optional().describe("Additional instructions from the user to guide retrieval")
-    }),
-    execute: async function* ({
-      query,
-      userInstructions,
-      toolVariablesConfig
-    }) {
-      if (!model) {
-        throw new Error("Model is required for executing the agentic retrieval tool");
-      }
-      let activeContexts = contexts;
-      let configInstructions = "";
-      if (toolVariablesConfig) {
-        configInstructions = toolVariablesConfig["instructions"] ?? "";
-        activeContexts = contexts.filter(
-          (ctx) => toolVariablesConfig[ctx.id] === true || toolVariablesConfig[ctx.id] === "true" || toolVariablesConfig[ctx.id] === 1
-        );
-        if (activeContexts.length === 0) activeContexts = contexts;
-      }
-      const combinedInstructions = [
-        configInstructions ? `Configuration instructions: ${configInstructions}` : "",
-        adminInstructions ? `Admin instructions: ${adminInstructions}` : "",
-        userInstructions ? `User instructions: ${userInstructions}` : ""
-      ].filter(Boolean).join("\n");
-      for await (const output of executeV4({
-        query,
-        contexts: activeContexts,
-        model,
-        user,
-        role,
-        customInstructions: combinedInstructions || void 0
-      })) {
-        yield { result: JSON.stringify(output) };
-      }
-    }
-  });
-}
-
 // src/index.ts
 var ExuluJobs = {
   redis: redisClient
@@ -18276,8 +19071,7 @@ var ExuluDefaultTools = {
   agentic: {
     retrieval: {
       create: {
-        v3: createAgenticRetrievalToolV3,
-        v4: createAgenticRetrievalToolV4
+        v3: createAgenticRetrievalToolV3
       }
     }
   }
@@ -18318,8 +19112,8 @@ var ExuluVariables = {
       throw new Error(`Variable ${name} not found.`);
     }
     if (variable.encrypted) {
-      const bytes = import_crypto_js9.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-      variable.value = bytes.toString(import_crypto_js9.default.enc.Utf8);
+      const bytes = import_crypto_js10.default.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+      variable.value = bytes.toString(import_crypto_js10.default.enc.Utf8);
     }
     return variable.value;
   }