@exulu/backend 3.1.0 → 3.2.0

package/dist/{chunk-ZDH5S2WF.js → chunk-CVQTDG37.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-7CCMW3IW.js";
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
-import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2, S3ServiceException } from "@aws-sdk/client-s3";
+import { S3Client as S3Client3, PutObjectCommand as PutObjectCommand3, S3ServiceException } from "@aws-sdk/client-s3";
 
 // src/exulu/tool.ts
 import { tool } from "ai";
@@ -33,210 +33,8 @@ var exuluApp = {
 };
 
 // src/exulu/resolve-model.ts
-import CryptoJS from "crypto-js";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 
-// src/postgres/client.ts
-import Knex from "knex";
-import "knex";
-import "pgvector/knex";
-var db = {};
-var databaseExistsChecked = false;
-var getDbName = () => process.env.POSTGRES_DB_NAME || "exulu";
-async function ensureDatabaseExists() {
-  const dbName = getDbName();
-  const defaultKnex = Knex({
-    client: "pg",
-    connection: {
-      host: process.env.POSTGRES_DB_HOST,
-      port: parseInt(process.env.POSTGRES_DB_PORT || "5432"),
-      user: process.env.POSTGRES_DB_USER,
-      database: "postgres",
-      // Connect to default database
-      password: process.env.POSTGRES_DB_PASSWORD,
-      ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false,
-      connectionTimeoutMillis: 1e4
-    },
-    pool: {
-      min: 2,
-      max: 4,
-      acquireTimeoutMillis: 3e4,
-      createTimeoutMillis: 3e4,
-      idleTimeoutMillis: 3e4,
-      reapIntervalMillis: 1e3,
-      createRetryIntervalMillis: 200
-    }
-  });
-  try {
-    const result = await defaultKnex.raw(`
-            SELECT 1 FROM pg_database WHERE datname = '${dbName}'
-        `);
-    if (result.rows.length === 0) {
-      console.log(`[EXULU] Database '${dbName}' does not exist. Creating it...`);
-      await defaultKnex.raw(`CREATE DATABASE ${dbName}`);
-      console.log(`[EXULU] Database '${dbName}' created successfully.`);
-    } else {
-      console.log(`[EXULU] Database '${dbName}' already exists.`);
-    }
-  } catch (error) {
-    console.error(
-      "[EXULU] Error while checking to ensure the database exists, this could be if the user running the server does not have database admin rights, it is fine to ignore this if you are sure the database exists.",
-      error
-    );
-    return;
-  } finally {
-    await defaultKnex.destroy();
-  }
-}
-async function postgresClient() {
-  if (!db["exulu"]) {
-    try {
-      if (!databaseExistsChecked) {
-        await ensureDatabaseExists();
-        databaseExistsChecked = true;
-      }
-      const knex = Knex({
-        client: "pg",
-        connection: {
-          host: process.env.POSTGRES_DB_HOST,
-          port: parseInt(process.env.POSTGRES_DB_PORT || "5432"),
-          user: process.env.POSTGRES_DB_USER,
-          database: getDbName(),
-          password: process.env.POSTGRES_DB_PASSWORD,
-          ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false,
-          // TCP keepalive prevents idle sockets from being silently dropped by
-          // intermediate network devices (NAT, firewalls) between us and Hetzner.
-          keepAlive: true,
-          keepAliveInitialDelayMillis: 1e4,
-          connectionTimeoutMillis: 3e4,
-          statement_timeout: 18e5,
-          query_timeout: 18e5
-        },
-        pool: {
-          min: 10,
-          max: 300,
-          acquireTimeoutMillis: 12e4,
-          createTimeoutMillis: 3e4,
-          idleTimeoutMillis: 3e4,
-          reapIntervalMillis: 1e3,
-          createRetryIntervalMillis: 200,
-          // Enable propagateCreateError to properly handle connection creation failures
-          propagateCreateError: false,
-          // Log pool events to help debug connection issues
-          afterCreate: (conn, done) => {
-            console.log("[EXULU] New database connection created");
-            conn.query("SET statement_timeout = 1800000; SET hnsw.ef_search = 20", (err) => {
-              if (err) {
-                console.error("[EXULU] Error setting connection parameters:", err);
-              }
-              done(err, conn);
-            });
-          }
-        }
-      });
-      try {
-        await knex.schema.createExtensionIfNotExists("vector");
-      } catch (error) {
-        console.error(
-          "[EXULU] Error creating vector extension, this might be fine if you already activated the extension and the 'user' running this script does not have higher level database permissions.",
-          error
-        );
-      }
-      db["exulu"] = knex;
-    } catch (error) {
-      console.error("[EXULU] Error initializing exulu database.", error);
-      throw error;
-    }
-  }
-  return {
-    db: db["exulu"]
-  };
-}
-
-// src/utils/check-record-access.ts
-var checkRecordAccessCache = /* @__PURE__ */ new Map();
-var checkRecordAccess = async (record, request, user) => {
-  const setRecordAccessCache = (hasAccess2) => {
-    checkRecordAccessCache.set(`${record.id}-${request}-${user?.id}`, {
-      hasAccess: hasAccess2,
-      expiresAt: new Date(Date.now() + 1e3 * 60 * 1)
-      // 1 minute
-    });
-  };
-  const cachedAccess = checkRecordAccessCache.get(`${record.id}-${request}-${user?.id}`);
-  if (cachedAccess && cachedAccess.expiresAt > /* @__PURE__ */ new Date()) {
-    return cachedAccess.hasAccess;
-  }
-  const isPublic = record.rights_mode === "public";
-  const byUsers = record.rights_mode === "users";
-  const byRoles = record.rights_mode === "roles";
-  const byTeams = record.rights_mode === "teams";
-  const createdBy = typeof record.created_by === "string" ? record.created_by : record.created_by?.toString();
-  const isCreator = user ? createdBy === user.id.toString() : false;
-  const isAdmin = user ? user.super_admin : false;
-  const isApi = user ? user.type === "api" : false;
-  const isAdminApi = isApi && (!user.scope_mode || user.scope_mode === "admin");
-  const isAgentsScopedApi = isApi && user.scope_mode === "agents" && request === "read" && Array.isArray(user.agent_ids) && user.agent_ids.includes(String(record.id));
-  let hasAccess = "none";
-  if (isPublic || isCreator || isAdmin || isAdminApi || isAgentsScopedApi) {
-    setRecordAccessCache(true);
-    return true;
-  }
-  if (byUsers) {
-    if (!user) {
-      setRecordAccessCache(false);
-      return false;
-    }
-    hasAccess = record.RBAC?.users?.find((x) => x.id === user.id)?.rights || "none";
-    if (!hasAccess || hasAccess === "none" || hasAccess !== request) {
-      console.error(
-        `[EXULU] Your current user ${user.id} does not have access to this record, current access type is: ${hasAccess}.`
-      );
-      setRecordAccessCache(false);
-      return false;
-    } else {
-      setRecordAccessCache(true);
-      return true;
-    }
-  }
-  if (byRoles) {
-    if (!user) {
-      setRecordAccessCache(false);
-      return false;
-    }
-    hasAccess = record.RBAC?.roles?.find((x) => x.id === user.role?.id)?.rights || "none";
-    if (!hasAccess || hasAccess === "none" || hasAccess !== request) {
-      console.error(
-        `[EXULU] Your current role ${user.role?.name} does not have access to this record, current access type is: ${hasAccess}.`
-      );
-      setRecordAccessCache(false);
-      return false;
-    } else {
-      setRecordAccessCache(true);
-      return true;
-    }
-  }
-  if (byTeams) {
-    if (!user) {
-      setRecordAccessCache(false);
-      return false;
-    }
-    hasAccess = record.RBAC?.teams?.find((x) => x.id === user.team?.id)?.rights || "none";
-    if (!hasAccess || hasAccess === "none" || hasAccess !== request) {
-      console.error(
-        `[EXULU] Your current team ${user.team?.name} does not have access to this record, current access type is: ${hasAccess}.`
-      );
-      setRecordAccessCache(false);
-      return false;
-    } else {
-      setRecordAccessCache(true);
-      return true;
-    }
-  }
-  setRecordAccessCache(false);
-  return false;
-};
-
 // src/exulu/litellm/supervisor.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
