@exulu/backend 3.0.0 → 3.2.0

package/dist/{chunk-KFL7HIID.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,166 +1088,171 @@ 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/oauth/validate.ts
-var REQUIRED_STRING_FIELDS = [
+// src/exulu/auth/validate.ts
+var OAUTH_REQUIRED_STRING_FIELDS = [
   "authorizationUrl",
   "tokenUrl",
   "clientId",
   "clientSecret"
 ];
-var validateOauthConfig = (toolId, config) => {
-  for (const field of REQUIRED_STRING_FIELDS) {
-    if (!config[field] || typeof config[field] !== "string") {
+var validateAuthConfig = (toolId, config) => {
+  if (config.authType === "oauth") {
+    for (const field of OAUTH_REQUIRED_STRING_FIELDS) {
+      const value = config[field];
+      if (!value || typeof value !== "string") {
+        throw new Error(
+          `ExuluTool "${toolId}": oauth.${field} is required and must be a non-empty string.`
+        );
+      }
+    }
+    if (!Array.isArray(config.scopes)) {
       throw new Error(
-        `ExuluTool "${toolId}": oauth.${field} is required and must be a non-empty string.`
+        `ExuluTool "${toolId}": oauth.scopes must be an array of strings (use [] to request no scopes).`
       );
     }
+    if (config.provider !== void 0) {
+      if (typeof config.provider !== "string" || config.provider.length === 0 || config.provider.trim() !== config.provider) {
+        throw new Error(
+          `ExuluTool "${toolId}": oauth.provider must be a non-empty string with no leading or trailing whitespace when set.`
+        );
+      }
+    }
+    if (!process.env.BACKEND) {
+      throw new Error(
+        `ExuluTool "${toolId}": oauth requires the BACKEND environment variable (the backend's public base URL) to build the redirect URI.`
+      );
+    }
+    return;
   }
-  if (!Array.isArray(config.scopes)) {
-    throw new Error(
-      `ExuluTool "${toolId}": oauth.scopes must be an array of strings (use [] to request no scopes).`
-    );
-  }
-  if (config.provider !== void 0) {
+  if (config.authType === "user_credentials") {
     if (typeof config.provider !== "string" || config.provider.length === 0 || config.provider.trim() !== config.provider) {
       throw new Error(
-        `ExuluTool "${toolId}": oauth.provider must be a non-empty string with no leading or trailing whitespace when set.`
+        `ExuluTool "${toolId}": user_credentials.provider must be a non-empty string with no leading or trailing whitespace.`
       );
     }
+    if (!Array.isArray(config.fields) || config.fields.length === 0) {
+      throw new Error(
+        `ExuluTool "${toolId}": user_credentials.fields must contain at least one field.`
+      );
+    }
+    const seenNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < config.fields.length; i++) {
+      const field = config.fields[i];
+      const name = field.name;
+      if (typeof name !== "string" || name.length === 0 || name.trim() !== name) {
+        throw new Error(
+          `ExuluTool "${toolId}": user_credentials.fields[${i}].name must be a non-empty string with no leading or trailing whitespace.`
+        );
+      }
+      if (seenNames.has(name)) {
+        throw new Error(
+          `ExuluTool "${toolId}": user_credentials.fields has duplicate field name '${name}'.`
+        );
+      }
+      seenNames.add(name);
+      const type = field.type;
+      if (type !== "text" && type !== "password") {
+        throw new Error(
+          `ExuluTool "${toolId}": user_credentials.fields[${i}].type must be 'text' or 'password' (got '${type}').`
+        );
+      }
+    }
+    if (!process.env.BACKEND) {
+      throw new Error(
+        `ExuluTool "${toolId}": user_credentials requires the BACKEND environment variable (the backend's public base URL) to build the credential submit URL.`
+      );
+    }
+    return;
   }
-  if (!process.env.BACKEND) {
-    throw new Error(
-      `ExuluTool "${toolId}": oauth requires the BACKEND environment variable (the backend's public base URL) to build the redirect URI.`
-    );
-  }
+  throw new Error(
+    `ExuluTool "${toolId}": auth.authType '${config.authType}' is not supported.`
+  );
 };
 
-// src/exulu/oauth/provider-key.ts
+// src/exulu/auth/provider-key.ts
 var providerKeyFor = (toolId, config) => config.provider && config.provider.length > 0 ? config.provider : toolId;
 
-// src/exulu/oauth/registry.ts
+// src/exulu/auth/registry.ts
 var byProvider = /* @__PURE__ */ new Map();
 var byTool = /* @__PURE__ */ new Map();
-var STABLE_STRING_FIELDS = [
+var STABLE_OAUTH_STRING_FIELDS = [
   "authorizationUrl",
   "tokenUrl",
   "clientId",
   "clientSecret"
 ];
 var assertCompatible = (providerKey, toolId, existing, next) => {
-  for (const field of STABLE_STRING_FIELDS) {
-    if (existing[field] !== next[field]) {
+  if (existing.authType !== next.authType) {
+    throw new Error(
+      `ExuluTool "${toolId}": auth.authType '${next.authType}' disagrees with another tool that shares provider "${providerKey}" using authType '${existing.authType}'.`
+    );
+  }
+  if (existing.authType === "oauth" && next.authType === "oauth") {
+    for (const field of STABLE_OAUTH_STRING_FIELDS) {
+      if (existing[field] !== next[field]) {
+        throw new Error(
+          `ExuluTool "${toolId}": oauth.${field} disagrees with another tool that shares provider "${providerKey}". Every tool on the same provider must use identical authorizationUrl/tokenUrl/clientId/clientSecret.`
+        );
+      }
+    }
+    const a = new Set(existing.scopes);
+    const b = new Set(next.scopes);
+    if (a.size !== b.size || [...a].some((s) => !b.has(s))) {
       throw new Error(
-        `ExuluTool "${toolId}": oauth.${field} disagrees with another tool that shares provider "${providerKey}". Every tool on the same provider must use identical authorizationUrl/tokenUrl/clientId/clientSecret.`
+        `ExuluTool "${toolId}": oauth.scopes disagrees with another tool that shares provider "${providerKey}". Every tool on the same provider must declare the same scope superset. Existing: [${[...a].sort().join(", ")}]. This tool: [${[...b].sort().join(", ")}].`
       );
     }
+    return;
   }
-  const a = new Set(existing.scopes);
-  const b = new Set(next.scopes);
-  if (a.size !== b.size || [...a].some((s) => !b.has(s))) {
-    throw new Error(
-      `ExuluTool "${toolId}": oauth.scopes disagrees with another tool that shares provider "${providerKey}". Every tool on the same provider must declare the same scope superset. Existing: [${[...a].sort().join(", ")}]. This tool: [${[...b].sort().join(", ")}].`
-    );
+  if (existing.authType === "user_credentials" && next.authType === "user_credentials") {
+    if (JSON.stringify(existing.fields) !== JSON.stringify(next.fields)) {
+      throw new Error(
+        `ExuluTool "${toolId}": user_credentials.fields disagrees with another tool that shares provider "${providerKey}". Every tool on the same provider must declare structurally identical fields (same names, types, and order).`
+      );
+    }
+    return;
   }
 };
-var oauthRegistry = {
+var authRegistry = {
   register: (toolId, config) => {
     const providerKey = providerKeyFor(toolId, config);
     const existing = byProvider.get(providerKey);
@@ -1367,60 +1272,74 @@ var oauthRegistry = {
   }
 };
 
-// src/exulu/oauth/flow.ts
-import CryptoJS3 from "crypto-js";
+// src/exulu/auth/flow.ts
+import CryptoJS2 from "crypto-js";
 import { createHash, randomBytes } from "crypto";
 
-// src/exulu/oauth/token-store.ts
-import CryptoJS2 from "crypto-js";
-var TABLE = "oauth_tokens";
-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 oauthTokenStore = {
-  get: async (providerKey, userId) => {
-    const { db: db2 } = await postgresClient();
-    const row = await db2.from(TABLE).where({ provider: providerKey, user_id: userId }).first();
-    if (!row) {
-      return null;
-    }
-    return {
-      accessToken: decrypt(row.access_token),
-      refreshToken: row.refresh_token ? decrypt(row.refresh_token) : null,
-      tokenType: row.token_type ?? null,
-      scopes: row.scopes ?? null,
-      expiresAt: row.expires_at ? new Date(row.expires_at) : null
-    };
-  },
-  // toolId is stored on every written row as an audit trail — which tool
-  // triggered the last grant/refresh — but does NOT participate in the key.
-  upsert: async (providerKey, userId, toolId, record) => {
-    const { db: db2 } = await postgresClient();
-    const existing = await db2.from(TABLE).where({ provider: providerKey, user_id: userId }).first();
-    const values = {
-      provider: providerKey,
-      tool_id: toolId,
-      access_token: encrypt(record.accessToken),
-      // Providers like Google only send a refresh_token on first consent;
-      // never overwrite a stored one with nothing.
-      refresh_token: record.refreshToken ? encrypt(record.refreshToken) : existing?.refresh_token ?? null,
-      token_type: record.tokenType ?? null,
-      scopes: record.scopes ?? null,
-      expires_at: record.expiresAt ?? null,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    if (existing) {
-      await db2.from(TABLE).where({ provider: providerKey, user_id: userId }).update(values);
-    } else {
-      await db2.from(TABLE).insert({ user_id: userId, ...values });
-    }
-  },
-  delete: async (providerKey, userId) => {
-    const { db: db2 } = await postgresClient();
-    await db2.from(TABLE).where({ provider: providerKey, user_id: userId }).del();
+// src/exulu/auth/credential-store.ts
+import CryptoJS from "crypto-js";
+var TABLE = "user_credentials";
+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();
+  if (!row) {
+    return null;
   }
-};
+  return {
+    provider,
+    userId,
+    authType: row.auth_type,
+    data: JSON.parse(decrypt(row.data))
+  };
+}
+async function upsert(record) {
+  const { db: db2 } = await postgresClient();
+  const encrypted = encrypt(JSON.stringify(record.data));
+  await db2.from(TABLE).insert({
+    provider: record.provider,
+    user_id: String(record.userId),
+    auth_type: record.authType,
+    data: encrypted,
+    updated_at: /* @__PURE__ */ new Date()
+  }).onConflict(["provider", "user_id"]).merge({ auth_type: record.authType, data: encrypted, updated_at: /* @__PURE__ */ new Date() });
+}
+async function listByUser(userId) {
+  const { db: db2 } = await postgresClient();
+  const list = await db2.from(TABLE).where({ user_id: String(userId) }).orderBy("provider");
+  return list.map((row) => ({
+    provider: row.provider,
+    authType: row.auth_type,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  }));
+}
+async function del(provider, userId) {
+  const { db: db2 } = await postgresClient();
+  await db2.from(TABLE).where({ provider, user_id: String(userId) }).del();
+}
+var credentialStore = { get, upsert, listByUser, delete: del };
 
-// src/exulu/oauth/flow.ts
+// src/exulu/auth/flow.ts
+function oauthRecordToBlob(r) {
+  return {
+    accessToken: r.accessToken,
+    refreshToken: r.refreshToken ?? null,
+    tokenType: r.tokenType ?? null,
+    scopes: r.scopes ?? null,
+    expiresAt: r.expiresAt ? r.expiresAt.toISOString() : null
+  };
+}
+function oauthBlobToRecord(b) {
+  return {
+    accessToken: b.accessToken,
+    refreshToken: b.refreshToken,
+    tokenType: b.tokenType,
+    scopes: b.scopes,
+    expiresAt: b.expiresAt ? new Date(b.expiresAt) : null
+  };
+}
 var OAUTH_CALLBACK_PATH = "/oauth/callback";
 var STATE_TTL_MS = 10 * 60 * 1e3;
 var EXPIRY_SKEW_MS = 30 * 1e3;
@@ -1440,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.");
@@ -1563,7 +1482,8 @@ var getValidAccessToken = async ({
   toolId,
   config
 }) => {
-  const stored = await oauthTokenStore.get(providerKey, userId);
+  const credRow = await credentialStore.get(providerKey, userId);
+  const stored = credRow ? oauthBlobToRecord(credRow.data) : null;
   if (!stored) {
     return null;
   }
@@ -1572,7 +1492,7 @@ var getValidAccessToken = async ({
     return stored;
   }
   if (!stored.refreshToken) {
-    await oauthTokenStore.delete(providerKey, userId);
+    await credentialStore.delete(providerKey, userId);
     return null;
   }
   try {
@@ -1580,20 +1500,127 @@ var getValidAccessToken = async ({
     if (!refreshed.refreshToken) {
       refreshed.refreshToken = stored.refreshToken;
     }
-    await oauthTokenStore.upsert(providerKey, userId, toolId, refreshed);
+    await credentialStore.upsert({
+      provider: providerKey,
+      userId,
+      authType: "oauth",
+      data: oauthRecordToBlob(refreshed)
+    });
     return refreshed;
   } catch (error) {
     console.error(
       `[EXULU] OAuth token refresh failed for provider "${providerKey}" tool "${toolId}" user ${userId}:`,
       error
     );
-    await oauthTokenStore.delete(providerKey, userId);
+    await credentialStore.delete(providerKey, userId);
     return null;
   }
 };
 
-// src/exulu/oauth/wrap-execute.ts
-var wrapExecuteWithOauth = (toolId, config, execute) => {
+// src/exulu/auth/state.ts
+async function getValidUserCredentials(cfg, userId) {
+  const row = await credentialStore.get(cfg.provider, userId);
+  if (!row || row.authType !== "user_credentials") return null;
+  const values = {};
+  for (const [k, v] of Object.entries(row.data)) {
+    if (typeof v !== "string") return null;
+    values[k] = v;
+  }
+  return values;
+}
+
+// src/exulu/auth/credentials-request.ts
+var DEFAULT_TTL_SECONDS = 15 * 60;
+function buildCredentialRequest(cfg, opts) {
+  const ttl = opts.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const claims = {
+    provider: cfg.provider,
+    userId: opts.userId,
+    expiresAt: Math.floor(Date.now() / 1e3) + ttl
+  };
+  const nonce = encrypt(JSON.stringify(claims));
+  return {
+    provider: cfg.provider,
+    fields: cfg.fields,
+    submitUrl: `${opts.baseUrl.replace(/\/+$/, "")}/credentials/submit`,
+    nonce
+  };
+}
+function verifyCredentialNonce(nonce) {
+  let claims;
+  try {
+    claims = JSON.parse(decrypt(nonce));
+  } catch {
+    throw new Error("Invalid credential nonce");
+  }
+  if (typeof claims.provider !== "string" || typeof claims.userId !== "string" || typeof claims.expiresAt !== "number") {
+    throw new Error("Malformed credential nonce claims");
+  }
+  if (claims.expiresAt < Math.floor(Date.now() / 1e3)) {
+    throw new Error("Credential nonce expired");
+  }
+  return claims;
+}
+
+// src/exulu/auth/short-circuit.ts
+function credentialRequestResult(request) {
+  return { credentialRequest: request, result: null };
+}
+
+// src/exulu/auth/errors.ts
+var CredentialInvalidError = class extends Error {
+  provider;
+  reason;
+  constructor(provider, reason) {
+    super(reason ? `Credential invalid for provider '${provider}': ${reason}` : `Credential invalid for provider '${provider}'`);
+    this.name = "CredentialInvalidError";
+    this.provider = provider;
+    this.reason = reason;
+  }
+};
+
+// src/exulu/auth/wrap-execute.ts
+var wrapExecuteWithAuth = (toolId, config, execute) => {
+  if (config.authType === "oauth") {
+    return wrapExecuteWithOauthInternal(toolId, config, execute);
+  }
+  if (config.authType === "user_credentials") {
+    return wrapUserCredentials(toolId, config, execute);
+  }
+  throw new Error(`ExuluTool "${toolId}": unknown authType`);
+};
+var wrapUserCredentials = (toolId, config, execute) => {
+  return async (inputs, options) => {
+    const userId = inputs?.user?.id;
+    if (!userId) {
+      return {
+        result: `The "${toolId}" tool requires user-supplied credentials, which needs a signed-in user. No user identity is available for this run.`
+      };
+    }
+    const baseUrl = (process.env.BACKEND ?? "").replace(/\/+$/, "");
+    if (!baseUrl) {
+      return {
+        result: `The "${toolId}" tool requires the BACKEND env var to build the credential submit URL.`
+      };
+    }
+    const values = await getValidUserCredentials(config, userId);
+    if (!values) {
+      const request = buildCredentialRequest(config, { baseUrl, userId: String(userId) });
+      return credentialRequestResult(request);
+    }
+    try {
+      return await execute({ ...inputs, credentials: values }, options);
+    } catch (e) {
+      if (e instanceof CredentialInvalidError && e.provider === config.provider) {
+        await credentialStore.delete(config.provider, userId);
+        const request = buildCredentialRequest(config, { baseUrl, userId: String(userId) });
+        return credentialRequestResult(request);
+      }
+      throw e;
+    }
+  };
+};
+var wrapExecuteWithOauthInternal = (toolId, config, execute) => {
   return async (inputs, options) => {
     const userId = inputs?.user?.id;
     if (!userId) {
@@ -1633,7 +1660,7 @@ var ExuluTool = class _ExuluTool {
   type;
   tool;
   needsApproval;
-  oauth;
+  authentication;
   config;
   constructor({
     id,
@@ -1645,7 +1672,7 @@ var ExuluTool = class _ExuluTool {
     execute,
     config,
     needsApproval,
-    oauth
+    authentication: authentication2
   }) {
     if (!PUBLIC_TOOL_TYPES.includes(type)) {
       throw new Error(
@@ -1654,11 +1681,11 @@ var ExuluTool = class _ExuluTool {
         )}. The "agent" and "context" types are managed by Exulu internally and cannot be set on a tool.`
       );
     }
-    if (oauth) {
-      validateOauthConfig(id, oauth);
-      oauthRegistry.register(id, oauth);
+    if (authentication2) {
+      validateAuthConfig(id, authentication2);
+      authRegistry.register(id, authentication2);
     }
-    this.oauth = oauth;
+    this.authentication = authentication2;
     this.id = id;
     this.config = config;
     this.needsApproval = needsApproval ?? true;
@@ -1670,7 +1697,7 @@ var ExuluTool = class _ExuluTool {
     this.tool = tool({
       description,
       inputSchema: inputSchema || z.object({}),
-      execute: oauth ? wrapExecuteWithOauth(id, oauth, execute) : execute
+      execute: authentication2 ? wrapExecuteWithAuth(id, authentication2, execute) : execute
     });
   }
   /**
@@ -1706,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-YY2WIMMJ.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,
@@ -1799,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";
@@ -2230,11 +2244,14 @@ function buildProjectKbProfileDefaults(items) {
 }
 
 // ee/agentic-retrieval/pipeline/routing.ts
-import { generateText as generateText2, Output as Output2 } from "ai";
 import { z as z5 } from "zod";
 
+// ee/agentic-retrieval/pipeline/micro-call.ts
+import { generateText, NoOutputGeneratedError, Output } from "ai";
+
 // src/utils/with-retry.ts
-async function withRetry(generateFn, maxRetries = 3) {
+async function withRetry(generateFn, maxRetries = 3, opts = {}) {
+  const { shouldRetry, baseDelayMs = 1e3 } = opts;
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
@@ -2242,18 +2259,66 @@ async function withRetry(generateFn, maxRetries = 3) {
     } catch (error) {
       lastError = error;
       console.error(`[EXULU] generateText attempt ${attempt} failed:`, error);
-      if (attempt === maxRetries) {
+      if (attempt === maxRetries || shouldRetry && !shouldRetry(error)) {
         throw error;
       }
-      await new Promise((resolve3) => setTimeout(resolve3, Math.pow(2, attempt) * 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, Math.pow(2, attempt) * baseDelayMs));
     }
   }
   throw lastError;
 }
 
+// ee/agentic-retrieval/pipeline/micro-call.ts
+var MICRO_CALL_MAX_OUTPUT_TOKENS = 2e3;
+function microCallProviderOptions(model) {
+  const modelId = typeof model === "string" ? model : model?.modelId;
+  return typeof modelId === "string" && /gemini/i.test(modelId) ? { litellm: { reasoningEffort: "disable" } } : void 0;
+}
+async function microCall(args) {
+  const {
+    model,
+    system,
+    prompt,
+    messages,
+    schema,
+    temperature = 0,
+    maxOutputTokens = MICRO_CALL_MAX_OUTPUT_TOKENS,
+    maxAttempts = 3,
+    retryBaseDelayMs
+  } = args;
+  return withRetry(
+    async () => {
+      const result = await generateText({
+        model,
+        temperature,
+        system,
+        prompt,
+        messages,
+        ...schema ? { output: Output.object({ schema }) } : {},
+        maxOutputTokens,
+        // withRetry owns retries. The SDK's internal retries on top of it
+        // tripled request volume per attempt while the provider was already
+        // rate-limiting.
+        maxRetries: 0,
+        providerOptions: microCallProviderOptions(model)
+      });
+      return {
+        output: schema ? result.output : void 0,
+        text: result.text
+      };
+    },
+    maxAttempts,
+    {
+      // Empty output is deterministic for identical params — retrying only
+      // added latency before the degraded path. Fail fast instead.
+      shouldRetry: (error) => !NoOutputGeneratedError.isInstance(error),
+      ...retryBaseDelayMs !== void 0 ? { baseDelayMs: retryBaseDelayMs } : {}
+    }
+  );
+}
+
 // ee/agentic-retrieval/pipeline/prefilter.ts
 import Fuse from "fuse.js";
-import { generateText, Output } from "ai";
 import { z as z4 } from "zod";
 
 // ee/agentic-retrieval/pipeline/text-utils.ts
@@ -2492,22 +2557,15 @@ async function resolveIdentifierPins({
     identifierSets.map(async (set) => {
       if (!set.contexts.length) return;
       try {
-        const { output } = await withRetry(
-          () => generateText({
-            model,
-            temperature: 0,
-            system: set.strategy === "exact" ? EXACT_EXTRACTION_PROMPT(set) : FUZZY_EXTRACTION_PROMPT(set),
-            messages: [{ role: "user", content: question }],
-            output: Output.object({
-              schema: z4.object({
-                hasMatches: z4.boolean(),
-                matches: z4.array(z4.string()).optional()
-              })
-            }),
-            maxOutputTokens: 300
-          }),
-          3
-        );
+        const { output } = await microCall({
+          model,
+          system: set.strategy === "exact" ? EXACT_EXTRACTION_PROMPT(set) : FUZZY_EXTRACTION_PROMPT(set),
+          messages: [{ role: "user", content: question }],
+          schema: z4.object({
+            hasMatches: z4.boolean(),
+            matches: z4.array(z4.string()).optional()
+          })
+        });
         if (!output?.hasMatches || !output.matches?.length) return;
         steps.push({ text: `Detected ${set.name} in the question: ${output.matches.join(", ")}` });
         await Promise.all(
@@ -2605,24 +2663,17 @@ If explicit, return the knowledge base ids. If not, return an empty array.`;
     const [docPageRaw, explicitKBRaw] = await Promise.all([
       (async () => {
         try {
-          return await withRetry(
-            () => generateText2({
-              model,
-              temperature: 0,
-              system: buildDocPagePrompt(knownIdentifiers),
-              messages: [{ role: "user", content: question }],
-              output: Output2.object({
-                schema: z5.object({
-                  hasFilenameHint: z5.boolean(),
-                  filenameHints: z5.array(z5.string()).optional(),
-                  hasPageHint: z5.boolean(),
-                  pageNumber: z5.number().int().nullable().optional()
-                })
-              }),
-              maxOutputTokens: 300
-            }),
-            3
-          );
+          return await microCall({
+            model,
+            system: buildDocPagePrompt(knownIdentifiers),
+            messages: [{ role: "user", content: question }],
+            schema: z5.object({
+              hasFilenameHint: z5.boolean(),
+              filenameHints: z5.array(z5.string()).optional(),
+              hasPageHint: z5.boolean(),
+              pageNumber: z5.number().int().nullable().optional()
+            })
+          });
         } catch (err) {
           steps.push({ text: "Doc/page detection failed \u2014 skipping filename and page hints." });
           return {
@@ -2637,23 +2688,16 @@ If explicit, return the knowledge base ids. If not, return an empty array.`;
       })(),
       (async () => {
         try {
-          return await withRetry(
-            () => generateText2({
-              model,
-              temperature: 0,
-              system: kbSystemPrompt,
-              output: Output2.object({
-                schema: z5.object({
-                  explicitlyRequestedKnowledgeBases: z5.array(
-                    z5.enum(enabledContexts.map((c) => c.id))
-                  )
-                })
-              }),
-              messages: [{ role: "user", content: question }],
-              maxOutputTokens: 200
+          return await microCall({
+            model,
+            system: kbSystemPrompt,
+            schema: z5.object({
+              explicitlyRequestedKnowledgeBases: z5.array(
+                z5.enum(enabledContexts.map((c) => c.id))
+              )
             }),
-            3
-          );
+            messages: [{ role: "user", content: question }]
+          });
         } catch (err) {
           return { output: { explicitlyRequestedKnowledgeBases: [] } };
         }
@@ -2736,22 +2780,15 @@ ${extraInstructions}
 </instructions>`;
       }
       try {
-        const { output: classified } = await withRetry(
-          () => generateText2({
-            model,
-            temperature: 0,
-            system: classifyPrompt,
-            messages: [{ role: "user", content: question }],
-            output: Output2.object({
-              schema: z5.object({
-                ruleId: z5.enum(ruleIds),
-                reason: z5.string()
-              })
-            }),
-            maxOutputTokens: 200
-          }),
-          3
-        );
+        const { output: classified } = await microCall({
+          model,
+          system: classifyPrompt,
+          messages: [{ role: "user", content: question }],
+          schema: z5.object({
+            ruleId: z5.enum(ruleIds),
+            reason: z5.string()
+          })
+        });
         const matchedRule = routingRules.find((r) => r.id === classified.ruleId);
         if (matchedRule) {
           const main = matchedRule.main.filter((id) => enabledIds.has(id));
@@ -2806,7 +2843,6 @@ ${extraInstructions}
 }
 
 // ee/agentic-retrieval/pipeline/memory.ts
-import { generateText as generateText3, Output as Output3 } from "ai";
 import { z as z6 } from "zod";
 
 // ee/agentic-retrieval/pipeline/multi-query.ts
@@ -3032,32 +3068,25 @@ async function runMemoryPhase({
     `;
     let relevantMemoryChunks = [];
     try {
-      const { output: output_relevant_memory } = await withRetry(
-        () => generateText3({
-          model,
-          temperature: 0,
-          system: CHECK_MEMORIES_FOR_RELEVANT_INFORMATION,
-          messages: [
-            {
-              role: "user",
-              content: `
+      const { output: output_relevant_memory } = await microCall({
+        model,
+        system: CHECK_MEMORIES_FOR_RELEVANT_INFORMATION,
+        messages: [
+          {
+            role: "user",
+            content: `
             <user_question>${question}</user_question>
             <relevant_keywords>${keywords.join(", ")}</relevant_keywords>
             <important_keyword>${importantKeyword}</important_keyword>
             `
-            }
-          ],
-          output: Output3.object({
-            schema: z6.object({
-              relevantChunkIds: z6.array(z6.string()).describe(
-                "The chunk_ids (UUIDs at the start of each bullet) of chunks containing information relevant to the user's question. Empty array if none are relevant."
-              )
-            })
-          }),
-          maxOutputTokens: 400
-        }),
-        3
-      );
+          }
+        ],
+        schema: z6.object({
+          relevantChunkIds: z6.array(z6.string()).describe(
+            "The chunk_ids (UUIDs at the start of each bullet) of chunks containing information relevant to the user's question. Empty array if none are relevant."
+          )
+        })
+      });
       const ids = new Set(output_relevant_memory?.relevantChunkIds ?? []);
       relevantMemoryChunks = ids.size === 0 ? [] : retrieved_memory.filter((c) => ids.has(c.chunk_id));
     } catch (e) {
@@ -3149,41 +3178,34 @@ ${glossary.map((g) => `${g.term} : ${g.meaning}`).join("\n")}` : "";
       `;
       const [overrideResult, fileResult, queryResult] = await Promise.all([
         // Override check: strict gate to decide if memory should be authoritative
-        memoryConfig.override ? withRetry(
-          () => generateText3({
-            model,
-            temperature: 0,
-            system: CHECK_MEMORY_OVERRIDE,
-            messages: [
-              {
-                role: "user",
-                content: `
+        memoryConfig.override ? microCall({
+          model,
+          system: CHECK_MEMORY_OVERRIDE,
+          messages: [
+            {
+              role: "user",
+              content: `
                   <user_question>${question}</user_question>
                   <relevant_keywords>${keywords.join(", ")}</relevant_keywords>
                   <important_keyword>${importantKeyword}</important_keyword>
                   `
-              }
-            ],
-            output: Output3.object({
-              schema: z6.object({
-                overrides: z6.boolean().describe(
-                  "True ONLY if a memory chunk directly and sufficiently answers the user's question and should be authoritative over the documents. Be strict; when unsure, false."
-                ),
-                confidence: z6.enum(["high", "medium", "low"]).describe(
-                  "Confidence that the selected memory chunk(s) fully and directly answer the question."
-                ),
-                authoritativeChunkIds: z6.array(z6.string()).describe(
-                  "The chunk_ids of the memory chunk(s) that directly answer the question. Empty if overrides is false."
-                ),
-                reason: z6.string().describe(
-                  "One short sentence: why this memory does or does not directly answer the question."
-                )
-              })
-            }),
-            maxOutputTokens: 300
-          }),
-          3
-        ).catch(() => ({
+            }
+          ],
+          schema: z6.object({
+            overrides: z6.boolean().describe(
+              "True ONLY if a memory chunk directly and sufficiently answers the user's question and should be authoritative over the documents. Be strict; when unsure, false."
+            ),
+            confidence: z6.enum(["high", "medium", "low"]).describe(
+              "Confidence that the selected memory chunk(s) fully and directly answer the question."
+            ),
+            authoritativeChunkIds: z6.array(z6.string()).describe(
+              "The chunk_ids of the memory chunk(s) that directly answer the question. Empty if overrides is false."
+            ),
+            reason: z6.string().describe(
+              "One short sentence: why this memory does or does not directly answer the question."
+            )
+          })
+        }).catch(() => ({
           output: {
             overrides: false,
             confidence: "low",
@@ -3199,44 +3221,30 @@ ${glossary.map((g) => `${g.term} : ${g.meaning}`).join("\n")}` : "";
           }
         }),
         // File prioritization: detect explicit document-pinning instructions in memory
-        memoryConfig.filePrioritization ? withRetry(
-          () => generateText3({
-            model,
-            temperature: 0,
-            system: "You are a helpful assistant that will strictly follow the user's instructions.",
-            messages: [{ role: "user", content: PROMPT_EXTRACT_PRIORITIZED_FILES }],
-            output: Output3.object({
-              schema: z6.object({
-                shouldPrioritizeFiles: z6.boolean(),
-                fileNameHints: z6.array(z6.string()).optional()
-              })
-            }),
-            maxOutputTokens: 300
-          }),
-          3
-        ).catch(() => ({
+        memoryConfig.filePrioritization ? microCall({
+          model,
+          system: "You are a helpful assistant that will strictly follow the user's instructions.",
+          messages: [{ role: "user", content: PROMPT_EXTRACT_PRIORITIZED_FILES }],
+          schema: z6.object({
+            shouldPrioritizeFiles: z6.boolean(),
+            fileNameHints: z6.array(z6.string()).optional()
+          })
+        }).catch(() => ({
           output: { shouldPrioritizeFiles: false, fileNameHints: [] }
         })) : Promise.resolve({
           output: { shouldPrioritizeFiles: false, fileNameHints: [] }
         }),
         // Query augmentation: expand keywords with synonyms/abbreviations from memory
-        memoryConfig.queryAugmentation && hasAugmentationContent ? withRetry(
-          () => generateText3({
-            model,
-            temperature: 0,
-            system: "You are a helpful assistant that will strictly follow the user's instructions.",
-            messages: [{ role: "user", content: QUERY_AUGMENTATION_PROMPT }],
-            output: Output3.object({
-              schema: z6.object({
-                updatedUserQuestion: z6.string(),
-                updatedRelevantKeywords: z6.array(z6.string()),
-                updatedImportantKeyword: z6.string()
-              })
-            }),
-            maxOutputTokens: 600
-          }),
-          3
-        ).catch(() => ({
+        memoryConfig.queryAugmentation && hasAugmentationContent ? microCall({
+          model,
+          system: "You are a helpful assistant that will strictly follow the user's instructions.",
+          messages: [{ role: "user", content: QUERY_AUGMENTATION_PROMPT }],
+          schema: z6.object({
+            updatedUserQuestion: z6.string(),
+            updatedRelevantKeywords: z6.array(z6.string()),
+            updatedImportantKeyword: z6.string()
+          })
+        }).catch(() => ({
           output: {
             updatedUserQuestion: question,
             updatedRelevantKeywords: [],
@@ -3318,7 +3326,6 @@ ${glossary.map((g) => `${g.term} : ${g.meaning}`).join("\n")}` : "";
 }
 
 // ee/agentic-retrieval/pipeline/hyde.ts
-import { generateText as generateText4 } from "ai";
 var hydeCache = /* @__PURE__ */ new Map();
 var HYDE_CACHE_MAX = 200;
 function hydeCacheKey(originalQuestion, relevantKeywords, styleHint, importantKeyword) {
@@ -3387,11 +3394,11 @@ IMPORTANT:
   prompt += `
 Question: "${originalQuestion}"
 Relevant keywords: ${relevantKeywords.join(", ")}`;
-  const { text } = await generateText4({
+  const { text } = await microCall({
     model,
     prompt,
     temperature: 0.3,
-    maxOutputTokens: 500
+    maxAttempts: 1
   });
   const passage = (text || "").trim();
   return passage.length > 0 ? passage : null;
@@ -3839,7 +3846,6 @@ function createAgenticRetrievalTool(opts) {
             const resolved = await resolveModel({
               modelId: cfg.utilityModel,
               user,
-              providers: exuluApp.get().providers,
               rbacBypass: true
             });
             utilityModel = resolved.languageModel ?? model;
@@ -4190,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 = {
@@ -4295,42 +4301,424 @@ var createNewMemoryItemTool = (agent, context) => {
             }
           }
         }
-        const newItem = {
-          name,
-          description: "Description: " + description + "\n\nSurrounding Context: " + surroundingContext,
-          information: "Information: " + information,
-          rights_mode: visibility === "private" ? "private" : "public",
-          ...extraFields
-        };
-        const { item: createdItem, job: createdJob } = await context.createItem(
-          newItem,
-          exuluConfig,
-          user?.id,
-          user?.role?.id,
-          false
-        );
-        if (createdJob) {
-          result = {
-            result: `Created a Job to create the memory item with the following ID: ${createdJob}`
-          };
-        } else if (createdItem) {
-          result = {
-            result: `Created memory item with the following ID: ${createdItem.id}`
-          };
-        } else {
-          result = {
-            result: `Failed to create memory item`
-          };
+        const newItem = {
+          name,
+          description: "Description: " + description + "\n\nSurrounding Context: " + surroundingContext,
+          information: "Information: " + information,
+          rights_mode: visibility === "private" ? "private" : "public",
+          ...extraFields
+        };
+        const { item: createdItem, job: createdJob } = await context.createItem(
+          newItem,
+          exuluConfig,
+          user?.id,
+          user?.role?.id,
+          false
+        );
+        if (createdJob) {
+          result = {
+            result: `Created a Job to create the memory item with the following ID: ${createdJob}`
+          };
+        } else if (createdItem) {
+          result = {
+            result: `Created memory item with the following ID: ${createdItem.id}`
+          };
+        } else {
+          result = {
+            result: `Failed to create memory item`
+          };
+        }
+      } catch (error) {
+        console.error("[EXULU] Error creating memory item", error);
+        result = {
+          result: `Failed to create memory item: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      return result;
+    }
+  });
+};
+
+// src/templates/tools/context-write-tools.ts
+import { z as z10 } from "zod";
+
+// src/exulu/table-names.ts
+var getTableName = (id) => sanitizeName(id) + "_items";
+var getChunksTableName = (id) => sanitizeName(id) + "_chunks";
+
+// src/utils/check-item-write-access.ts
+var checkItemWriteAccess = async (context, record, user) => {
+  if (!user) {
+    return false;
+  }
+  if (user.super_admin === true) {
+    return true;
+  }
+  if (user.type === "api" && (!user.scope_mode || user.scope_mode === "admin")) {
+    return true;
+  }
+  if (record.rights_mode === "public") {
+    return true;
+  }
+  if (record.rights_mode === "private") {
+    return record.created_by != null && String(record.created_by) === String(user.id);
+  }
+  const validRightsModes = ["users", "roles", "teams"];
+  if (!validRightsModes.includes(record.rights_mode)) {
+    return false;
+  }
+  const entity = getTableName(context.id);
+  const { db: db2 } = await postgresClient();
+  if (record.rights_mode === "users") {
+    const grant = await db2.from("rbac").where({
+      entity,
+      target_resource_id: record.id,
+      access_type: "User",
+      user_id: user.id,
+      rights: "write"
+    }).first();
+    return !!grant;
+  }
+  if (record.rights_mode === "roles") {
+    const roleId = typeof user.role === "string" ? user.role : user.role?.id;
+    if (!roleId) {
+      return false;
+    }
+    const grant = await db2.from("rbac").where({
+      entity,
+      target_resource_id: record.id,
+      access_type: "Role",
+      role_id: roleId,
+      rights: "write"
+    }).first();
+    return !!grant;
+  }
+  if (record.rights_mode === "teams") {
+    const teamId = typeof user.team === "string" ? user.team : user.team?.id;
+    if (!teamId) {
+      return false;
+    }
+    const grant = await db2.from("rbac").where({
+      entity,
+      target_resource_id: record.id,
+      access_type: "Team",
+      team_id: teamId,
+      rights: "write"
+    }).first();
+    return !!grant;
+  }
+  return false;
+};
+
+// src/templates/tools/kb-editor-config.ts
+import { z as z9 } from "zod";
+var KB_EDITOR_TOOL_ID = "knowledge_base_editor";
+var permissionsSchema = z9.object({
+  create: z9.boolean().catch(false).default(false),
+  update: z9.boolean().catch(false).default(false)
+});
+var emptyConfig = () => ({
+  enabled: false,
+  knowledgeBases: {},
+  skipApproval: false
+});
+var parseKbEditorConfig = (tools) => {
+  let entries = tools;
+  if (typeof entries === "string") {
+    try {
+      entries = JSON.parse(entries);
+    } catch {
+      return emptyConfig();
+    }
+  }
+  if (!Array.isArray(entries)) {
+    return emptyConfig();
+  }
+  const entry = entries.find((t) => t?.id === KB_EDITOR_TOOL_ID);
+  if (!entry) {
+    return emptyConfig();
+  }
+  const rawValue = (name) => {
+    const row = Array.isArray(entry.config) ? entry.config.find((c) => c?.name === name) : void 0;
+    return row?.value ?? row?.variable ?? row?.default;
+  };
+  let kbsRaw = rawValue("knowledge_bases");
+  if (typeof kbsRaw === "string" && kbsRaw) {
+    try {
+      kbsRaw = JSON.parse(kbsRaw);
+    } catch {
+      kbsRaw = {};
+    }
+  }
+  const knowledgeBases = {};
+  if (kbsRaw && typeof kbsRaw === "object" && !Array.isArray(kbsRaw)) {
+    for (const [contextId, value] of Object.entries(kbsRaw)) {
+      const parsed = permissionsSchema.safeParse(value);
+      if (parsed.success && (parsed.data.create || parsed.data.update)) {
+        knowledgeBases[contextId] = parsed.data;
+      }
+    }
+  }
+  const skipRaw = rawValue("skip_approval");
+  const skipApproval = skipRaw === true || skipRaw === "true" || skipRaw === 1;
+  return { enabled: true, knowledgeBases, skipApproval };
+};
+
+// src/templates/tools/context-write-tools.ts
+var MAX_CONTEXT_SEGMENT = 68;
+var RESERVED_INPUT_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "user",
+  "contexts",
+  "memory",
+  "req",
+  "upload",
+  "sessionID",
+  "sessionItems",
+  "providerapikey",
+  "allExuluTools",
+  "currentTools",
+  "exuluConfig",
+  "toolVariablesConfig",
+  "oauth"
+]);
+var buildWriteSchema = (context, mode) => {
+  const shape = {};
+  const contentKeys = [];
+  const addContent = (key, schema, required) => {
+    shape[key] = required && mode === "create" ? schema : schema.optional();
+    contentKeys.push(key);
+  };
+  if (mode === "update") {
+    shape["id"] = z10.string().optional().describe("The id of the item to update.");
+    shape["external_id"] = z10.string().optional().describe("The external_id of the item to update, if the id is unknown. Lookup only \u2014 it is never changed.");
+  }
+  addContent("name", z10.string().describe("The name of the item."), true);
+  addContent("description", z10.string().describe("A description of the item."), false);
+  addContent("tags", z10.array(z10.string()).describe("Tags for the item."), false);
+  if (mode === "create") {
+    addContent(
+      "external_id",
+      z10.string().describe("An optional external identifier for the item, e.g. an id from a source system."),
+      false
+    );
+  }
+  for (const field of context.fields ?? []) {
+    if (field.type === "file" || field.type === "uuid") continue;
+    if (field.calculated === true || field.editable === false) continue;
+    if (field.hidden === true) continue;
+    if (RESERVED_INPUT_KEYS.has(field.name)) continue;
+    let schema;
+    switch (field.type) {
+      case "enum":
+        schema = z10.string().describe(
+          `The ${field.name} of the item. Must be one of: ${(field.enumValues ?? []).join(", ")}`
+        );
+        break;
+      case "json":
+        schema = z10.string().describe(`The ${field.name} of the item, as a valid JSON string.`);
+        break;
+      case "markdown":
+        schema = z10.string().describe(`The ${field.name} of the item, as a valid Markdown string.`);
+        break;
+      case "date":
+        schema = z10.string().describe(`The ${field.name} of the item, as an ISO-8601 date string.`);
+        break;
+      case "number":
+        schema = z10.number().describe(`The ${field.name} of the item.`);
+        break;
+      case "boolean":
+        schema = z10.boolean().describe(`The ${field.name} of the item.`);
+        break;
+      default:
+        schema = z10.string().describe(`The ${field.name} of the item.`);
+        break;
+    }
+    addContent(field.name, schema, field.required === true);
+  }
+  return { shape, contentKeys };
+};
+var canonicalizeEnumFields = (context, params) => {
+  for (const field of context.fields ?? []) {
+    if (field.type !== "enum" || !field.enumValues?.length) continue;
+    const raw = params[field.name];
+    if (raw === void 0 || raw === null || raw === "") continue;
+    const rawStr = String(raw);
+    const canonical = field.enumValues.find((v) => v.toUpperCase() === rawStr.toUpperCase());
+    if (canonical === void 0) {
+      return `Invalid value "${rawStr}" for field "${field.name}". Allowed values: ${field.enumValues.join(", ")}.`;
+    }
+    params[field.name] = canonical;
+  }
+  return void 0;
+};
+var pickContent = (params, contentKeys) => {
+  const item = {};
+  for (const key of contentKeys) {
+    if (params[key] !== void 0) {
+      item[key] = params[key];
+    }
+  }
+  return item;
+};
+var jobNote = (job) => job ? ` Processing/embeddings queued (job: ${job}); changes become searchable when the job completes.` : "";
+var createContextWriteTools = (context, perms, skipApproval) => {
+  const tools = [];
+  const segment = sanitizeName(context.id).slice(0, MAX_CONTEXT_SEGMENT);
+  const contextLabel = context.description ? ` ${context.description}` : "";
+  if (perms.create) {
+    const { shape, contentKeys } = buildWriteSchema(context, "create");
+    tools.push(
+      new ExuluTool({
+        id: `create_${segment}_item`,
+        name: `Create ${context.name} item`,
+        category: "knowledge_base_editing",
+        description: `Create a new item in the "${context.name}" knowledge base.${contextLabel}`,
+        type: "function",
+        inputSchema: z10.object(shape),
+        config: [],
+        needsApproval: !skipApproval,
+        execute: async (params) => {
+          const { user, exuluConfig } = params;
+          if (!user?.id) {
+            return { result: "Knowledge base writes require an authenticated user." };
+          }
+          try {
+            const enumError = canonicalizeEnumFields(context, params);
+            if (enumError) {
+              return { result: enumError };
+            }
+            const item = pickContent(params, contentKeys);
+            item.created_by = String(user.id);
+            const { item: created, job } = await context.createItem(
+              item,
+              exuluConfig,
+              user?.id,
+              user?.role?.id,
+              false
+            );
+            if (!created?.id) {
+              return { result: `Failed to create item in "${context.name}".` };
+            }
+            return {
+              result: `Created item ${created.id} in knowledge base "${context.name}".${jobNote(job)}`
+            };
+          } catch (error) {
+            console.error(`[EXULU] Error creating item in context ${context.id}`, error);
+            return {
+              result: `Failed to create item in "${context.name}": ${error instanceof Error ? error.message : String(error)}`
+            };
+          }
+        }
+      })
+    );
+  }
+  if (perms.update) {
+    const { shape, contentKeys } = buildWriteSchema(context, "update");
+    const NOT_FOUND = `Item not found in "${context.name}" or you don't have write access to it.`;
+    tools.push(
+      new ExuluTool({
+        id: `update_${segment}_item`,
+        name: `Update ${context.name} item`,
+        category: "knowledge_base_editing",
+        description: `Update an existing item in the "${context.name}" knowledge base. Provide the item's id (or external_id) plus only the fields to change; omitted fields keep their values.`,
+        type: "function",
+        inputSchema: z10.object(shape),
+        config: [],
+        needsApproval: !skipApproval,
+        execute: async (params) => {
+          const { user, exuluConfig } = params;
+          if (!user?.id) {
+            return { result: "Knowledge base writes require an authenticated user." };
+          }
+          try {
+            if (!params.id && !params.external_id) {
+              return { result: "Provide the id or external_id of the item to update." };
+            }
+            const existing = await context.getItem({
+              item: { id: params.id, external_id: params.external_id }
+            });
+            if (!existing?.id) {
+              return { result: NOT_FOUND };
+            }
+            const allowed = await checkItemWriteAccess(context, existing, user);
+            if (!allowed) {
+              return { result: NOT_FOUND };
+            }
+            const enumError = canonicalizeEnumFields(context, params);
+            if (enumError) {
+              return { result: enumError };
+            }
+            const patch = pickContent(params, contentKeys);
+            if (Object.keys(patch).length === 0) {
+              return { result: "No fields to update were provided." };
+            }
+            patch.id = existing.id;
+            const { job } = await context.updateItem(patch, exuluConfig, user?.id, user?.role?.id);
+            const fresh = await context.getItem({ item: { id: existing.id } });
+            const summary = { id: existing.id };
+            for (const key of contentKeys) {
+              if (fresh?.[key] !== void 0 && fresh?.[key] !== null) {
+                summary[key] = fresh[key];
+              }
+            }
+            return {
+              result: `Updated item ${existing.id} in knowledge base "${context.name}".${jobNote(job)}
+Current item: ${JSON.stringify(summary)}`
+            };
+          } catch (error) {
+            console.error(`[EXULU] Error updating item in context ${context.id}`, error);
+            return {
+              result: `Failed to update item in "${context.name}": ${error instanceof Error ? error.message : String(error)}`
+            };
+          }
         }
-      } catch (error) {
-        console.error("[EXULU] Error creating memory item", error);
-        result = {
-          result: `Failed to create memory item: ${error instanceof Error ? error.message : String(error)}`
-        };
-      }
-      return result;
+      })
+    );
+  }
+  return tools;
+};
+var createKbEditorPickerTool = () => new ExuluTool({
+  id: KB_EDITOR_TOOL_ID,
+  name: "Knowledge base editor",
+  category: "default",
+  description: "Let this agent create or update items in selected knowledge bases during chat. Configure per knowledge base whether the agent may create and/or update items.",
+  type: "function",
+  inputSchema: z10.object({}),
+  config: [
+    {
+      name: "knowledge_bases",
+      description: "JSON record of context id to { create: boolean, update: boolean }. Contexts absent here get no write access.",
+      type: "json"
+    },
+    {
+      name: "skip_approval",
+      description: "Run knowledge base writes without asking for approval in the chat.",
+      type: "boolean",
+      default: false
+    }
+  ],
+  execute: async () => ({
+    result: "This entry is configuration-only; Exulu expands it into per-context create/update tools at runtime."
+  })
+});
+var collectKbWriteTools = (agent, contexts) => {
+  if (!agent?.tools || !contexts?.length) {
+    return [];
+  }
+  const config = parseKbEditorConfig(agent.tools);
+  if (!config.enabled) {
+    return [];
+  }
+  const tools = [];
+  for (const [contextId, perms] of Object.entries(config.knowledgeBases)) {
+    const context = contexts.find((c) => c.id === contextId);
+    if (!context) {
+      continue;
     }
-  });
+    tools.push(...createContextWriteTools(context, perms, config.skipApproval));
+  }
+  return tools;
 };
 
 // ee/invoke-skills/create-sandbox.ts
@@ -5468,8 +5856,8 @@ ${body}`
 // ee/invoke-skills/create-sandbox.ts
 import { createBashTool } from "bash-tool";
 import { tool as tool2 } from "ai";
-import { z as z9 } from "zod";
-import CryptoJS4 from "crypto-js";
+import { z as z11 } from "zod";
+import CryptoJS3 from "crypto-js";
 var getAllExuluVariables = async () => {
   const { db: db2 } = await postgresClient();
   const rows = await db2.from("variables").select("*");
@@ -5481,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.`,
@@ -5766,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;
@@ -5886,12 +6274,12 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   });
   const writeFileTool = tool2({
     description: 'Write content to a file in the sandbox. Creates parent directories if needed. Paths are always resolved against the session sandbox root \u2014 both relative paths ("skills/foo.md") and leading-slash paths ("/skills/foo.md") work and reach the same file. When the path is under the session artifact tree, the file is also uploaded to S3 and a short-lived presigned URL is returned in the tool output.',
-    inputSchema: z9.object({
-      path: z9.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: z9.string().describe("The content to write to the file")
+    inputSchema: z11.object({
+      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) {
@@ -5907,11 +6295,11 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   });
   const readFileTool = tool2({
     description: 'Read the contents of a file from the sandbox. Paths are always resolved against the session sandbox root \u2014 both relative paths ("skills/foo.md") and leading-slash paths ("/skills/foo.md") work and reach the same file. If the file does not exist, the error message is surfaced verbatim.',
-    inputSchema: z9.object({
-      path: z9.string().describe("The path of the file to read. Relative paths and leading-slash paths are both resolved against the session sandbox root.")
+    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 };
     }
@@ -5919,8 +6307,8 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   const originalBashTool = tools.bash;
   const bashTool = tool2({
     description: originalBashTool.description ?? "",
-    inputSchema: z9.object({
-      command: z9.string().describe("The bash command to execute.")
+    inputSchema: z11.object({
+      command: z11.string().describe("The bash command to execute.")
     }),
     execute: async (args, opts) => {
       const before = persistenceEnabled ? await snapshotSessionArtifacts() : null;
@@ -5933,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
             );
           }
@@ -6167,8 +6555,27 @@ var guardExtractedFileText = async (filename, text, ctx) => {
 ${notice}`;
 };
 
+// src/exulu/auth/scrub-text.ts
+var credentialScrubText = (provider, fieldLabels) => `A secure credential form for provider "${provider}"` + (fieldLabels.length ? ` (fields: ${fieldLabels.join(", ")})` : "") + ` is shown to the user in the chat UI. Never ask for these values in chat. After the user confirms saving, call the tool again.`;
+var SCRUBBED_CREDENTIAL_TEXT = "A secure credential form was shown to the user in the chat UI. Never ask for credential values in chat. After the user confirms saving, call the tool again.";
+var SCRUBBED_OAUTH_TEXT = "Authorization is required. A Connect button was shown to the user in the chat UI. Do not relay any URL in chat. After the user confirms connecting, call the tool again.";
+
+// src/templates/tools/auth-tool-model-output.ts
+var buildAuthToolModelOutput = (tool3) => ({ output }) => {
+  if (output && typeof output === "object" && output.credentialRequest) {
+    const auth = tool3.authentication;
+    const labels = auth?.authType === "user_credentials" ? auth.fields.map((f) => f.label) : [];
+    const provider = output.credentialRequest.provider ?? (auth && "provider" in auth ? auth.provider : "unknown");
+    return { type: "text", value: credentialScrubText(provider, labels) };
+  }
+  if (output && typeof output === "object" && output.oauth?.authorizationUrl) {
+    return { type: "text", value: SCRUBBED_OAUTH_TEXT };
+  }
+  return { type: "json", value: output ?? null };
+};
+
 // src/templates/tools/session-file-read-tool.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 var DEFAULT_LIMIT = 250;
 var MAX_CONTENT_CHARS = 16e3;
 var createSessionFileReadTool = ({
@@ -6220,10 +6627,10 @@ var createSessionFileReadTool = ({
     name: "read_session_file",
     needsApproval: false,
     description: "Read a line range from a file stored in this session's files \u2014 including offloaded tool outputs (tool-output-*.txt) and uploaded documents. Use offset (1-based line number) and limit to page through large files instead of reading everything at once.",
-    inputSchema: z10.object({
-      filename: z10.string().describe('Exact session file name as referenced in a truncation notice, e.g. "tool-output-web_search-a1b2c3d4.txt"'),
-      offset: z10.number().int().min(1).optional().describe("1-based first line to read (default 1)"),
-      limit: z10.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT})`)
+    inputSchema: z12.object({
+      filename: z12.string().describe('Exact session file name as referenced in a truncation notice, e.g. "tool-output-web_search-a1b2c3d4.txt"'),
+      offset: z12.number().int().min(1).optional().describe("1-based first line to read (default 1)"),
+      limit: z12.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT})`)
     }),
     type: "function",
     category: "session",
@@ -6236,7 +6643,7 @@ var createSessionFileReadTool = ({
 };
 
 // src/templates/tools/parse-document-tool.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 import { extname } from "path";
 import { parseOfficeAsync } from "officeparser";
 
@@ -6399,11 +6806,11 @@ ${text.trim()}`).join("\n");
     name: "parse_document",
     needsApproval: false,
     description: `Extract the text of an uploaded PDF or Office document from this session's files, with "--- page N ---" markers for PDFs so you can locate content by page. Free and fast (no OCR): works only on documents with a real text layer. To SEE a page or an image inside a document, use view_document_page.`,
-    inputSchema: z11.object({
-      filename: z11.string().describe('Exact session file name, e.g. "report.pdf"'),
-      pages: z11.string().optional().describe('PDF page or range to extract, e.g. "2" or "1-5" (default: all pages) (PDF only)'),
-      offset: z11.number().int().min(1).optional().describe("1-based first output line to read (default 1)"),
-      limit: z11.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT2})`)
+    inputSchema: z13.object({
+      filename: z13.string().describe('Exact session file name, e.g. "report.pdf"'),
+      pages: z13.string().optional().describe('PDF page or range to extract, e.g. "2" or "1-5" (default: all pages) (PDF only)'),
+      offset: z13.number().int().min(1).optional().describe("1-based first output line to read (default 1)"),
+      limit: z13.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT2})`)
     }),
     type: "function",
     category: "session",
@@ -6416,7 +6823,7 @@ ${text.trim()}`).join("\n");
 };
 
 // src/templates/tools/view-document-page-tool.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 import { extname as extname3 } from "path";
 
 // src/sessions/pdf-preview-cache.ts
@@ -6686,9 +7093,9 @@ var createViewDocumentPageTool = ({
     name: "view_document_page",
     needsApproval: false,
     description: "LOOK at a page of an uploaded PDF/Office document, or at an uploaded image, from this session's files. The rendered image is attached as a user message directly after this tool result so you can visually analyze photos, charts, scans, and layouts. Use parse_document first to find which page you need. Requires a vision-capable model.",
-    inputSchema: z12.object({
-      filename: z12.string().describe('Exact session file name, e.g. "report.pdf" or "screenshot.png"'),
-      page: z12.number().int().min(1).optional().describe("Page number to render (default 1; ignored for image files)")
+    inputSchema: z14.object({
+      filename: z14.string().describe('Exact session file name, e.g. "report.pdf" or "screenshot.png"'),
+      page: z14.number().int().min(1).optional().describe("Page number to render (default 1; ignored for image files)")
     }),
     type: "function",
     category: "session",
@@ -6698,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) {
@@ -6789,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;
@@ -6798,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 = [];
@@ -6863,6 +7764,11 @@ var convertExuluToolsToAiSdkTools = async (currentTools, currentSkills, approved
       currentTools.push(createNewMemoryTool);
     }
   }
+  for (const kbWriteTool of collectKbWriteTools(agent, contexts)) {
+    if (!disabled.has(kbWriteTool.id)) {
+      currentTools.push(kbWriteTool);
+    }
+  }
   console.log("[EXULU] Convert tools array to object, session items", sessionItems);
   if (sessionItems) {
     const sessionItemsRetrievalTool = await createSessionItemsRetrievalTool({
@@ -7015,6 +7921,10 @@ var convertExuluToolsToAiSdkTools = async (currentTools, currentSkills, approved
           // Vercel AI SDK uses the sanitized tool name as the key, so this matches.
           needsApproval: approvedTools?.includes("tool-" + cur.name) || !cur.needsApproval ? false : true,
           // todo make configurable
+          // Auth-wrapped tools: the model sees scrub text instead of the
+          // credentialRequest/oauth payload; the UI stream keeps the raw
+          // output (spec 2026-07-22 §1.2).
+          ...cur.authentication ? { toModelOutput: buildAuthToolModelOutput(cur) } : {},
           async *execute(inputs, options) {
             console.log(
               "[EXULU] Executing tool",
@@ -7024,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;
             }
           }
         }
@@ -7167,6 +8115,8 @@ export {
   getS3SignedUploadUrl,
   createUppyRoutes,
   sanitizeName,
+  getTableName,
+  getChunksTableName,
   LITELLM_UI_PATH,
   isLiteLLMEnabled,
   setLiteLLMPackageRoot,
@@ -7191,18 +8141,21 @@ export {
   getUserBudgetView,
   updateStatistic,
   checkLicense,
-  checkRecordAccess,
   ResolveModelError,
   resolveModel,
   exuluApp,
-  oauthRegistry,
+  authRegistry,
   encrypt,
   decrypt,
-  oauthTokenStore,
+  credentialStore,
   OAUTH_CALLBACK_PATH,
   decryptOauthState,
   exchangeCodeForTokens,
+  verifyCredentialNonce,
+  CredentialInvalidError,
   sanitizeToolName,
+  KB_EDITOR_TOOL_ID,
+  createKbEditorPickerTool,
   reportSystemDependencies,
   downloadKeyIntoSandbox,
   truncateToolOutput,
@@ -7216,9 +8169,13 @@ export {
   ContextCompactionRequiredError,
   mapStreamErrorMessage,
   guardExtractedFileText,
+  SCRUBBED_CREDENTIAL_TEXT,
+  SCRUBBED_OAUTH_TEXT,
   PreviewRenderError,
   getPdfPreviewBytes,
   imageAttachmentGuard,
+  getAuditLogger,
+  initAudit,
   hydrateVariables,
   convertExuluToolsToAiSdkTools,
   ExuluTool,