@@ -616,6 +414,123 @@ function createTaggedFetch(tags) {
   return labeled;
 }
 
+// src/postgres/client.ts
+import Knex from "knex";
+import "knex";
+import "pgvector/knex";
+var db = {};
+var databaseExistsChecked = false;
+var getDbName = () => process.env.POSTGRES_DB_NAME || "exulu";
+async function ensureDatabaseExists() {
+  const dbName = getDbName();
+  const defaultKnex = Knex({
+    client: "pg",
+    connection: {
+      host: process.env.POSTGRES_DB_HOST,
+      port: parseInt(process.env.POSTGRES_DB_PORT || "5432"),
+      user: process.env.POSTGRES_DB_USER,
+      database: "postgres",
+      // Connect to default database
+      password: process.env.POSTGRES_DB_PASSWORD,
+      ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false,
+      connectionTimeoutMillis: 1e4
+    },
+    pool: {
+      min: 2,
+      max: 4,
+      acquireTimeoutMillis: 3e4,
+      createTimeoutMillis: 3e4,
+      idleTimeoutMillis: 3e4,
+      reapIntervalMillis: 1e3,
+      createRetryIntervalMillis: 200
+    }
+  });
+  try {
+    const result = await defaultKnex.raw(`
+            SELECT 1 FROM pg_database WHERE datname = '${dbName}'
+        `);
+    if (result.rows.length === 0) {
+      console.log(`[EXULU] Database '${dbName}' does not exist. Creating it...`);
+      await defaultKnex.raw(`CREATE DATABASE ${dbName}`);
+      console.log(`[EXULU] Database '${dbName}' created successfully.`);
+    } else {
+      console.log(`[EXULU] Database '${dbName}' already exists.`);
+    }
+  } catch (error) {
+    console.error(
+      "[EXULU] Error while checking to ensure the database exists, this could be if the user running the server does not have database admin rights, it is fine to ignore this if you are sure the database exists.",
+      error
+    );
+    return;
+  } finally {
+    await defaultKnex.destroy();
+  }
+}
+async function postgresClient() {
+  if (!db["exulu"]) {
+    try {
+      if (!databaseExistsChecked) {
+        await ensureDatabaseExists();
+        databaseExistsChecked = true;
+      }
+      const knex = Knex({
+        client: "pg",
+        connection: {
+          host: process.env.POSTGRES_DB_HOST,
+          port: parseInt(process.env.POSTGRES_DB_PORT || "5432"),
+          user: process.env.POSTGRES_DB_USER,
+          database: getDbName(),
+          password: process.env.POSTGRES_DB_PASSWORD,
+          ssl: process.env.POSTGRES_DB_SSL === "true" ? { rejectUnauthorized: false } : false,
+          // TCP keepalive prevents idle sockets from being silently dropped by
+          // intermediate network devices (NAT, firewalls) between us and Hetzner.
+          keepAlive: true,
+          keepAliveInitialDelayMillis: 1e4,
+          connectionTimeoutMillis: 3e4,
+          statement_timeout: 18e5,
+          query_timeout: 18e5
+        },
+        pool: {
+          min: 10,
+          max: 300,
+          acquireTimeoutMillis: 12e4,
+          createTimeoutMillis: 3e4,
+          idleTimeoutMillis: 3e4,
+          reapIntervalMillis: 1e3,
+          createRetryIntervalMillis: 200,
+          // Enable propagateCreateError to properly handle connection creation failures
+          propagateCreateError: false,
+          // Log pool events to help debug connection issues
+          afterCreate: (conn, done) => {
+            console.log("[EXULU] New database connection created");
+            conn.query("SET statement_timeout = 1800000; SET hnsw.ef_search = 20", (err) => {
+              if (err) {
+                console.error("[EXULU] Error setting connection parameters:", err);
+              }
+              done(err, conn);
+            });
+          }
+        }
+      });
+      try {
+        await knex.schema.createExtensionIfNotExists("vector");
+      } catch (error) {
+        console.error(
+          "[EXULU] Error creating vector extension, this might be fine if you already activated the extension and the 'user' running this script does not have higher level database permissions.",
+          error
+        );
+      }
+      db["exulu"] = knex;
+    } catch (error) {
+      console.error("[EXULU] Error initializing exulu database.", error);
+      throw error;
+    }
+  }
+  return {
+    db: db["exulu"]
+  };
+}
+
 // src/exulu/litellm/env.ts
 var LiteLLMAdminError = class extends Error {
   constructor(message, status) {
@@ -635,9 +550,9 @@ function litellmBase() {
 }
 
 // src/exulu/litellm/admin-client.ts
-async function call(path, body) {
+async function call(path3, body) {
   const { url, masterKey } = litellmBase();
-  const res = await fetch(`${url}${path}`, {
+  const res = await fetch(`${url}${path3}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${masterKey}`,
@@ -648,7 +563,7 @@ async function call(path, body) {
   if (!res.ok) {
     const text = await res.text().catch(() => "");
     throw new LiteLLMAdminError(
-      `LiteLLM ${path} returned ${res.status}: ${text}`,
+      `LiteLLM ${path3} returned ${res.status}: ${text}`,
       res.status
     );
   }
@@ -1112,21 +1027,6 @@ async function getUserBudgetView(userId) {
 }
 
 // src/exulu/resolve-model.ts
-var LITELLM_PROVIDER_SENTINEL = new Proxy(
-  {},
-  {
-    get(_target, prop) {
-      if (prop === "id") return "litellm";
-      if (prop === Symbol.toPrimitive || prop === "toString") {
-        return () => "[LiteLLMProviderSentinel]";
-      }
-      console.error(`ExuluProvider.${String(prop)} is not available in LiteLLM mode. `, new Error().stack);
-      throw new Error(
-        `ExuluProvider.${String(prop)} is not available in LiteLLM mode. Code paths that depend on the in-code provider catalog must check isLiteLLMEnabled() and degrade.`
-      );
-    }
-  }
-);
 var ResolveModelError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -1188,101 +1088,43 @@ var getLiteLLMProvider = ({
   });
 };
 async function resolveModel(input) {
-  const { modelId, user, providers, agent, project, routine, rbacBypass } = input;
-  const rbacRequest = input.rbacRequest ?? "read";
-  if (isLiteLLMEnabled()) {
-    try {
-      await waitForLiteLLMReady();
-    } catch (err) {
-      throw new ResolveModelError(
-        "LITELLM_NOT_READY",
-        `LiteLLM is not ready: ${err.message}`
-      );
-    }
-    if (user?.id) await provisionDefaultUserBudget(user.id);
-    const litellm = getLiteLLMProvider({
-      user,
-      role: user?.role,
-      // Fall back to the caller's own project (set on API keys) when no
-      // explicit request project is supplied, so API-triggered requests are
-      // attributed to the key's project.
-      project: project ?? user?.project,
-      agent,
-      team: user?.team,
-      routine
-    });
-    const languageModel2 = litellm(modelId);
-    const syntheticModel = {
-      id: modelId,
-      name: modelId,
-      provider: modelId,
-      active: true,
-      rights_mode: "public",
-      created_by: "litellm"
-    };
-    return {
-      languageModel: languageModel2,
-      model: syntheticModel,
-      exuluProvider: LITELLM_PROVIDER_SENTINEL,
-      apiKey: void 0
-    };
-  }
-  const { db: db2 } = await postgresClient();
-  const model = await db2.from("models").where({ id: modelId }).first();
-  if (!model) {
-    throw new ResolveModelError("MODEL_NOT_FOUND", `Model ${modelId} not found`);
-  }
-  if (!model.active) {
-    throw new ResolveModelError("MODEL_INACTIVE", `Model ${model.name} is inactive`);
-  }
-  if (!rbacBypass) {
-    const ok = await checkRecordAccess(model, rbacRequest, user);
-    if (!ok) {
-      throw new ResolveModelError(
-        "MODEL_FORBIDDEN",
-        `No ${rbacRequest} access to model ${model.name}`
-      );
-    }
-  }
-  const exuluProvider = providers.find((p) => p.id === model.provider);
-  if (!exuluProvider) {
-    throw new ResolveModelError(
-      "PROVIDER_NOT_FOUND",
-      `ExuluProvider ${model.provider} (referenced by model ${model.name}) not registered in this instance`
-    );
+  const { modelId, user, agent, project, routine } = input;
+  if (!isLiteLLMEnabled()) {
+    throw new Error("Litellm not configured or available.");
   }
-  if (!exuluProvider.config?.model?.create) {
+  try {
+    await waitForLiteLLMReady();
+  } catch (err) {
     throw new ResolveModelError(
-      "PROVIDER_NO_MODEL",
-      `ExuluProvider ${exuluProvider.id} has no model.create()`
+      "LITELLM_NOT_READY",
+      `LiteLLM is not ready: ${err.message}`
     );
   }
-  let apiKey;
-  if (model.authvariable) {
-    const variable = await db2.from("variables").where({ name: model.authvariable }).first();
-    if (!variable) {
-      throw new ResolveModelError(
-        "AUTH_VAR_NOT_FOUND",
-        `Auth variable ${model.authvariable} (referenced by model ${model.name}) not found`
-      );
-    }
-    if (!variable.encrypted) {
-      throw new ResolveModelError(
-        "AUTH_VAR_NOT_ENCRYPTED",
-        `Auth variable ${model.authvariable} must be encrypted`
-      );
-    }
-    const bytes = CryptoJS.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-    apiKey = bytes.toString(CryptoJS.enc.Utf8);
-  }
-  const languageModel = exuluProvider.config.model.create({
-    apiKey,
-    user: user?.id,
-    role: user?.role?.id,
-    project: project?.id,
-    agent: agent?.id
+  if (user?.id) await provisionDefaultUserBudget(user.id);
+  const litellm = getLiteLLMProvider({
+    user,
+    role: user?.role,
+    // Fall back to the caller's own project (set on API keys) when no
+    // explicit request project is supplied, so API-triggered requests are
+    // attributed to the key's project.
+    project: project ?? user?.project,
+    agent,
+    team: user?.team,
+    routine
   });
-  return { languageModel, model, exuluProvider, apiKey };
+  const languageModel = litellm(modelId);
+  const syntheticModel = {
+    id: modelId,
+    name: modelId,
+    provider: modelId,
+    active: true,
+    rights_mode: "public",
+    created_by: "litellm"
+  };
+  return {
+    languageModel,
+    model: syntheticModel
+  };
 }
 
 // src/exulu/auth/validate.ts
@@ -1431,14 +1273,14 @@ var authRegistry = {
 };
 
 // src/exulu/auth/flow.ts
-import CryptoJS3 from "crypto-js";
+import CryptoJS2 from "crypto-js";
 import { createHash, randomBytes } from "crypto";
 
 // src/exulu/auth/credential-store.ts
-import CryptoJS2 from "crypto-js";
+import CryptoJS from "crypto-js";
 var TABLE = "user_credentials";
-var encrypt = (value) => CryptoJS2.AES.encrypt(value, process.env.NEXTAUTH_SECRET).toString();
-var decrypt = (value) => CryptoJS2.AES.decrypt(value, process.env.NEXTAUTH_SECRET).toString(CryptoJS2.enc.Utf8);
+var encrypt = (value) => CryptoJS.AES.encrypt(value, process.env.NEXTAUTH_SECRET).toString();
+var decrypt = (value) => CryptoJS.AES.decrypt(value, process.env.NEXTAUTH_SECRET).toString(CryptoJS.enc.Utf8);
 async function get(provider, userId) {
   const { db: db2 } = await postgresClient();
   const row = await db2.from(TABLE).where({ provider, user_id: String(userId) }).first();
@@ -1517,12 +1359,12 @@ var fromBase64Url = (value) => {
   }
   return base64;
 };
-var encryptOauthState = (state) => toBase64Url(CryptoJS3.AES.encrypt(JSON.stringify(state), process.env.NEXTAUTH_SECRET).toString());
+var encryptOauthState = (state) => toBase64Url(CryptoJS2.AES.encrypt(JSON.stringify(state), process.env.NEXTAUTH_SECRET).toString());
 var decryptOauthState = (value) => {
   let json = "";
   try {
-    json = CryptoJS3.AES.decrypt(fromBase64Url(value), process.env.NEXTAUTH_SECRET).toString(
-      CryptoJS3.enc.Utf8
+    json = CryptoJS2.AES.decrypt(fromBase64Url(value), process.env.NEXTAUTH_SECRET).toString(
+      CryptoJS2.enc.Utf8
     );
   } catch {
     throw new Error("[EXULU] Invalid OAuth state.");
@@ -1891,26 +1733,13 @@ var ExuluTool = class _ExuluTool {
     if (!agent) {
       throw new Error("Agent not found.");
     }
-    let providerapikey;
-    if (agent.model) {
-      const providers = exuluApp.get().providers;
-      const resolved = await resolveModel({
-        modelId: agent.model,
-        user,
-        providers,
-        agent,
-        rbacBypass: true
-      });
-      providerapikey = resolved.apiKey;
-    }
-    const { convertExuluToolsToAiSdkTools: convertExuluToolsToAiSdkTools2 } = await import("./convert-exulu-tools-to-ai-sdk-tools-FN6WZSIQ.js");
+    const { convertExuluToolsToAiSdkTools: convertExuluToolsToAiSdkTools2 } = await import("./convert-exulu-tools-to-ai-sdk-tools-QG7E6UX5.js");
     const tools = await convertExuluToolsToAiSdkTools2(
       [this],
       [],
       [],
       [],
       agent.tools,
-      providerapikey,
       void 0,
       user,
       config,
@@ -1984,7 +1813,7 @@ var updateStatistic = async (statistic) => {
 };
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
-import CryptoJS5 from "crypto-js";
+import CryptoJS4 from "crypto-js";
 
 // src/templates/tools/session-items-retrieval-tool.ts
 import { z as z2 } from "zod";
@@ -4017,7 +3846,6 @@ function createAgenticRetrievalTool(opts) {
             const resolved = await resolveModel({
               modelId: cfg.utilityModel,
               user,
-              providers: exuluApp.get().providers,
               rbacBypass: true
             });
             utilityModel = resolved.languageModel ?? model;
@@ -4368,7 +4196,7 @@ function sanitizeToolName(name) {
 }
 
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // types/enums/statistics.ts
 var STATISTICS_TYPE_ENUM = {
@@ -6029,7 +5857,7 @@ ${body}`
 import { createBashTool } from "bash-tool";
 import { tool as tool2 } from "ai";
 import { z as z11 } from "zod";
-import CryptoJS4 from "crypto-js";
+import CryptoJS3 from "crypto-js";
 var getAllExuluVariables = async () => {
   const { db: db2 } = await postgresClient();
   const rows = await db2.from("variables").select("*");
@@ -6041,8 +5869,8 @@ var getAllExuluVariables = async () => {
     let value = row.value;
     if (row.encrypted) {
       try {
-        const bytes = CryptoJS4.AES.decrypt(value, process.env.NEXTAUTH_SECRET);
-        value = bytes.toString(CryptoJS4.enc.Utf8);
+        const bytes = CryptoJS3.AES.decrypt(value, process.env.NEXTAUTH_SECRET);
+        value = bytes.toString(CryptoJS3.enc.Utf8);
       } catch (err) {
         console.error(
           `[VARIABLES] Failed to decrypt variable "${row.name}"; skipping.`,
@@ -6326,11 +6154,11 @@ Probe error: ${probe.reason ?? "(no detail)"}`
     async executeCommand(command) {
       return await runWrapped(command);
     },
-    async readFile(path) {
-      const { stdout, stderr, exitCode } = await runWrapped(`cat ${shellQuote(path)}`);
+    async readFile(path3) {
+      const { stdout, stderr, exitCode } = await runWrapped(`cat ${shellQuote(path3)}`);
       if (exitCode !== 0) {
         throw new Error(
-          `readFile ${path} failed (exit ${exitCode}): ${stderr.trim() || "no stderr captured"}`
+          `readFile ${path3} failed (exit ${exitCode}): ${stderr.trim() || "no stderr captured"}`
         );
       }
       return stdout;
@@ -6450,8 +6278,8 @@ Probe error: ${probe.reason ?? "(no detail)"}`
       path: z11.string().describe("The path where the file should be written. Relative paths and leading-slash paths are both resolved against the session sandbox root."),
       content: z11.string().describe("The content to write to the file")
     }),
-    execute: async ({ path, content }) => {
-      const resolvedPath = resolveSessionPath(path, sessionDir);
+    execute: async ({ path: path3, content }) => {
+      const resolvedPath = resolveSessionPath(path3, sessionDir);
       const results = await writeFilesInternal([{ path: resolvedPath, content }]);
       const result = results[0];
       if (!result) {
@@ -6470,8 +6298,8 @@ Probe error: ${probe.reason ?? "(no detail)"}`
     inputSchema: z11.object({
       path: z11.string().describe("The path of the file to read. Relative paths and leading-slash paths are both resolved against the session sandbox root.")
     }),
-    execute: async ({ path }) => {
-      const resolvedPath = resolveSessionPath(path, sessionDir);
+    execute: async ({ path: path3 }) => {
+      const resolvedPath = resolveSessionPath(path3, sessionDir);
       const content = await customSandbox.readFile(resolvedPath);
       return { content };
     }
@@ -6493,25 +6321,25 @@ Probe error: ${probe.reason ?? "(no detail)"}`
       if (persistenceEnabled && before) {
         const after = await snapshotSessionArtifacts();
         const changedPaths = [];
-        for (const [path, mtime] of after) {
-          const beforeMtime = before.get(path);
+        for (const [path3, mtime] of after) {
+          const beforeMtime = before.get(path3);
           if (beforeMtime === void 0 || beforeMtime < mtime) {
-            changedPaths.push(path);
+            changedPaths.push(path3);
           }
         }
-        for (const path of changedPaths) {
+        for (const path3 of changedPaths) {
           try {
-            const content = await fsReadFile(path);
-            const persisted = await persistArtifactToS3(path, content);
+            const content = await fsReadFile(path3);
+            const persisted = await persistArtifactToS3(path3, content);
             artifacts.push({
-              path,
-              relativePath: relative(sessionDir, path),
+              path: path3,
+              relativePath: relative(sessionDir, path3),
               key: persisted.key,
               url: persisted.url
             });
           } catch (err) {
             console.error(
-              `[SKILLS] Failed to mirror bash-produced artifact ${path} to S3; continuing.`,
+              `[SKILLS] Failed to mirror bash-produced artifact ${path3} to S3; continuing.`,
               err
             );
           }
@@ -7277,9 +7105,503 @@ var createViewDocumentPageTool = ({
   });
 };
 
+// src/exulu/audit/config.ts
+import os from "os";
+import path from "path";
+var normalizePrefix = (p) => {
+  const raw = (p ?? "audit").trim().replace(/^\/+|\/+$/g, "");
+  return `${raw || "audit"}/`;
+};
+var hasAllS3Fields = (t) => !!t && !!t.s3region && !!t.s3key && !!t.s3secret && !!t.s3Bucket;
+var resolveAuditConfig = (config) => {
+  const a = config.audit;
+  if (!a || a.enabled !== true) return null;
+  const dedicated = hasAllS3Fields(a.s3);
+  const source = dedicated ? a.s3 : config.fileUploads;
+  if (!hasAllS3Fields(source)) {
+    throw new Error(
+      "[EXULU] audit.enabled is true but no S3 target is configured. Set config.audit.s3 or config.fileUploads."
+    );
+  }
+  if (!Number.isInteger(a.retentionDays) || a.retentionDays <= 0) {
+    throw new Error(`[EXULU] audit.retentionDays must be a positive integer, got ${a.retentionDays}.`);
+  }
+  const usingSharedFileUploadsBucket = !dedicated;
+  return {
+    target: {
+      s3region: source.s3region,
+      s3key: source.s3key,
+      s3secret: source.s3secret,
+      s3Bucket: source.s3Bucket,
+      s3prefix: normalizePrefix(source.s3prefix),
+      ...source.s3endpoint ? { s3endpoint: source.s3endpoint } : {}
+    },
+    retentionDays: a.retentionDays,
+    manageLifecycle: a.manageLifecycle ?? !usingSharedFileUploadsBucket,
+    usingSharedFileUploadsBucket,
+    spoolDir: a.spoolDir ?? path.join(os.tmpdir(), "exulu-audit-spool"),
+    flush: {
+      maxRecords: a.flush?.maxRecords ?? 100,
+      maxIntervalMs: a.flush?.maxIntervalMs ?? 5e3
+    },
+    payload: {
+      maxBytes: a.payload?.maxBytes ?? 32768,
+      captureOutput: a.payload?.captureOutput ?? true,
+      redactKeys: a.payload?.redactKeys ?? []
+    },
+    failureMode: a.failureMode ?? "open",
+    toolCalls: {
+      enabled: a.sources?.toolCalls?.enabled ?? true,
+      include: a.sources?.toolCalls?.include ?? [],
+      exclude: a.sources?.toolCalls?.exclude ?? []
+    }
+  };
+};
+
+// src/exulu/audit/s3-writer.ts
+import {
+  S3Client as S3Client2,
+  PutObjectCommand as PutObjectCommand2,
+  GetBucketLifecycleConfigurationCommand,
+  PutBucketLifecycleConfigurationCommand
+} from "@aws-sdk/client-s3";
+var RETRYABLE = /* @__PURE__ */ new Set(["SignatureDoesNotMatch", "InvalidAccessKeyId", "AccessDenied"]);
+var buildAuditS3Client = (t) => new S3Client2({
+  region: t.s3region,
+  ...t.s3endpoint ? { forcePathStyle: true, endpoint: t.s3endpoint } : {},
+  credentials: { accessKeyId: t.s3key, secretAccessKey: t.s3secret },
+  requestChecksumCalculation: "WHEN_REQUIRED",
+  responseChecksumValidation: "WHEN_REQUIRED"
+});
+var createAuditS3Writer = (target, client, opts) => {
+  const c = client ?? buildAuditS3Client(target);
+  const maxRetries = opts?.maxRetries ?? 3;
+  const backoffMs = opts?.backoffMs ?? ((attempt) => Math.pow(2, attempt) * 1e3);
+  const putNdjson = async (key, body) => {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const command = new PutObjectCommand2({
+        Bucket: target.s3Bucket,
+        Key: key,
+        Body: Buffer.from(body, "utf8"),
+        ContentType: "application/x-ndjson"
+      });
+      try {
+        await c.send(command);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (RETRYABLE.has(error?.name) && attempt < maxRetries) {
+          await new Promise((r) => setTimeout(r, backoffMs(attempt)));
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (lastError) throw lastError;
+  };
+  const getLifecycle = async () => c.send(new GetBucketLifecycleConfigurationCommand({ Bucket: target.s3Bucket }));
+  const putLifecycle = async (config) => {
+    await c.send(
+      new PutBucketLifecycleConfigurationCommand({
+        Bucket: target.s3Bucket,
+        LifecycleConfiguration: config
+      })
+    );
+  };
+  return { putNdjson, getLifecycle, putLifecycle };
+};
+
+// src/exulu/audit/lifecycle.ts
+var AUDIT_LIFECYCLE_RULE_ID = "exulu-audit-retention";
+var buildRule = (prefix, retentionDays) => ({
+  ID: AUDIT_LIFECYCLE_RULE_ID,
+  Filter: { Prefix: prefix },
+  Status: "Enabled",
+  Expiration: { Days: retentionDays }
+});
+var applyRetentionLifecycle = async (writer, opts) => {
+  const rule = buildRule(opts.prefix, opts.retentionDays);
+  const config = { Rules: [rule] };
+  if (!opts.manage) {
+    console.warn(
+      `[EXULU] audit retention: not managing the S3 lifecycle for this bucket. Apply this rule manually:
+${JSON.stringify(config, null, 2)}`
+    );
+    return;
+  }
+  try {
+    let existing = [];
+    try {
+      const current = await writer.getLifecycle();
+      existing = (current?.Rules ?? []).filter((r) => r.ID !== AUDIT_LIFECYCLE_RULE_ID);
+    } catch (error) {
+      if (error?.name !== "NoSuchLifecycleConfiguration") throw error;
+    }
+    await writer.putLifecycle({ Rules: [...existing, rule] });
+    console.log(`[EXULU] audit retention: S3 lifecycle set to expire "${opts.prefix}" after ${opts.retentionDays} days.`);
+  } catch (error) {
+    console.warn(
+      `[EXULU] audit retention: could not set the S3 lifecycle (${error?.name ?? "error"}). Apply this rule manually:
+${JSON.stringify(config, null, 2)}`
+    );
+  }
+};
+
+// src/exulu/audit/sink.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var createFsSpoolStore = (dir) => ({
+  write: async (name, body) => {
+    await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(path2.join(dir, name), body, "utf8");
+  },
+  list: async () => {
+    try {
+      return (await fs2.readdir(dir)).filter((f) => f.endsWith(".ndjson"));
+    } catch {
+      return [];
+    }
+  },
+  read: async (name) => fs2.readFile(path2.join(dir, name), "utf8"),
+  remove: async (name) => {
+    await fs2.rm(path2.join(dir, name), { force: true });
+  }
+});
+var pad = (n) => String(n).padStart(2, "0");
+var AuditSink = class {
+  constructor(cfg, writer, spool, opts) {
+    this.cfg = cfg;
+    this.writer = writer;
+    this.spool = spool;
+    this.now = opts?.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  buffer = [];
+  timer = null;
+  now;
+  objectKey() {
+    const d = this.now();
+    const dt = `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+    return `${this.cfg.target.s3prefix}dt=${dt}/${pad(d.getUTCHours())}/${d.getTime()}-${randomUUID4()}.ndjson`;
+  }
+  serialize(events) {
+    return events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  }
+  record(event) {
+    this.buffer.push(event);
+    if (this.buffer.length >= this.cfg.flush.maxRecords) {
+      void this.flush();
+    } else if (!this.timer) {
+      this.timer = setTimeout(() => void this.flush(), this.cfg.flush.maxIntervalMs);
+      this.timer.unref?.();
+    }
+  }
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer;
+    this.buffer = [];
+    const body = this.serialize(batch);
+    try {
+      await this.writer.putNdjson(this.objectKey(), body);
+      await this.drainSpool();
+    } catch (error) {
+      const name = `${Date.now()}-${randomUUID4()}.ndjson`;
+      try {
+        await this.spool.write(name, body);
+        console.warn(`[EXULU] audit: S3 write failed, spooled ${batch.length} record(s) to disk (${name}).`, error);
+      } catch (spoolError) {
+        console.error(`[EXULU] audit: S3 write AND local spool failed \u2014 ${batch.length} record(s) lost.`, spoolError);
+      }
+    }
+  }
+  async drainSpool() {
+    const names = await this.spool.list();
+    for (const name of names) {
+      try {
+        const body = await this.spool.read(name);
+        await this.writer.putNdjson(this.objectKey(), body);
+        await this.spool.remove(name);
+      } catch {
+        return;
+      }
+    }
+  }
+  async recordDurable(event) {
+    await this.writer.putNdjson(this.objectKey(), this.serialize([event]));
+  }
+  async close() {
+    await this.flush();
+  }
+};
+
+// src/exulu/audit/event.ts
+var AUDIT_EVENT_TYPES = {
+  TOOL_CALL: "tool.call"
+};
+
+// src/exulu/audit/redact.ts
+var SECRET_KEY_DENYLIST = [
+  "oauth",
+  "credentials",
+  "accesstoken",
+  "refreshtoken",
+  "password",
+  "secret",
+  "token",
+  "apikey",
+  "authorization",
+  "nonce"
+];
+var FRAMEWORK_INTERNAL_KEYS = /* @__PURE__ */ new Set([
+  "req",
+  "model",
+  "contexts",
+  "upload",
+  "memory",
+  "exuluConfig",
+  "toolVariablesConfig",
+  "allExuluTools",
+  "currentTools",
+  "sessionItems",
+  "audit"
+]);
+var isSecretKey = (key, extra) => {
+  const k = key.toLowerCase();
+  if (extra.some((e) => k.includes(e.toLowerCase()))) return true;
+  return SECRET_KEY_DENYLIST.some((term) => k.includes(term));
+};
+var redact = (value, redactKeys, seen) => {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((v) => redact(v, redactKeys, seen));
+  const out = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (FRAMEWORK_INTERNAL_KEYS.has(key)) continue;
+    if (isSecretKey(key, redactKeys)) {
+      if (val !== null && typeof val === "object") {
+        out[key] = "[redacted]";
+      }
+      continue;
+    }
+    out[key] = redact(val, redactKeys, seen);
+  }
+  return out;
+};
+var sanitizeData = (value, opts) => {
+  let cleaned;
+  try {
+    cleaned = redact(value, opts.redactKeys ?? [], /* @__PURE__ */ new WeakSet());
+  } catch {
+    cleaned = "[unserializable]";
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(cleaned) ?? "";
+  } catch {
+    return { value: "[unserializable]", truncated: false };
+  }
+  if (serialized.length <= opts.maxBytes) return { value: cleaned, truncated: false };
+  return {
+    value: { _truncated: true, preview: serialized.slice(0, opts.maxBytes) },
+    truncated: true
+  };
+};
+
+// src/exulu/auth/describe.ts
+var describeCredentialIdentity = async (auth, userId, toolId) => {
+  const provider = providerKeyFor(toolId ?? auth.provider, auth);
+  const base = {
+    provider,
+    authType: auth.authType,
+    account: String(userId)
+  };
+  if (auth.authType !== "oauth") return base;
+  try {
+    const row = await credentialStore.get(provider, userId);
+    if (!row || row.authType !== "oauth") return base;
+    const { scopes, expiresAt } = row.data;
+    return {
+      ...base,
+      ...scopes ? { scopes: scopes.split(" ").filter(Boolean) } : {},
+      ...expiresAt !== void 0 ? { expiresAt } : {}
+    };
+  } catch (error) {
+    console.error(`[EXULU] describeCredentialIdentity failed for provider "${provider}":`, error);
+    return base;
+  }
+};
+
+// src/exulu/audit/emitters/tool-call.ts
+var str = (v) => v === void 0 || v === null ? void 0 : String(v);
+var isAuthShortCircuit = (output) => {
+  if (!output || typeof output !== "object") return false;
+  const o = output;
+  return !!o.credentialRequest || !!o.oauth?.authorizationUrl;
+};
+var buildToolCallEvent = async (ctx, opts) => {
+  const nowIso = opts.nowIso ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const status = ctx.status === "error" ? "error" : isAuthShortCircuit(ctx.output) ? "auth_required" : "ok";
+  const input = sanitizeData(ctx.input, { maxBytes: opts.maxBytes, redactKeys: opts.redactKeys });
+  const data = { input: input.value };
+  const truncated = {};
+  if (input.truncated) truncated.input = true;
+  if (opts.captureOutput && status !== "auth_required") {
+    const output = sanitizeData(ctx.output, { maxBytes: opts.maxBytes, redactKeys: opts.redactKeys });
+    data.output = output.value;
+    if (output.truncated) truncated.output = true;
+  }
+  let credential;
+  if (ctx.tool.authentication && ctx.user?.id != null) {
+    credential = await describeCredentialIdentity(
+      ctx.tool.authentication,
+      Number(ctx.user.id),
+      ctx.tool.id
+    );
+  }
+  const err = ctx.error;
+  return {
+    v: 1,
+    ts: nowIso(),
+    type: AUDIT_EVENT_TYPES.TOOL_CALL,
+    actor: {
+      kind: "user",
+      userId: str(ctx.user?.id),
+      email: ctx.user?.email,
+      roleId: str(ctx.user?.role?.id),
+      projectId: ctx.projectId
+    },
+    context: {
+      sessionId: ctx.sessionID,
+      agentId: ctx.agent?.id,
+      agentName: ctx.agent?.name,
+      toolCallId: ctx.toolCallId
+    },
+    target: { kind: "tool", id: ctx.tool.id, name: ctx.tool.name, category: ctx.tool.category, builtin: ctx.builtin },
+    ...credential ? { credential } : {},
+    status,
+    ...status === "error" ? { error: { name: err?.name, message: String(err?.message ?? err ?? "unknown error") } } : {},
+    data,
+    durationMs: ctx.durationMs,
+    ...Object.keys(truncated).length ? { truncated } : {}
+  };
+};
+
+// src/exulu/audit/logger.ts
+var noop = {
+  enabled: false,
+  failClosed: false,
+  isBuiltin: () => false,
+  shouldAuditTool: () => false,
+  record: () => {
+  },
+  recordToolCall: async () => {
+  },
+  flush: async () => {
+  },
+  close: async () => {
+  }
+};
+var RealAuditLogger = class {
+  constructor(resolved, builtinToolIds) {
+    this.resolved = resolved;
+    this.builtinToolIds = builtinToolIds;
+    this.failClosed = resolved.failureMode === "closed";
+    const writer = createAuditS3Writer(resolved.target);
+    this.sink = new AuditSink(resolved, writer, createFsSpoolStore(resolved.spoolDir));
+  }
+  enabled = true;
+  failClosed;
+  sink;
+  lifecycleWriter() {
+    return createAuditS3Writer(this.resolved.target);
+  }
+  isBuiltin(id) {
+    return this.builtinToolIds.has(id);
+  }
+  shouldAuditTool(id) {
+    const t = this.resolved.toolCalls;
+    if (!t.enabled) return false;
+    if (t.exclude.includes(id)) return false;
+    if (t.include.length > 0) return t.include.includes(id);
+    return true;
+  }
+  record(event) {
+    this.sink.record(event);
+  }
+  async recordToolCall(ctx) {
+    const event = await buildToolCallEvent(ctx, {
+      maxBytes: this.resolved.payload.maxBytes,
+      captureOutput: this.resolved.payload.captureOutput,
+      redactKeys: this.resolved.payload.redactKeys
+    });
+    if (this.failClosed) await this.sink.recordDurable(event);
+    else this.sink.record(event);
+  }
+  flush() {
+    return this.sink.flush();
+  }
+  close() {
+    return this.sink.close();
+  }
+  get resolvedConfig() {
+    return this.resolved;
+  }
+};
+var _instance;
+var _signalClose;
+var build = (config, builtinToolIds) => {
+  const resolved = resolveAuditConfig(config);
+  return resolved ? new RealAuditLogger(resolved, builtinToolIds) : noop;
+};
+var getAuditLogger = (config) => {
+  if (!_instance) _instance = build(config, /* @__PURE__ */ new Set());
+  return _instance;
+};
+var initAudit = async (config, opts) => {
+  _instance = build(config, opts?.builtinToolIds ?? /* @__PURE__ */ new Set());
+  if (_instance instanceof RealAuditLogger) {
+    const r = _instance.resolvedConfig;
+    await applyRetentionLifecycle(_instance.lifecycleWriter(), {
+      prefix: r.target.s3prefix,
+      retentionDays: r.retentionDays,
+      manage: r.manageLifecycle
+    });
+    if (_signalClose) {
+      process.off("SIGTERM", _signalClose);
+      process.off("SIGINT", _signalClose);
+    }
+    const close = () => {
+      void _instance?.close();
+    };
+    _signalClose = close;
+    process.on("SIGTERM", close);
+    process.on("SIGINT", close);
+  }
+  return _instance;
+};
+
+// src/exulu/audit/emit-tool-call.ts
+var emitToolCallAudit = async (logger, ctx) => {
+  if (!logger.shouldAuditTool(ctx.tool.id)) return;
+  const full = { ...ctx, builtin: logger.isBuiltin(ctx.tool.id) };
+  if (logger.failClosed) {
+    await logger.recordToolCall(full);
+    return;
+  }
+  logger.recordToolCall(full).catch(
+    (error) => console.error(`[EXULU] audit: recordToolCall failed for tool "${ctx.tool.id}":`, error)
+  );
+};
+
 // src/templates/tools/convert-exulu-tools-to-ai-sdk-tools.ts
 var OUTPUT_OFFLOAD_EXEMPT_TOOL_IDS = /* @__PURE__ */ new Set(["agentic_context_search"]);
-var generateS3Key = (filename) => `${randomUUID4()}-${filename}`;
+var generateS3Key = (filename) => `${randomUUID5()}-${filename}`;
 var s3Client2;
 var getMimeType = (type) => {
   switch (type) {
@@ -7368,8 +7690,8 @@ var hydrateVariables = async (tool3) => {
     }
     let value = variable.value;
     if (variable.encrypted) {
-      const bytes = CryptoJS5.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
-      value = bytes.toString(CryptoJS5.enc.Utf8);
+      const bytes = CryptoJS4.AES.decrypt(variable.value, process.env.NEXTAUTH_SECRET);
+      value = bytes.toString(CryptoJS4.enc.Utf8);
     }
     toolConfig.value = value;
     return toolConfig;
@@ -7377,7 +7699,7 @@ var hydrateVariables = async (tool3) => {
   await Promise.all(promises);
   return tool3;
 };
-var convertExuluToolsToAiSdkTools = async (currentTools, currentSkills, approvedTools, allExuluTools, configs, providerapikey, contexts, user, exuluConfig, sessionID, req, project, sessionItems, model, agent, memoryItems, contextWindow, disabledTools) => {
+var convertExuluToolsToAiSdkTools = async (currentTools, currentSkills, approvedTools, allExuluTools, configs, contexts, user, exuluConfig, sessionID, req, project, sessionItems, model, agent, memoryItems, contextWindow, disabledTools) => {
   if (!currentTools) return {};
   if (!allExuluTools) {
     allExuluTools = [];
@@ -7612,124 +7934,162 @@ var convertExuluToolsToAiSdkTools = async (currentTools, currentSkills, approved
               "and options",
               options
             );
-            if (!cur.tool?.execute) {
-              console.error("[EXULU] Tool execute function is undefined.", cur.tool);
-              throw new Error("Tool execute function is undefined.");
-            }
-            if (toolVariableConfig) {
-              toolVariableConfig = await hydrateVariables(toolVariableConfig || []);
-            }
-            let upload = void 0;
-            if (exuluConfig?.fileUploads?.s3endpoint && exuluConfig?.fileUploads?.s3key && exuluConfig?.fileUploads?.s3secret && exuluConfig?.fileUploads?.s3Bucket) {
-              s3Client2 ??= new S3Client2({
-                region: exuluConfig?.fileUploads?.s3region,
-                ...exuluConfig?.fileUploads?.s3endpoint && {
-                  forcePathStyle: true,
-                  endpoint: exuluConfig?.fileUploads?.s3endpoint
-                },
-                credentials: {
-                  accessKeyId: exuluConfig?.fileUploads?.s3key ?? "",
-                  secretAccessKey: exuluConfig?.fileUploads?.s3secret ?? ""
-                }
-              });
-              upload = async ({
-                name,
-                data,
-                type
-              }) => {
-                const mime = getMimeType(type);
-                const prefix = exuluConfig?.fileUploads?.s3prefix ? `${exuluConfig.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
-                const key = `${prefix}${user?.id}/${generateS3Key(name)}${type}`;
-                const command = new PutObjectCommand2({
-                  Bucket: exuluConfig?.fileUploads?.s3Bucket,
-                  Key: key,
-                  Body: data,
-                  ContentType: mime
-                });
-                try {
-                  if (!s3Client2) {
-                    throw new Error("S3 client not initialized");
+            const __auditStart = Date.now();
+            let __auditOutput;
+            let __auditStatus = "ok";
+            let __auditError;
+            try {
+              if (!cur.tool?.execute) {
+                console.error("[EXULU] Tool execute function is undefined.", cur.tool);
+                throw new Error("Tool execute function is undefined.");
+              }
+              if (toolVariableConfig) {
+                toolVariableConfig = await hydrateVariables(toolVariableConfig || []);
+              }
+              let upload = void 0;
+              if (exuluConfig?.fileUploads?.s3endpoint && exuluConfig?.fileUploads?.s3key && exuluConfig?.fileUploads?.s3secret && exuluConfig?.fileUploads?.s3Bucket) {
+                s3Client2 ??= new S3Client3({
+                  region: exuluConfig?.fileUploads?.s3region,
+                  ...exuluConfig?.fileUploads?.s3endpoint && {
+                    forcePathStyle: true,
+                    endpoint: exuluConfig?.fileUploads?.s3endpoint
+                  },
+                  credentials: {
+                    accessKeyId: exuluConfig?.fileUploads?.s3key ?? "",
+                    secretAccessKey: exuluConfig?.fileUploads?.s3secret ?? ""
                   }
-                  await s3Client2.send(command);
-                  const bucket = exuluConfig?.fileUploads?.s3Bucket ?? "";
-                  const presignedUrl = await getPresignedUrl(bucket, key, exuluConfig);
-                  return { url: presignedUrl, key: `${bucket}/${key}` };
-                } catch (caught) {
-                  if (caught instanceof S3ServiceException && caught.name === "EntityTooLarge") {
-                    throw new Error(`[EXULU] Error from S3 while uploading object to ${exuluConfig?.fileUploads?.s3Bucket}.                                       The object was too large. To upload objects larger than 5GB, use the S3 console (160GB max)                                       or the multipart upload API (5TB max).`);
-                  } else if (caught instanceof S3ServiceException) {
-                    throw new Error(
-                      `[EXULU] Error from S3 while uploading object to ${exuluConfig?.fileUploads?.s3Bucket}.  ${caught.name}: ${caught.message}`
-                    );
-                  } else {
-                    throw caught;
+                });
+                upload = async ({
+                  name,
+                  data,
+                  type
+                }) => {
+                  const mime = getMimeType(type);
+                  const prefix = exuluConfig?.fileUploads?.s3prefix ? `${exuluConfig.fileUploads.s3prefix.replace(/\/$/, "")}/` : "";
+                  const key = `${prefix}${user?.id}/${generateS3Key(name)}${type}`;
+                  const command = new PutObjectCommand3({
+                    Bucket: exuluConfig?.fileUploads?.s3Bucket,
+                    Key: key,
+                    Body: data,
+                    ContentType: mime
+                  });
+                  try {
+                    if (!s3Client2) {
+                      throw new Error("S3 client not initialized");
+                    }
+                    await s3Client2.send(command);
+                    const bucket = exuluConfig?.fileUploads?.s3Bucket ?? "";
+                    const presignedUrl = await getPresignedUrl(bucket, key, exuluConfig);
+                    return { url: presignedUrl, key: `${bucket}/${key}` };
+                  } catch (caught) {
+                    if (caught instanceof S3ServiceException && caught.name === "EntityTooLarge") {
+                      throw new Error(`[EXULU] Error from S3 while uploading object to ${exuluConfig?.fileUploads?.s3Bucket}.                                       The object was too large. To upload objects larger than 5GB, use the S3 console (160GB max)                                       or the multipart upload API (5TB max).`);
+                    } else if (caught instanceof S3ServiceException) {
+                      throw new Error(
+                        `[EXULU] Error from S3 while uploading object to ${exuluConfig?.fileUploads?.s3Bucket}.  ${caught.name}: ${caught.message}`
+                      );
+                    } else {
+                      throw caught;
+                    }
                   }
-                }
-              };
-            }
-            const contextsMap = contexts?.reduce((acc, curr) => {
-              acc[curr.id] = curr;
-              return acc;
-            }, {});
-            const toolVariablesConfigData = toolVariableConfig ? toolVariableConfig.config.reduce((acc, curr) => {
-              acc[curr.name] = curr.value;
-              return acc;
-            }, {}) : {};
-            const response = await cur.tool.execute(
-              {
-                ...inputs,
-                model,
+                };
+              }
+              const contextsMap = contexts?.reduce((acc, curr) => {
+                acc[curr.id] = curr;
+                return acc;
+              }, {});
+              const toolVariablesConfigData = toolVariableConfig ? toolVariableConfig.config.reduce((acc, curr) => {
+                acc[curr.name] = curr.value;
+                return acc;
+              }, {}) : {};
+              const response = await cur.tool.execute(
+                {
+                  ...inputs,
+                  model,
+                  sessionID,
+                  sessionItems,
+                  memory: memoryItems,
+                  req,
+                  // Convert config to object format if a config object
+                  // is available, after we added the .value property
+                  // by hydrating it from the variables table.
+                  allExuluTools,
+                  currentTools,
+                  user,
+                  contexts: contextsMap,
+                  upload,
+                  exuluConfig,
+                  toolVariablesConfig: toolVariablesConfigData
+                },
+                options
+              );
+              await updateStatistic({
+                name: "count",
+                label: cur.name,
+                type: STATISTICS_TYPE_ENUM.TOOL_CALL,
+                trigger: "agent",
+                count: 1,
+                user: user?.id,
+                role: user?.role?.id
+              });
+              const guardCtx = {
+                toolName: cur.name,
+                contextWindow,
                 sessionID,
-                sessionItems,
-                memory: memoryItems,
-                req,
-                // Convert config to object format if a config object
-                // is available, after we added the .value property
-                // by hydrating it from the variables table.
-                providerapikey,
-                allExuluTools,
-                currentTools,
                 user,
-                contexts: contextsMap,
-                upload,
-                exuluConfig,
-                toolVariablesConfig: toolVariablesConfigData
-              },
-              options
-            );
-            await updateStatistic({
-              name: "count",
-              label: cur.name,
-              type: STATISTICS_TYPE_ENUM.TOOL_CALL,
-              trigger: "agent",
-              count: 1,
-              user: user?.id,
-              role: user?.role?.id
-            });
-            const guardCtx = {
-              toolName: cur.name,
-              contextWindow,
-              sessionID,
-              user,
-              exuluConfig
-            };
-            const offloadExempt = OUTPUT_OFFLOAD_EXEMPT_TOOL_IDS.has(cur.id);
-            if (response && typeof response === "object" && Symbol.asyncIterator in response) {
-              let lastValue;
-              for await (const value of response) {
-                yield value;
-                lastValue = value;
-              }
-              if (offloadExempt) return lastValue;
-              const guarded = await guardToolOutput(lastValue, guardCtx);
-              if (guarded !== lastValue) {
+                exuluConfig
+              };
+              const offloadExempt = OUTPUT_OFFLOAD_EXEMPT_TOOL_IDS.has(cur.id);
+              if (response && typeof response === "object" && Symbol.asyncIterator in response) {
+                let lastValue;
+                for await (const value of response) {
+                  yield value;
+                  lastValue = value;
+                }
+                if (offloadExempt) {
+                  __auditOutput = lastValue;
+                  return lastValue;
+                }
+                const guarded = await guardToolOutput(lastValue, guardCtx);
+                if (guarded !== lastValue) {
+                  yield guarded;
+                }
+                __auditOutput = guarded;
+                return guarded;
+              } else {
+                const guarded = offloadExempt ? response : await guardToolOutput(response, guardCtx);
                 yield guarded;
+                __auditOutput = guarded;
+                return guarded;
+              }
+            } catch (error) {
+              __auditStatus = "error";
+              __auditError = error;
+              throw error;
+            } finally {
+              const __auditLogger = getAuditLogger(exuluConfig ?? {});
+              if (__auditLogger.shouldAuditTool(cur.id)) {
+                const __emit = emitToolCallAudit(__auditLogger, {
+                  durationMs: Date.now() - __auditStart,
+                  agent: agent ? { id: agent.id, name: agent.name, slug: agent.slug } : void 0,
+                  tool: { id: cur.id, name: cur.name, category: cur.category, authentication: cur.authentication },
+                  user,
+                  projectId: project ? String(project) : void 0,
+                  sessionID,
+                  toolCallId: options?.toolCallId,
+                  input: inputs,
+                  output: __auditOutput,
+                  status: __auditStatus,
+                  error: __auditError
+                });
+                if (__auditLogger.failClosed) {
+                  await __emit;
+                } else {
+                  __emit.catch(
+                    (error) => console.error(`[EXULU] audit: tool-call emit failed for "${cur.id}":`, error)
+                  );
+                }
               }
-              return guarded;
-            } else {
-              const guarded = offloadExempt ? response : await guardToolOutput(response, guardCtx);
-              yield guarded;
-              return guarded;
             }
           }
         }
@@ -7781,7 +8141,6 @@ export {
   getUserBudgetView,
   updateStatistic,
   checkLicense,
-  checkRecordAccess,
   ResolveModelError,
   resolveModel,
   exuluApp,
@@ -7815,6 +8174,8 @@ export {
   PreviewRenderError,
   getPdfPreviewBytes,
   imageAttachmentGuard,
+  getAuditLogger,
+  initAudit,
   hydrateVariables,
   convertExuluToolsToAiSdkTools,
   ExuluTool,