@exulu/backend 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -1221,6 +1221,18 @@ var init_sanitize_name = __esm({
   }
 });
 
+// src/exulu/table-names.ts
+var getTableName, getChunksTableName;
+var init_table_names = __esm({
+  "src/exulu/table-names.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_sanitize_name();
+    getTableName = (id) => sanitizeName(id) + "_items";
+    getChunksTableName = (id) => sanitizeName(id) + "_chunks";
+  }
+});
+
 // src/exulu/litellm/supervisor.ts
 var import_node_child_process, import_node_fs3, import_node_path2, LITELLM_UI_PATH, MAX_CRASHES, INITIAL_BACKOFF_MS, MAX_BACKOFF_MS, READY_TIMEOUT_MS, WAIT_TIMEOUT_MS, READY_POLL_INTERVAL_MS, SHUTDOWN_GRACE_MS, internal, isLiteLLMEnabled, resolveConfig, log2, pollHealth, spawnLiteLLM, supervise, _packageRoot, _clientMode, setLiteLLMPackageRoot, enableLiteLLMClientMode, startLiteLLMSupervisor, waitForLiteLLMReady, stopLiteLLM, shutdownHandlersRegistered, registerShutdownHandlers, getSupervisorState;
 var init_supervisor = __esm({
@@ -1819,8 +1831,8 @@ async function getTagDailyActivity(params) {
   }
   return await res.json().catch(() => ({}));
 }
-async function getTagSpendByWindow(windows, endDate) {
-  const windowEntries = Object.entries(windows);
+async function getTagSpendByWindow(windows2, endDate) {
+  const windowEntries = Object.entries(windows2);
   const out = {};
   for (const [tag] of windowEntries) out[tag] = 0;
   if (windowEntries.length === 0) return out;
@@ -1945,14 +1957,14 @@ function windowStartYmd(reset_at, duration) {
 async function enrichSpendFromActivity(map) {
   const names = Object.keys(map);
   if (names.length === 0) return;
-  const windows = {};
+  const windows2 = {};
   for (const name of names) {
     const ti = map[name];
-    windows[name] = windowStartYmd(ti.budget_reset_at, ti.budget_duration);
+    windows2[name] = windowStartYmd(ti.budget_reset_at, ti.budget_duration);
   }
   try {
     const spendByTag = await getTagSpendByWindow(
-      windows,
+      windows2,
       ymd(new Date(Date.now() + DAY_MS))
     );
     for (const name of names) {
@@ -2524,89 +2536,152 @@ var init_singleton = __esm({
   }
 });
 
-// src/exulu/oauth/validate.ts
-var REQUIRED_STRING_FIELDS, validateOauthConfig;
+// src/exulu/auth/validate.ts
+var OAUTH_REQUIRED_STRING_FIELDS, validateAuthConfig;
 var init_validate = __esm({
-  "src/exulu/oauth/validate.ts"() {
+  "src/exulu/auth/validate.ts"() {
     "use strict";
     init_cjs_shims();
-    REQUIRED_STRING_FIELDS = [
+    OAUTH_REQUIRED_STRING_FIELDS = [
       "authorizationUrl",
       "tokenUrl",
       "clientId",
       "clientSecret"
     ];
-    validateOauthConfig = (toolId, config) => {
-      for (const field of REQUIRED_STRING_FIELDS) {
-        if (!config[field] || typeof config[field] !== "string") {
+    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;
 var init_provider_key = __esm({
-  "src/exulu/oauth/provider-key.ts"() {
+  "src/exulu/auth/provider-key.ts"() {
     "use strict";
     init_cjs_shims();
     providerKeyFor = (toolId, config) => config.provider && config.provider.length > 0 ? config.provider : toolId;
   }
 });
 
-// src/exulu/oauth/registry.ts
-var byProvider, byTool, STABLE_STRING_FIELDS, assertCompatible, oauthRegistry;
+// src/exulu/auth/registry.ts
+var byProvider, byTool, STABLE_OAUTH_STRING_FIELDS, assertCompatible, authRegistry;
 var init_registry = __esm({
-  "src/exulu/oauth/registry.ts"() {
+  "src/exulu/auth/registry.ts"() {
     "use strict";
     init_cjs_shims();
     init_provider_key();
     byProvider = /* @__PURE__ */ new Map();
     byTool = /* @__PURE__ */ new Map();
-    STABLE_STRING_FIELDS = [
+    STABLE_OAUTH_STRING_FIELDS = [
       "authorizationUrl",
       "tokenUrl",
       "clientId",
       "clientSecret"
     ];
     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;
       }
     };
-    oauthRegistry = {
+    authRegistry = {
       register: (toolId, config) => {
         const providerKey = providerKeyFor(toolId, config);
         const existing = byProvider.get(providerKey);
@@ -2628,72 +2703,86 @@ var init_registry = __esm({
   }
 });
 
-// src/exulu/oauth/token-store.ts
-var import_crypto_js2, TABLE, encrypt, decrypt, oauthTokenStore;
-var init_token_store = __esm({
-  "src/exulu/oauth/token-store.ts"() {
+// src/exulu/auth/credential-store.ts
+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 import_crypto_js2, TABLE, encrypt, decrypt, credentialStore;
+var init_credential_store = __esm({
+  "src/exulu/auth/credential-store.ts"() {
     "use strict";
     init_cjs_shims();
     import_crypto_js2 = __toESM(require("crypto-js"), 1);
     init_client();
-    TABLE = "oauth_tokens";
+    TABLE = "user_credentials";
     encrypt = (value) => import_crypto_js2.default.AES.encrypt(value, process.env.NEXTAUTH_SECRET).toString();
     decrypt = (value) => import_crypto_js2.default.AES.decrypt(value, process.env.NEXTAUTH_SECRET).toString(import_crypto_js2.default.enc.Utf8);
-    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();
-      }
-    };
+    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 import_crypto_js3, import_node_crypto2, OAUTH_CALLBACK_PATH, STATE_TTL_MS, EXPIRY_SKEW_MS, getOauthRedirectUri, toBase64Url, fromBase64Url, encryptOauthState, decryptOauthState, buildAuthorizationUrl, tokenResponseToRecord, postTokenEndpoint, exchangeCodeForTokens, refreshAccessToken, getValidAccessToken;
 var init_flow = __esm({
-  "src/exulu/oauth/flow.ts"() {
+  "src/exulu/auth/flow.ts"() {
     "use strict";
     init_cjs_shims();
     import_crypto_js3 = __toESM(require("crypto-js"), 1);
     import_node_crypto2 = require("crypto");
-    init_token_store();
+    init_credential_store();
     init_provider_key();
     OAUTH_CALLBACK_PATH = "/oauth/callback";
     STATE_TTL_MS = 10 * 60 * 1e3;
@@ -2837,7 +2926,8 @@ var init_flow = __esm({
       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;
       }
@@ -2846,7 +2936,7 @@ var init_flow = __esm({
         return stored;
       }
       if (!stored.refreshToken) {
-        await oauthTokenStore.delete(providerKey, userId);
+        await credentialStore.delete(providerKey, userId);
         return null;
       }
       try {
@@ -2854,29 +2944,169 @@ var init_flow = __esm({
         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;
+// 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;
+}
+var init_state = __esm({
+  "src/exulu/auth/state.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_credential_store();
+  }
+});
+
+// src/exulu/auth/credentials-request.ts
+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;
+}
+var DEFAULT_TTL_SECONDS;
+var init_credentials_request = __esm({
+  "src/exulu/auth/credentials-request.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_credential_store();
+    DEFAULT_TTL_SECONDS = 15 * 60;
+  }
+});
+
+// src/exulu/auth/short-circuit.ts
+function credentialRequestResult(request3) {
+  return { credentialRequest: request3, result: null };
+}
+var init_short_circuit = __esm({
+  "src/exulu/auth/short-circuit.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/exulu/auth/errors.ts
+var CredentialInvalidError;
+var init_errors = __esm({
+  "src/exulu/auth/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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, wrapUserCredentials, wrapExecuteWithOauthInternal;
 var init_wrap_execute = __esm({
-  "src/exulu/oauth/wrap-execute.ts"() {
+  "src/exulu/auth/wrap-execute.ts"() {
     "use strict";
     init_cjs_shims();
     init_flow();
     init_provider_key();
-    wrapExecuteWithOauth = (toolId, config, execute2) => {
+    init_state();
+    init_credentials_request();
+    init_short_circuit();
+    init_credential_store();
+    init_errors();
+    wrapExecuteWithAuth = (toolId, config, execute2) => {
+      if (config.authType === "oauth") {
+        return wrapExecuteWithOauthInternal(toolId, config, execute2);
+      }
+      if (config.authType === "user_credentials") {
+        return wrapUserCredentials(toolId, config, execute2);
+      }
+      throw new Error(`ExuluTool "${toolId}": unknown authType`);
+    };
+    wrapUserCredentials = (toolId, config, execute2) => {
+      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 request3 = buildCredentialRequest(config, { baseUrl, userId: String(userId) });
+          return credentialRequestResult(request3);
+        }
+        try {
+          return await execute2({ ...inputs, credentials: values }, options);
+        } catch (e) {
+          if (e instanceof CredentialInvalidError && e.provider === config.provider) {
+            await credentialStore.delete(config.provider, userId);
+            const request3 = buildCredentialRequest(config, { baseUrl, userId: String(userId) });
+            return credentialRequestResult(request3);
+          }
+          throw e;
+        }
+      };
+    };
+    wrapExecuteWithOauthInternal = (toolId, config, execute2) => {
       return async (inputs, options) => {
         const userId = inputs?.user?.id;
         if (!userId) {
@@ -3233,6 +3463,409 @@ var init_memory_tool = __esm({
   }
 });
 
+// src/utils/check-item-write-access.ts
+var checkItemWriteAccess;
+var init_check_item_write_access = __esm({
+  "src/utils/check-item-write-access.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_client();
+    init_table_names();
+    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
+var import_zod4, KB_EDITOR_TOOL_ID, permissionsSchema, emptyConfig, parseKbEditorConfig;
+var init_kb_editor_config = __esm({
+  "src/templates/tools/kb-editor-config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod4 = require("zod");
+    KB_EDITOR_TOOL_ID = "knowledge_base_editor";
+    permissionsSchema = import_zod4.z.object({
+      create: import_zod4.z.boolean().catch(false).default(false),
+      update: import_zod4.z.boolean().catch(false).default(false)
+    });
+    emptyConfig = () => ({
+      enabled: false,
+      knowledgeBases: {},
+      skipApproval: false
+    });
+    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 import_zod5, MAX_CONTEXT_SEGMENT, RESERVED_INPUT_KEYS, buildWriteSchema, canonicalizeEnumFields, pickContent, jobNote, createContextWriteTools, createKbEditorPickerTool, collectKbWriteTools;
+var init_context_write_tools = __esm({
+  "src/templates/tools/context-write-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_tool();
+    import_zod5 = require("zod");
+    init_sanitize_name();
+    init_check_item_write_access();
+    init_kb_editor_config();
+    MAX_CONTEXT_SEGMENT = 68;
+    RESERVED_INPUT_KEYS = /* @__PURE__ */ new Set([
+      "model",
+      "user",
+      "contexts",
+      "memory",
+      "req",
+      "upload",
+      "sessionID",
+      "sessionItems",
+      "providerapikey",
+      "allExuluTools",
+      "currentTools",
+      "exuluConfig",
+      "toolVariablesConfig",
+      "oauth"
+    ]);
+    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"] = import_zod5.z.string().optional().describe("The id of the item to update.");
+        shape["external_id"] = import_zod5.z.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", import_zod5.z.string().describe("The name of the item."), true);
+      addContent("description", import_zod5.z.string().describe("A description of the item."), false);
+      addContent("tags", import_zod5.z.array(import_zod5.z.string()).describe("Tags for the item."), false);
+      if (mode === "create") {
+        addContent(
+          "external_id",
+          import_zod5.z.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 = import_zod5.z.string().describe(
+              `The ${field.name} of the item. Must be one of: ${(field.enumValues ?? []).join(", ")}`
+            );
+            break;
+          case "json":
+            schema = import_zod5.z.string().describe(`The ${field.name} of the item, as a valid JSON string.`);
+            break;
+          case "markdown":
+            schema = import_zod5.z.string().describe(`The ${field.name} of the item, as a valid Markdown string.`);
+            break;
+          case "date":
+            schema = import_zod5.z.string().describe(`The ${field.name} of the item, as an ISO-8601 date string.`);
+            break;
+          case "number":
+            schema = import_zod5.z.number().describe(`The ${field.name} of the item.`);
+            break;
+          case "boolean":
+            schema = import_zod5.z.boolean().describe(`The ${field.name} of the item.`);
+            break;
+          default:
+            schema = import_zod5.z.string().describe(`The ${field.name} of the item.`);
+            break;
+        }
+        addContent(field.name, schema, field.required === true);
+      }
+      return { shape, contentKeys };
+    };
+    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;
+    };
+    pickContent = (params, contentKeys) => {
+      const item = {};
+      for (const key of contentKeys) {
+        if (params[key] !== void 0) {
+          item[key] = params[key];
+        }
+      }
+      return item;
+    };
+    jobNote = (job) => job ? ` Processing/embeddings queued (job: ${job}); changes become searchable when the job completes.` : "";
+    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: import_zod5.z.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: import_zod5.z.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)}`
+                };
+              }
+            }
+          })
+        );
+      }
+      return tools;
+    };
+    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: import_zod5.z.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."
+      })
+    });
+    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;
+    };
+  }
+});
+
 // src/exulu/system-dependencies.ts
 async function getNpmGlobalRoot() {
   if (cachedNpmGlobalRoot !== void 0) return cachedNpmGlobalRoot;
@@ -3747,9 +4380,9 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   });
   const writeFileTool = (0, import_ai2.tool)({
     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: import_zod4.z.object({
-      path: import_zod4.z.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: import_zod4.z.string().describe("The content to write to the file")
+    inputSchema: import_zod6.z.object({
+      path: import_zod6.z.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: import_zod6.z.string().describe("The content to write to the file")
     }),
     execute: async ({ path: path2, content }) => {
       const resolvedPath = resolveSessionPath(path2, sessionDir);
@@ -3768,8 +4401,8 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   });
   const readFileTool = (0, import_ai2.tool)({
     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: import_zod4.z.object({
-      path: import_zod4.z.string().describe("The path of the file to read. Relative paths and leading-slash paths are both resolved against the session sandbox root.")
+    inputSchema: import_zod6.z.object({
+      path: import_zod6.z.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: path2 }) => {
       const resolvedPath = resolveSessionPath(path2, sessionDir);
@@ -3780,8 +4413,8 @@ Probe error: ${probe.reason ?? "(no detail)"}`
   const originalBashTool = tools.bash;
   const bashTool = (0, import_ai2.tool)({
     description: originalBashTool.description ?? "",
-    inputSchema: import_zod4.z.object({
-      command: import_zod4.z.string().describe("The bash command to execute.")
+    inputSchema: import_zod6.z.object({
+      command: import_zod6.z.string().describe("The bash command to execute.")
     }),
     execute: async (args, opts) => {
       const before = persistenceEnabled ? await snapshotSessionArtifacts() : null;
@@ -3851,7 +4484,7 @@ ${lines.join("\n")}`;
   sandboxCache.set(sessionId, { handle, installedSkills });
   return handle;
 }
-var import_sandbox_runtime, import_promises, import_node_fs5, import_node_path4, import_node_child_process3, import_node_util2, import_bash_tool, import_ai2, import_zod4, import_crypto_js4, getAllExuluVariables, execAsync2, EXEC_MAX_BUFFER, sandboxProbePromise, SANDBOX_FALLBACK_INSTRUCTIONS, degradedModeLogged, sandboxCache;
+var import_sandbox_runtime, import_promises, import_node_fs5, import_node_path4, import_node_child_process3, import_node_util2, import_bash_tool, import_ai2, import_zod6, import_crypto_js4, getAllExuluVariables, execAsync2, EXEC_MAX_BUFFER, sandboxProbePromise, SANDBOX_FALLBACK_INSTRUCTIONS, degradedModeLogged, sandboxCache;
 var init_create_sandbox = __esm({
   "ee/invoke-skills/create-sandbox.ts"() {
     "use strict";
@@ -3866,7 +4499,7 @@ var init_create_sandbox = __esm({
     init_system_dependencies();
     import_bash_tool = require("bash-tool");
     import_ai2 = require("ai");
-    import_zod4 = require("zod");
+    import_zod6 = require("zod");
     init_variable();
     import_crypto_js4 = __toESM(require("crypto-js"), 1);
     init_client();
@@ -4101,13 +4734,47 @@ ${notice}`;
   }
 });
 
+// src/exulu/auth/scrub-text.ts
+var credentialScrubText, SCRUBBED_CREDENTIAL_TEXT, SCRUBBED_OAUTH_TEXT;
+var init_scrub_text = __esm({
+  "src/exulu/auth/scrub-text.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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.`;
+    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.";
+    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;
+var init_auth_tool_model_output = __esm({
+  "src/templates/tools/auth-tool-model-output.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_scrub_text();
+    buildAuthToolModelOutput = (tool4) => ({ output }) => {
+      if (output && typeof output === "object" && output.credentialRequest) {
+        const auth = tool4.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
-var import_zod5, DEFAULT_LIMIT, MAX_CONTENT_CHARS, createSessionFileReadTool;
+var import_zod7, DEFAULT_LIMIT, MAX_CONTENT_CHARS, createSessionFileReadTool;
 var init_session_file_read_tool = __esm({
   "src/templates/tools/session-file-read-tool.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod5 = require("zod");
+    import_zod7 = require("zod");
     init_tool();
     init_uppy();
     DEFAULT_LIMIT = 250;
@@ -4161,10 +4828,10 @@ var init_session_file_read_tool = __esm({
         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: import_zod5.z.object({
-          filename: import_zod5.z.string().describe('Exact session file name as referenced in a truncation notice, e.g. "tool-output-web_search-a1b2c3d4.txt"'),
-          offset: import_zod5.z.number().int().min(1).optional().describe("1-based first line to read (default 1)"),
-          limit: import_zod5.z.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT})`)
+        inputSchema: import_zod7.z.object({
+          filename: import_zod7.z.string().describe('Exact session file name as referenced in a truncation notice, e.g. "tool-output-web_search-a1b2c3d4.txt"'),
+          offset: import_zod7.z.number().int().min(1).optional().describe("1-based first line to read (default 1)"),
+          limit: import_zod7.z.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT})`)
         }),
         type: "function",
         category: "session",
@@ -4231,12 +4898,12 @@ var init_document_render_helpers = __esm({
 });
 
 // src/templates/tools/parse-document-tool.ts
-var import_zod6, import_node_path6, import_officeparser, DEFAULT_LIMIT2, MAX_CONTENT_CHARS2, MIN_CHARS_PER_PAGE, OFFICE_EXTENSIONS, pagesPattern, createParseDocumentTool;
+var import_zod8, import_node_path6, import_officeparser, DEFAULT_LIMIT2, MAX_CONTENT_CHARS2, MIN_CHARS_PER_PAGE, OFFICE_EXTENSIONS, pagesPattern, createParseDocumentTool;
 var init_parse_document_tool = __esm({
   "src/templates/tools/parse-document-tool.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod6 = require("zod");
+    import_zod8 = require("zod");
     import_node_path6 = require("path");
     import_officeparser = require("officeparser");
     init_tool();
@@ -4355,11 +5022,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: import_zod6.z.object({
-          filename: import_zod6.z.string().describe('Exact session file name, e.g. "report.pdf"'),
-          pages: import_zod6.z.string().optional().describe('PDF page or range to extract, e.g. "2" or "1-5" (default: all pages) (PDF only)'),
-          offset: import_zod6.z.number().int().min(1).optional().describe("1-based first output line to read (default 1)"),
-          limit: import_zod6.z.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT2})`)
+        inputSchema: import_zod8.z.object({
+          filename: import_zod8.z.string().describe('Exact session file name, e.g. "report.pdf"'),
+          pages: import_zod8.z.string().optional().describe('PDF page or range to extract, e.g. "2" or "1-5" (default: all pages) (PDF only)'),
+          offset: import_zod8.z.number().int().min(1).optional().describe("1-based first output line to read (default 1)"),
+          limit: import_zod8.z.number().int().min(1).max(1e3).optional().describe(`Number of lines to read (default ${DEFAULT_LIMIT2})`)
         }),
         type: "function",
         category: "session",
@@ -4622,12 +5289,12 @@ var init_tool_image_attachments = __esm({
 });
 
 // src/templates/tools/view-document-page-tool.ts
-var import_zod7, import_node_path8, MAX_IMAGE_BYTES, SCALE_PRIMARY, SCALE_FALLBACK, IMAGE_MEDIA_TYPES, OFFICE_EXTENSIONS2, createViewDocumentPageTool;
+var import_zod9, import_node_path8, MAX_IMAGE_BYTES, SCALE_PRIMARY, SCALE_FALLBACK, IMAGE_MEDIA_TYPES, OFFICE_EXTENSIONS2, createViewDocumentPageTool;
 var init_view_document_page_tool = __esm({
   "src/templates/tools/view-document-page-tool.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod7 = require("zod");
+    import_zod9 = require("zod");
     import_node_path8 = require("path");
     init_tool();
     init_uppy();
@@ -4753,9 +5420,9 @@ var init_view_document_page_tool = __esm({
         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: import_zod7.z.object({
-          filename: import_zod7.z.string().describe('Exact session file name, e.g. "report.pdf" or "screenshot.png"'),
-          page: import_zod7.z.number().int().min(1).optional().describe("Page number to render (default 1; ignored for image files)")
+        inputSchema: import_zod9.z.object({
+          filename: import_zod9.z.string().describe('Exact session file name, e.g. "report.pdf" or "screenshot.png"'),
+          page: import_zod9.z.number().int().min(1).optional().describe("Page number to render (default 1; ignored for image files)")
         }),
         type: "function",
         category: "session",
@@ -4790,10 +5457,12 @@ var init_convert_exulu_tools_to_ai_sdk_tools = __esm({
     import_node_crypto4 = require("crypto");
     init_statistics();
     init_memory_tool();
+    init_context_write_tools();
     init_create_sandbox();
     init_uppy();
     init_truncate_tool_output();
     init_tool_output_offload();
+    init_auth_tool_model_output();
     init_session_file_read_tool();
     init_parse_document_tool();
     init_view_document_page_tool();
@@ -4961,6 +5630,11 @@ var init_convert_exulu_tools_to_ai_sdk_tools = __esm({
           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({
@@ -5113,6 +5787,10 @@ var init_convert_exulu_tools_to_ai_sdk_tools = __esm({
               // 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",
@@ -5252,13 +5930,13 @@ var init_convert_exulu_tools_to_ai_sdk_tools = __esm({
 });
 
 // src/exulu/tool.ts
-var import_ai3, import_zod8, import_node_crypto5, PUBLIC_TOOL_TYPES, ExuluTool;
+var import_ai3, import_zod10, import_node_crypto5, PUBLIC_TOOL_TYPES, ExuluTool;
 var init_tool = __esm({
   "src/exulu/tool.ts"() {
     "use strict";
     init_cjs_shims();
     import_ai3 = require("ai");
-    import_zod8 = require("zod");
+    import_zod10 = require("zod");
     init_sanitize_name();
     import_node_crypto5 = require("crypto");
     init_singleton();
@@ -5279,7 +5957,7 @@ var init_tool = __esm({
       type;
       tool;
       needsApproval;
-      oauth;
+      authentication;
       config;
       constructor({
         id,
@@ -5291,7 +5969,7 @@ var init_tool = __esm({
         execute: execute2,
         config,
         needsApproval,
-        oauth
+        authentication: authentication2
       }) {
         if (!PUBLIC_TOOL_TYPES.includes(type)) {
           throw new Error(
@@ -5300,11 +5978,11 @@ var init_tool = __esm({
             )}. 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;
@@ -5315,8 +5993,8 @@ var init_tool = __esm({
         this.type = type;
         this.tool = (0, import_ai3.tool)({
           description,
-          inputSchema: inputSchema || import_zod8.z.object({}),
-          execute: oauth ? wrapExecuteWithOauth(id, oauth, execute2) : execute2
+          inputSchema: inputSchema || import_zod10.z.object({}),
+          execute: authentication2 ? wrapExecuteWithAuth(id, authentication2, execute2) : execute2
         });
       }
       /**
@@ -5608,62 +6286,62 @@ function effectiveKbSettings(profile, ctx) {
     keywordPrefilter: preset.keywordPrefilter
   };
 }
-var import_zod9, KB_KINDS, DEFAULT_PREFILTER_CUTOFF, RRF_K, CHUNK_GROUP_MAX, kbProfileSchema, knowledgeBasesSchema, routingRuleSchema, routingSchema, identifierSetSchema, vocabularySchema, memorySchema, tuningSchema, boolVal, strVal, KIND_PRESETS;
+var import_zod11, KB_KINDS, DEFAULT_PREFILTER_CUTOFF, RRF_K, CHUNK_GROUP_MAX, kbProfileSchema, knowledgeBasesSchema, routingRuleSchema, routingSchema, identifierSetSchema, vocabularySchema, memorySchema, tuningSchema, boolVal, strVal, KIND_PRESETS;
 var init_config = __esm({
   "ee/agentic-retrieval/pipeline/config.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod9 = require("zod");
+    import_zod11 = require("zod");
     KB_KINDS = ["documents", "conversations", "records"];
     DEFAULT_PREFILTER_CUTOFF = 2.5;
     RRF_K = 60;
     CHUNK_GROUP_MAX = 10;
-    kbProfileSchema = import_zod9.z.object({
-      enabled: import_zod9.z.boolean().default(true),
-      kind: import_zod9.z.enum(KB_KINDS).default("documents"),
-      instructions: import_zod9.z.string().default(""),
-      overrides: import_zod9.z.object({
-        limit: import_zod9.z.number().int().positive().optional(),
-        expand: import_zod9.z.number().int().min(0).optional(),
-        multiQuery: import_zod9.z.boolean().optional(),
-        hyde: import_zod9.z.boolean().optional()
+    kbProfileSchema = import_zod11.z.object({
+      enabled: import_zod11.z.boolean().default(true),
+      kind: import_zod11.z.enum(KB_KINDS).default("documents"),
+      instructions: import_zod11.z.string().default(""),
+      overrides: import_zod11.z.object({
+        limit: import_zod11.z.number().int().positive().optional(),
+        expand: import_zod11.z.number().int().min(0).optional(),
+        multiQuery: import_zod11.z.boolean().optional(),
+        hyde: import_zod11.z.boolean().optional()
       }).default({})
     });
-    knowledgeBasesSchema = import_zod9.z.record(import_zod9.z.string(), kbProfileSchema);
-    routingRuleSchema = import_zod9.z.object({
-      id: import_zod9.z.string(),
-      label: import_zod9.z.string(),
-      description: import_zod9.z.string(),
-      main: import_zod9.z.array(import_zod9.z.string()),
-      fallback: import_zod9.z.array(import_zod9.z.string()).default([])
+    knowledgeBasesSchema = import_zod11.z.record(import_zod11.z.string(), kbProfileSchema);
+    routingRuleSchema = import_zod11.z.object({
+      id: import_zod11.z.string(),
+      label: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      main: import_zod11.z.array(import_zod11.z.string()),
+      fallback: import_zod11.z.array(import_zod11.z.string()).default([])
     });
-    routingSchema = import_zod9.z.object({ rules: import_zod9.z.array(routingRuleSchema).default([]) });
-    identifierSetSchema = import_zod9.z.object({
-      name: import_zod9.z.string(),
-      description: import_zod9.z.string().default(""),
-      examples: import_zod9.z.array(import_zod9.z.string()).default([]),
-      strategy: import_zod9.z.enum(["fuzzy", "exact"]),
-      contexts: import_zod9.z.array(import_zod9.z.string()).default([])
+    routingSchema = import_zod11.z.object({ rules: import_zod11.z.array(routingRuleSchema).default([]) });
+    identifierSetSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string().default(""),
+      examples: import_zod11.z.array(import_zod11.z.string()).default([]),
+      strategy: import_zod11.z.enum(["fuzzy", "exact"]),
+      contexts: import_zod11.z.array(import_zod11.z.string()).default([])
     });
-    vocabularySchema = import_zod9.z.object({
-      glossary: import_zod9.z.array(import_zod9.z.object({ term: import_zod9.z.string(), meaning: import_zod9.z.string() })).default([]),
-      identifiers: import_zod9.z.array(identifierSetSchema).default([]),
-      rewrites: import_zod9.z.array(import_zod9.z.object({ find: import_zod9.z.string(), replace: import_zod9.z.string() })).default([]),
-      styleHint: import_zod9.z.string().default("")
+    vocabularySchema = import_zod11.z.object({
+      glossary: import_zod11.z.array(import_zod11.z.object({ term: import_zod11.z.string(), meaning: import_zod11.z.string() })).default([]),
+      identifiers: import_zod11.z.array(identifierSetSchema).default([]),
+      rewrites: import_zod11.z.array(import_zod11.z.object({ find: import_zod11.z.string(), replace: import_zod11.z.string() })).default([]),
+      styleHint: import_zod11.z.string().default("")
     });
-    memorySchema = import_zod9.z.object({
-      enabled: import_zod9.z.boolean().default(true),
-      override: import_zod9.z.boolean().default(false),
-      filePrioritization: import_zod9.z.boolean().default(false),
-      queryAugmentation: import_zod9.z.boolean().default(true)
+    memorySchema = import_zod11.z.object({
+      enabled: import_zod11.z.boolean().default(true),
+      override: import_zod11.z.boolean().default(false),
+      filePrioritization: import_zod11.z.boolean().default(false),
+      queryAugmentation: import_zod11.z.boolean().default(true)
     });
-    tuningSchema = import_zod9.z.object({
-      topK: import_zod9.z.number().int().positive().default(5),
-      fallbackThreshold: import_zod9.z.number().min(0).max(1).default(0.95),
-      pinBoost: import_zod9.z.number().min(0).max(1).default(0.15),
-      identifierBoost: import_zod9.z.number().min(0).max(1).default(0.15),
-      pageWindow: import_zod9.z.number().int().min(0).default(1),
-      maxQueriesPerContext: import_zod9.z.number().int().positive().default(5)
+    tuningSchema = import_zod11.z.object({
+      topK: import_zod11.z.number().int().positive().default(5),
+      fallbackThreshold: import_zod11.z.number().min(0).max(1).default(0.95),
+      pinBoost: import_zod11.z.number().min(0).max(1).default(0.15),
+      identifierBoost: import_zod11.z.number().min(0).max(1).default(0.15),
+      pageWindow: import_zod11.z.number().int().min(0).default(1),
+      maxQueriesPerContext: import_zod11.z.number().int().positive().default(5)
     });
     boolVal = (v) => v === true || v === "true" || v === 1;
     strVal = (v, fallback) => typeof v === "string" && v.length > 0 ? v : fallback;
@@ -5676,7 +6354,8 @@ var init_config = __esm({
 });
 
 // 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 {
@@ -5684,10 +6363,10 @@ 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((resolve8) => setTimeout(resolve8, Math.pow(2, attempt) * 1e3));
+      await new Promise((resolve8) => setTimeout(resolve8, Math.pow(2, attempt) * baseDelayMs));
     }
   }
   throw lastError;
@@ -5699,6 +6378,64 @@ var init_with_retry = __esm({
   }
 });
 
+// ee/agentic-retrieval/pipeline/micro-call.ts
+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 (0, import_ai4.generateText)({
+        model,
+        temperature,
+        system,
+        prompt,
+        messages,
+        ...schema ? { output: import_ai4.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) => !import_ai4.NoOutputGeneratedError.isInstance(error),
+      ...retryBaseDelayMs !== void 0 ? { baseDelayMs: retryBaseDelayMs } : {}
+    }
+  );
+}
+var import_ai4, MICRO_CALL_MAX_OUTPUT_TOKENS;
+var init_micro_call = __esm({
+  "ee/agentic-retrieval/pipeline/micro-call.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ai4 = require("ai");
+    init_with_retry();
+    MICRO_CALL_MAX_OUTPUT_TOKENS = 2e3;
+  }
+});
+
 // ee/agentic-retrieval/pipeline/text-utils.ts
 function extractIdentifierTokens(parts) {
   const tokens = /* @__PURE__ */ new Set();
@@ -5903,22 +6640,15 @@ async function resolveIdentifierPins({
     identifierSets.map(async (set) => {
       if (!set.contexts.length) return;
       try {
-        const { output } = await withRetry(
-          () => (0, import_ai4.generateText)({
-            model,
-            temperature: 0,
-            system: set.strategy === "exact" ? EXACT_EXTRACTION_PROMPT(set) : FUZZY_EXTRACTION_PROMPT(set),
-            messages: [{ role: "user", content: question }],
-            output: import_ai4.Output.object({
-              schema: import_zod10.z.object({
-                hasMatches: import_zod10.z.boolean(),
-                matches: import_zod10.z.array(import_zod10.z.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: import_zod12.z.object({
+            hasMatches: import_zod12.z.boolean(),
+            matches: import_zod12.z.array(import_zod12.z.string()).optional()
+          })
+        });
         if (!output?.hasMatches || !output.matches?.length) return;
         steps.push({ text: `Detected ${set.name} in the question: ${output.matches.join(", ")}` });
         await Promise.all(
@@ -5960,15 +6690,14 @@ async function resolveIdentifierPins({
   );
   return { pinsByContext, exactPinsByContext, steps };
 }
-var import_fuse, import_ai4, import_zod10, itemCaches, ensureItemsCache, FUZZY_EXTRACTION_PROMPT, EXACT_EXTRACTION_PROMPT;
+var import_fuse, import_zod12, itemCaches, ensureItemsCache, FUZZY_EXTRACTION_PROMPT, EXACT_EXTRACTION_PROMPT;
 var init_prefilter = __esm({
   "ee/agentic-retrieval/pipeline/prefilter.ts"() {
     "use strict";
     init_cjs_shims();
     import_fuse = __toESM(require("fuse.js"), 1);
-    import_ai4 = require("ai");
-    import_zod10 = require("zod");
-    init_with_retry();
+    import_zod12 = require("zod");
+    init_micro_call();
     init_text_utils();
     init_config();
     itemCaches = {};
@@ -6045,24 +6774,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(
-            () => (0, import_ai5.generateText)({
-              model,
-              temperature: 0,
-              system: buildDocPagePrompt(knownIdentifiers),
-              messages: [{ role: "user", content: question }],
-              output: import_ai5.Output.object({
-                schema: import_zod11.z.object({
-                  hasFilenameHint: import_zod11.z.boolean(),
-                  filenameHints: import_zod11.z.array(import_zod11.z.string()).optional(),
-                  hasPageHint: import_zod11.z.boolean(),
-                  pageNumber: import_zod11.z.number().int().nullable().optional()
-                })
-              }),
-              maxOutputTokens: 300
-            }),
-            3
-          );
+          return await microCall({
+            model,
+            system: buildDocPagePrompt(knownIdentifiers),
+            messages: [{ role: "user", content: question }],
+            schema: import_zod13.z.object({
+              hasFilenameHint: import_zod13.z.boolean(),
+              filenameHints: import_zod13.z.array(import_zod13.z.string()).optional(),
+              hasPageHint: import_zod13.z.boolean(),
+              pageNumber: import_zod13.z.number().int().nullable().optional()
+            })
+          });
         } catch (err) {
           steps.push({ text: "Doc/page detection failed \u2014 skipping filename and page hints." });
           return {
@@ -6077,23 +6799,16 @@ If explicit, return the knowledge base ids. If not, return an empty array.`;
       })(),
       (async () => {
         try {
-          return await withRetry(
-            () => (0, import_ai5.generateText)({
-              model,
-              temperature: 0,
-              system: kbSystemPrompt,
-              output: import_ai5.Output.object({
-                schema: import_zod11.z.object({
-                  explicitlyRequestedKnowledgeBases: import_zod11.z.array(
-                    import_zod11.z.enum(enabledContexts.map((c) => c.id))
-                  )
-                })
-              }),
-              messages: [{ role: "user", content: question }],
-              maxOutputTokens: 200
+          return await microCall({
+            model,
+            system: kbSystemPrompt,
+            schema: import_zod13.z.object({
+              explicitlyRequestedKnowledgeBases: import_zod13.z.array(
+                import_zod13.z.enum(enabledContexts.map((c) => c.id))
+              )
             }),
-            3
-          );
+            messages: [{ role: "user", content: question }]
+          });
         } catch (err) {
           return { output: { explicitlyRequestedKnowledgeBases: [] } };
         }
@@ -6176,22 +6891,15 @@ ${extraInstructions}
 </instructions>`;
       }
       try {
-        const { output: classified } = await withRetry(
-          () => (0, import_ai5.generateText)({
-            model,
-            temperature: 0,
-            system: classifyPrompt,
-            messages: [{ role: "user", content: question }],
-            output: import_ai5.Output.object({
-              schema: import_zod11.z.object({
-                ruleId: import_zod11.z.enum(ruleIds),
-                reason: import_zod11.z.string()
-              })
-            }),
-            maxOutputTokens: 200
-          }),
-          3
-        );
+        const { output: classified } = await microCall({
+          model,
+          system: classifyPrompt,
+          messages: [{ role: "user", content: question }],
+          schema: import_zod13.z.object({
+            ruleId: import_zod13.z.enum(ruleIds),
+            reason: import_zod13.z.string()
+          })
+        });
         const matchedRule = routingRules.find((r) => r.id === classified.ruleId);
         if (matchedRule) {
           const main = matchedRule.main.filter((id) => enabledIds.has(id));
@@ -6244,14 +6952,13 @@ ${extraInstructions}
     };
   }
 }
-var import_ai5, import_zod11, MAX_USER_PIN_MATCHES, buildDocPagePrompt;
+var import_zod13, MAX_USER_PIN_MATCHES, buildDocPagePrompt;
 var init_routing = __esm({
   "ee/agentic-retrieval/pipeline/routing.ts"() {
     "use strict";
     init_cjs_shims();
-    import_ai5 = require("ai");
-    import_zod11 = require("zod");
-    init_with_retry();
+    import_zod13 = require("zod");
+    init_micro_call();
     init_prefilter();
     init_text_utils();
     MAX_USER_PIN_MATCHES = 8;
@@ -6506,32 +7213,25 @@ async function runMemoryPhase({
     `;
     let relevantMemoryChunks = [];
     try {
-      const { output: output_relevant_memory } = await withRetry(
-        () => (0, import_ai6.generateText)({
-          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: import_ai6.Output.object({
-            schema: import_zod12.z.object({
-              relevantChunkIds: import_zod12.z.array(import_zod12.z.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: import_zod14.z.object({
+          relevantChunkIds: import_zod14.z.array(import_zod14.z.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) {
@@ -6623,41 +7323,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(
-          () => (0, import_ai6.generateText)({
-            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: import_ai6.Output.object({
-              schema: import_zod12.z.object({
-                overrides: import_zod12.z.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: import_zod12.z.enum(["high", "medium", "low"]).describe(
-                  "Confidence that the selected memory chunk(s) fully and directly answer the question."
-                ),
-                authoritativeChunkIds: import_zod12.z.array(import_zod12.z.string()).describe(
-                  "The chunk_ids of the memory chunk(s) that directly answer the question. Empty if overrides is false."
-                ),
-                reason: import_zod12.z.string().describe(
-                  "One short sentence: why this memory does or does not directly answer the question."
-                )
-              })
-            }),
-            maxOutputTokens: 300
-          }),
-          3
-        ).catch(() => ({
+            }
+          ],
+          schema: import_zod14.z.object({
+            overrides: import_zod14.z.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: import_zod14.z.enum(["high", "medium", "low"]).describe(
+              "Confidence that the selected memory chunk(s) fully and directly answer the question."
+            ),
+            authoritativeChunkIds: import_zod14.z.array(import_zod14.z.string()).describe(
+              "The chunk_ids of the memory chunk(s) that directly answer the question. Empty if overrides is false."
+            ),
+            reason: import_zod14.z.string().describe(
+              "One short sentence: why this memory does or does not directly answer the question."
+            )
+          })
+        }).catch(() => ({
           output: {
             overrides: false,
             confidence: "low",
@@ -6673,44 +7366,30 @@ ${glossary.map((g) => `${g.term} : ${g.meaning}`).join("\n")}` : "";
           }
         }),
         // File prioritization: detect explicit document-pinning instructions in memory
-        memoryConfig.filePrioritization ? withRetry(
-          () => (0, import_ai6.generateText)({
-            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: import_ai6.Output.object({
-              schema: import_zod12.z.object({
-                shouldPrioritizeFiles: import_zod12.z.boolean(),
-                fileNameHints: import_zod12.z.array(import_zod12.z.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: import_zod14.z.object({
+            shouldPrioritizeFiles: import_zod14.z.boolean(),
+            fileNameHints: import_zod14.z.array(import_zod14.z.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(
-          () => (0, import_ai6.generateText)({
-            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: import_ai6.Output.object({
-              schema: import_zod12.z.object({
-                updatedUserQuestion: import_zod12.z.string(),
-                updatedRelevantKeywords: import_zod12.z.array(import_zod12.z.string()),
-                updatedImportantKeyword: import_zod12.z.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: import_zod14.z.object({
+            updatedUserQuestion: import_zod14.z.string(),
+            updatedRelevantKeywords: import_zod14.z.array(import_zod14.z.string()),
+            updatedImportantKeyword: import_zod14.z.string()
+          })
+        }).catch(() => ({
           output: {
             updatedUserQuestion: question,
             updatedRelevantKeywords: [],
@@ -6790,14 +7469,13 @@ ${glossary.map((g) => `${g.term} : ${g.meaning}`).join("\n")}` : "";
     return neutralResult(question, keywords, importantKeyword);
   }
 }
-var import_ai6, import_zod12, MEMORY_OVERRIDE_MIN_CONFIDENCE, MEMORY_SYNTHETIC_RERANK_SCORE, ITEM_CACHE_TTL_MS, memoryItemCache;
+var import_zod14, MEMORY_OVERRIDE_MIN_CONFIDENCE, MEMORY_SYNTHETIC_RERANK_SCORE, ITEM_CACHE_TTL_MS, memoryItemCache;
 var init_memory = __esm({
   "ee/agentic-retrieval/pipeline/memory.ts"() {
     "use strict";
     init_cjs_shims();
-    import_ai6 = require("ai");
-    import_zod12 = require("zod");
-    init_with_retry();
+    import_zod14 = require("zod");
+    init_micro_call();
     init_multi_query();
     init_prefilter();
     init_text_utils();
@@ -6875,21 +7553,21 @@ IMPORTANT:
   prompt += `
 Question: "${originalQuestion}"
 Relevant keywords: ${relevantKeywords.join(", ")}`;
-  const { text } = await (0, import_ai7.generateText)({
+  const { text } = await microCall({
     model,
     prompt,
     temperature: 0.3,
-    maxOutputTokens: 500
+    maxAttempts: 1
   });
   const passage = (text || "").trim();
   return passage.length > 0 ? passage : null;
 }
-var import_ai7, hydeCache, HYDE_CACHE_MAX;
+var hydeCache, HYDE_CACHE_MAX;
 var init_hyde = __esm({
   "ee/agentic-retrieval/pipeline/hyde.ts"() {
     "use strict";
     init_cjs_shims();
-    import_ai7 = require("ai");
+    init_micro_call();
     init_text_utils();
     hydeCache = /* @__PURE__ */ new Map();
     HYDE_CACHE_MAX = 200;
@@ -7292,11 +7970,11 @@ function createAgenticRetrievalTool(opts) {
         default: '{"topK":5,"fallbackThreshold":0.95,"pinBoost":0.15,"identifierBoost":0.15,"pageWindow":1,"maxQueriesPerContext":5}'
       }
     ],
-    inputSchema: import_zod13.z.object({
-      userQuery: import_zod13.z.string().describe("The original unaltered question from the user"),
-      relevantKeywords: import_zod13.z.array(import_zod13.z.string()).describe("Keywords extracted from the user's question relevant to the search"),
-      importantKeyword: import_zod13.z.string().describe("The single most important keyword from the user's question"),
-      confirmedContextIds: import_zod13.z.array(import_zod13.z.string()).optional().describe(
+    inputSchema: import_zod15.z.object({
+      userQuery: import_zod15.z.string().describe("The original unaltered question from the user"),
+      relevantKeywords: import_zod15.z.array(import_zod15.z.string()).describe("Keywords extracted from the user's question relevant to the search"),
+      importantKeyword: import_zod15.z.string().describe("The single most important keyword from the user's question"),
+      confirmedContextIds: import_zod15.z.array(import_zod15.z.string()).optional().describe(
         "Knowledge base IDs explicitly confirmed by the user to be used in the retrieval. When present, only searches these contexts."
       )
     }),
@@ -7687,12 +8365,12 @@ Verified answer:
     }
   });
 }
-var import_zod13;
+var import_zod15;
 var init_pipeline = __esm({
   "ee/agentic-retrieval/pipeline/index.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod13 = require("zod");
+    import_zod15 = require("zod");
     init_tool();
     init_entitlements();
     init_resolve_reranker();
@@ -7713,6 +8391,7 @@ var init_pipeline = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CredentialInvalidError: () => CredentialInvalidError,
   EXULU_JOB_STATUS_ENUM: () => JOB_STATUS_ENUM,
   EXULU_STATISTICS_TYPE_ENUM: () => STATISTICS_TYPE_ENUM,
   ExuluApp: () => ExuluApp,
@@ -7797,9 +8476,9 @@ async function guardRedisStartup(label, run, source) {
     );
   }, WATCHDOG_INTERVAL_MS);
   watchdog.unref?.();
-  let timer2;
+  let timer3;
   const timeout = new Promise((_resolve, reject) => {
-    timer2 = setTimeout(() => {
+    timer3 = setTimeout(() => {
       reject(
         new Error(
           `[EXULU-REDIS] Redis unreachable at ${addr} after ${REDIS_STARTUP_TIMEOUT_MS / 1e3}s \u2014 aborting ${label} startup. Last error: ${lastError ? describeError(lastError) : "none surfaced"}. Check REDIS_HOST/REDIS_PORT and that a Redis server is reachable at ${addr}.`
@@ -7816,7 +8495,7 @@ async function guardRedisStartup(label, run, source) {
     return result;
   } finally {
     clearInterval(watchdog);
-    if (timer2) clearTimeout(timer2);
+    if (timer3) clearTimeout(timer3);
     source?.off?.("error", onError);
   }
 }
@@ -7873,7 +8552,13 @@ var requestValidators = {
     const { db: db2 } = await postgresClient();
     let authtoken = null;
     if (!apikey) {
-      authtoken = await getToken((req.headers["authorization"] || req.headers["x-api-key"]) ?? "");
+      try {
+        authtoken = await getToken(
+          (req.headers["authorization"] || req.headers["x-api-key"]) ?? ""
+        );
+      } catch {
+        authtoken = null;
+      }
     }
     return await authentication({
       authtoken,
@@ -8202,14 +8887,7 @@ var ExuluStorage = class {
 
 // src/exulu/context.ts
 init_sanitize_name();
-
-// src/exulu/table-names.ts
-init_cjs_shims();
-init_sanitize_name();
-var getTableName = (id) => sanitizeName(id) + "_items";
-var getChunksTableName = (id) => sanitizeName(id) + "_chunks";
-
-// src/exulu/context.ts
+init_table_names();
 var import_knex5 = __toESM(require("pgvector/knex"), 1);
 
 // src/exulu/chunker.ts
@@ -9097,9 +9775,33 @@ function preprocessQuery(query, options = {}) {
 
 // src/graphql/resolvers/apply-sorting.ts
 init_cjs_shims();
-var applySorting = (query, sort, field_prefix) => {
+
+// src/graphql/resolvers/field-allow-list.ts
+init_cjs_shims();
+var ALWAYS_ALLOWED = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+function groupableFields(table) {
+  const allowed = new Set(ALWAYS_ALLOWED);
+  for (const field of table.fields) {
+    if (field.hidden !== true) {
+      allowed.add(field.name);
+    }
+  }
+  return allowed;
+}
+function assertAllowedField(table, fieldName, label) {
+  const allowed = groupableFields(table);
+  if (!allowed.has(fieldName)) {
+    throw new Error(`Cannot ${label} by "${fieldName}".`);
+  }
+}
+
+// src/graphql/resolvers/apply-sorting.ts
+var applySorting = (query, sort, field_prefix, table) => {
   const prefix = field_prefix ? field_prefix + "." : "";
   if (sort) {
+    if (table) {
+      assertAllowedField(table, sort.field, "sort");
+    }
     sort.field = prefix + sort.field;
     query = query.orderBy(sort.field, sort.direction.toLowerCase());
   }
@@ -10050,6 +10752,31 @@ var agentsSchema = {
       // (DEFAULT_MAX_STEPS in resolve-max-steps.ts). Auto-ALTERed on boot.
       name: "max_tool_steps",
       type: "number"
+    },
+    {
+      name: "guest_access",
+      type: "boolean",
+      default: false
+    },
+    {
+      name: "guest_auth_mode",
+      type: "text",
+      default: "regular"
+      // 'public' | 'password' | 'regular' (= login)
+    },
+    {
+      // bcrypt hash (hashSharePassword); NEVER exposed via GraphQL/REST —
+      // see sanitizeRequestedFields + createExuluContextsTypeDefs filtering.
+      name: "guest_password_hash",
+      type: "text",
+      required: false,
+      hidden: true
+    },
+    {
+      // S3 key of the custom login-page image shown on the public auth page.
+      name: "guest_cover_image",
+      type: "text",
+      required: false
     }
   ]
 };
@@ -10166,7 +10893,8 @@ var usersSchema = {
     },
     {
       name: "temporary_token",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "type",
@@ -10192,7 +10920,8 @@ var usersSchema = {
     },
     {
       name: "apikey",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "scope_mode",
@@ -10209,11 +10938,13 @@ var usersSchema = {
     },
     {
       name: "password",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "anthropic_token",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "personal_system_prompt",
@@ -10433,29 +11164,20 @@ var imageGenerationsSchema = {
     { name: "error", type: "text", required: false }
   ]
 };
-var oauthTokensSchema = {
-  type: "oauth_tokens",
-  name: {
-    plural: "oauth_tokens",
-    singular: "oauth_token"
-  },
-  // Rows are only ever read/written by the oauth token store for the owning
-  // (provider, user_id) pair — never exposed via GraphQL — so no RBAC fields.
-  RBAC: false,
-  fields: [
-    { name: "provider", type: "text", required: false, index: true },
-    { name: "tool_id", type: "text", required: true, index: true },
-    { name: "user_id", type: "number", required: true, index: true },
-    { name: "access_token", type: "longText", required: true },
-    // AES-encrypted
-    { name: "refresh_token", type: "longText", required: false },
-    // AES-encrypted
-    { name: "token_type", type: "text", required: false },
-    { name: "scopes", type: "text", required: false },
-    { name: "expires_at", type: "date", required: false }
-    // null = non-expiring
-  ]
-};
+function userCredentialsSchema() {
+  return `
+CREATE TABLE IF NOT EXISTS user_credentials (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    provider text NOT NULL,
+    user_id text NOT NULL,
+    auth_type text NOT NULL CHECK (auth_type IN ('oauth', 'user_credentials')),
+    data text NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    UNIQUE (provider, user_id)
+);
+`;
+}
 var sharedArtifactsSchema = {
   type: "shared_artifacts",
   name: {
@@ -10469,7 +11191,7 @@ var sharedArtifactsSchema = {
     { name: "name", type: "text", index: true, unique: true, required: true },
     { name: "s3key", type: "text", required: true },
     { name: "auth_mode", type: "text", default: "regular" },
-    { name: "password_hash", type: "text", required: false },
+    { name: "password_hash", type: "text", required: false, hidden: true },
     // bcrypt; password mode only
     { name: "expires_at", type: "date", required: false },
     // null = no expiry
@@ -10567,7 +11289,6 @@ var coreSchemas = {
       entityTypeSettingsSchema: () => addCoreFields(entityTypeSettingsSchema),
       promptFavoritesSchema: () => addCoreFields(promptFavoritesSchema),
       contextPresetsSchema: () => addCoreFields(contextPresetsSchema),
-      oauthTokensSchema: () => addCoreFields(oauthTokensSchema),
       sharedArtifactsSchema: () => addCoreFields(sharedArtifactsSchema),
       transcriptionJobsSchema: () => addCoreFields(transcriptionJobsSchema),
       imageGenerationsSchema: () => addCoreFields(imageGenerationsSchema)
@@ -11435,7 +12156,7 @@ var vectorSearch = async ({
   chunksQuery = applyFilters(chunksQuery, itemFilters, table, "items");
   chunksQuery = applyFilters(chunksQuery, chunkFilters, table, "chunks");
   chunksQuery = applyAccessControl(table, chunksQuery, user, "items");
-  chunksQuery = applySorting(chunksQuery, sort, "items");
+  chunksQuery = applySorting(chunksQuery, sort, "items", table);
   if (filterEntityIds) {
     applyEntityFilter(chunksQuery, "chunks", context, filterEntityIds, entityFilter?.mode || "any");
   }
@@ -12398,9 +13119,9 @@ var ExuluContext2 = class {
       job
     };
   };
-  createItem = async (item, config, user, role, upsert, generateEmbeddingsOverwrite) => {
-    console.log("[EXULU] creating item", item, upsert);
-    if (upsert && !item.id && !item.external_id) {
+  createItem = async (item, config, user, role, upsert2, generateEmbeddingsOverwrite) => {
+    console.log("[EXULU] creating item", item, upsert2);
+    if (upsert2 && !item.id && !item.external_id) {
       throw new Error("Item id or external id is required for upsert.");
     }
     const { db: db2 } = await postgresClient();
@@ -12416,8 +13137,8 @@ var ExuluContext2 = class {
       ...item,
       tags: item.tags ? Array.isArray(item.tags) ? item.tags.join(",") : item.tags : void 0
     }).returning("id");
-    console.log("[EXULU] Upsert", upsert);
-    if (upsert) {
+    console.log("[EXULU] Upsert", upsert2);
+    if (upsert2) {
       if (item.external_id) {
         mutation.onConflict("external_id").merge();
       } else if (item.id) {
@@ -12999,6 +13720,7 @@ var queues = new ExuluQueues();
 // src/graphql/schemas/index.ts
 var import_uuid4 = require("uuid");
 init_pipeline();
+init_context_write_tools();
 
 // src/graphql/types/index.ts
 init_cjs_shims();
@@ -13040,6 +13762,8 @@ var GraphQLDate = new import_graphql.GraphQLScalarType({
 
 // src/graphql/resolvers/utils.ts
 init_cjs_shims();
+var NON_COLUMN_SELECTIONS = /* @__PURE__ */ new Set(["pageInfo", "items", "RBAC"]);
+var isSelectableColumn = (field) => !NON_COLUMN_SELECTIONS.has(field) && !field.startsWith("__");
 var getRequestedFields = (info) => {
   const selections = info.operation.selectionSet.selections[0].selectionSet.selections;
   const itemSelection = selections.find((s) => s.name.value === "item");
@@ -13052,7 +13776,7 @@ var getRequestedFields = (info) => {
         return acc;
       }, {})
     );
-    return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+    return fields.filter(isSelectableColumn);
   }
   if (itemsSelection) {
     fields = Object.keys(
@@ -13061,7 +13785,7 @@ var getRequestedFields = (info) => {
         return acc;
       }, {})
     );
-    return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+    return fields.filter(isSelectableColumn);
   }
   fields = Object.keys(
     selections.reduce((acc, field) => {
@@ -13069,7 +13793,7 @@ var getRequestedFields = (info) => {
       return acc;
     }, {})
   );
-  return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+  return fields.filter(isSelectableColumn);
 };
 var contextItemsProcessorHandler = async (context, config, items, user, role) => {
   let jobs = [];
@@ -13150,8 +13874,11 @@ init_client();
 init_singleton();
 init_supervisor();
 init_catalog();
-init_tags();
+
+// src/graphql/utilities/budget-field.ts
+init_cjs_shims();
 init_budget_service();
+init_tags();
 var BUDGET_ENTITY_SINGULARS = /* @__PURE__ */ new Set([
   "user",
   "role",
@@ -13174,22 +13901,37 @@ var BUDGET_ENTITY_TYPE_BY_SINGULAR = {
 };
 var addBudgetField = async (requestedFields, result, tableSingular, user) => {
   if (!requestedFields.includes("budget")) return result;
+  const entityType = BUDGET_ENTITY_TYPE_BY_SINGULAR[tableSingular];
   const scope = user?.role?.budget_management;
-  const canRead = !!user?.super_admin || scope === "read" || scope === "write";
-  if (!canRead || result?.id == null) {
+  const canReadAll = !!user?.super_admin || scope === "read" || scope === "write";
+  const memberView = !canReadAll && entityType === "project";
+  if (!canReadAll && !memberView || result?.id == null || !entityType) {
     result.budget = null;
     return result;
   }
-  const entityType = BUDGET_ENTITY_TYPE_BY_SINGULAR[tableSingular];
-  if (!entityType) {
+  const map = await getTagBudgetMap();
+  const tag = budgetTagFor(entityType, result.id);
+  const info = tag ? map[tag] ?? null : null;
+  if (!memberView) {
+    result.budget = info;
+    return result;
+  }
+  if (!info) {
     result.budget = null;
     return result;
   }
-  const map = await getTagBudgetMap();
-  const tag = budgetTagFor(entityType, result.id);
-  result.budget = tag ? map[tag] ?? null : null;
+  const settings = await getBudgetSettings();
+  result.budget = {
+    spend: info.spend,
+    max_budget: info.max_budget,
+    budget_duration: info.budget_duration,
+    budget_reset_at: info.budget_reset_at,
+    display: settings.user_budget_display
+  };
   return result;
 };
+
+// src/graphql/utilities/sanitize-and-hydrate-fields.ts
 var addProviderFields = async (args, requestedFields, providers, result, tools, user, contexts) => {
   let provider;
   let modelRow;
@@ -13439,6 +14181,14 @@ var finalizeRequestedFields = async ({
       if (!requestedFields.includes("provider")) {
         delete result.provider;
       }
+      if (requestedFields.includes("guest_has_password")) {
+        result.guest_has_password = !!result.guest_password_hash;
+      }
+    }
+    for (const field of table.fields) {
+      if (field.hidden === true) {
+        delete result[field.name];
+      }
     }
     if (BUDGET_ENTITY_SINGULARS.has(table.name.singular)) {
       result = await addBudgetField(requestedFields, result, table.name.singular, user);
@@ -13510,7 +14260,7 @@ var itemsPaginationRequest = async ({
   let dataQuery = db2(tableName);
   dataQuery = applyFilters(dataQuery, filters, table);
   dataQuery = applyAccessControl(table, dataQuery, user);
-  dataQuery = applySorting(dataQuery, sort);
+  dataQuery = applySorting(dataQuery, sort, void 0, table);
   if (page > 1) {
     dataQuery = dataQuery.offset((page - 1) * limit);
   }
@@ -13533,8 +14283,20 @@ var removeProviderFields = (requestedFields) => {
   return filtered;
 };
 var sanitizeRequestedFields = (table, requestedFields) => {
+  const hiddenNames = new Set(
+    table.fields.filter((f) => f.hidden === true).map((f) => f.name)
+  );
+  if (hiddenNames.size > 0) {
+    requestedFields = requestedFields.filter((f) => !hiddenNames.has(f));
+  }
   if (table.name.singular === "agent") {
     requestedFields = removeProviderFields(requestedFields);
+    if (requestedFields.includes("guest_has_password")) {
+      requestedFields = requestedFields.filter(
+        (field) => field !== "guest_has_password"
+      );
+      requestedFields.push("guest_password_hash");
+    }
   }
   if (["user", "role", "team", "project", "agent"].includes(table.name.singular)) {
     requestedFields = requestedFields.filter((field) => field !== "budget");
@@ -13632,7 +14394,7 @@ function createQueries(table, providers, tools, contexts) {
       let query = db2.from(tableNamePlural).select(sanitizedFields);
       query = applyFilters(query, filters, table);
       query = applyAccessControl(table, query, context.user);
-      query = applySorting(query, sort);
+      query = applySorting(query, sort, void 0, table);
       let result = await query.first();
       return finalizeRequestedFields({
         args,
@@ -13683,6 +14445,7 @@ function createQueries(table, providers, tools, contexts) {
       query = applyAccessControl(table, query, context.user);
       query = query.limit(limit);
       if (groupBy) {
+        assertAllowedField(table, groupBy, "group");
         query = query.select(groupBy).groupBy(groupBy);
         if (tableNamePlural === "tracking") {
           query = query.sum("total as count");
@@ -13919,7 +14682,7 @@ var encryptSensitiveFields = (input) => {
 };
 
 // src/graphql/mutations/index.ts
-var import_bcryptjs3 = __toESM(require("bcryptjs"), 1);
+var import_bcryptjs4 = __toESM(require("bcryptjs"), 1);
 init_statistics();
 
 // src/exulu/routines/run-state.ts
@@ -14207,7 +14970,77 @@ var handleRBACUpdate = async (db2, entityName, resourceId, rbacData, existingRba
   }
 };
 
+// src/graphql/utilities/agent-guest-fields.ts
+init_cjs_shims();
+
+// src/exulu/shared-artifacts.ts
+init_cjs_shims();
+var import_bcryptjs3 = __toESM(require("bcryptjs"), 1);
+var normalizeS3Key = (key, bucket) => {
+  const segments = key.split("/").filter((s, i) => !(i === 0 && s === "")).map((s) => decodeURIComponent(s));
+  if (segments[0] === bucket) segments.shift();
+  return segments.join("/");
+};
+var isHtmlKey = (key) => /\.html?$/i.test(key);
+var deriveFilename = (key) => {
+  const base = key.split("/").pop() ?? key;
+  return base.split("_EXULU_").pop() ?? base;
+};
+var slugifyShareName = (input) => deriveFilename(input).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+var isExpired = (expiresAt, now) => {
+  if (!expiresAt) return false;
+  return new Date(expiresAt).getTime() <= now.getTime();
+};
+var validateCreateInput = (input, now) => {
+  if (!input.s3key) return { ok: false, message: "s3key is required." };
+  if (!input.name) return { ok: false, message: "name is required." };
+  const mode = input.auth_mode;
+  if (mode !== "public" && mode !== "password" && mode !== "regular") {
+    return { ok: false, message: "auth_mode must be public, password, or regular." };
+  }
+  if (mode === "password" && !input.password) {
+    return { ok: false, message: "A password is required for password mode." };
+  }
+  if (input.expires_at && Number.isNaN(new Date(input.expires_at).getTime())) {
+    return { ok: false, message: "expires_at is not a valid date." };
+  }
+  if (input.expires_at && isExpired(input.expires_at, now)) {
+    return { ok: false, message: "expires_at must be in the future." };
+  }
+  return { ok: true };
+};
+var hashSharePassword = (password) => import_bcryptjs3.default.hash(password, 10);
+var verifySharePassword = (password, hash) => import_bcryptjs3.default.compare(password, hash);
+var contentHeadersFor = (key, contentType, filename) => {
+  if (isHtmlKey(key)) return { contentType: "text/html; charset=utf-8" };
+  return {
+    contentType: contentType || "application/octet-stream",
+    disposition: `attachment; filename="${filename.replace(/"/g, "")}"`
+  };
+};
+var getSharedArtifactByName = (db2, name) => db2("shared_artifacts").where({ name }).first();
+
+// src/graphql/utilities/agent-guest-fields.ts
+var VALID_GUEST_AUTH_MODES = /* @__PURE__ */ new Set(["public", "password", "regular"]);
+var applyAgentGuestFieldTransforms = async (input) => {
+  if (input.guest_auth_mode !== void 0 && !VALID_GUEST_AUTH_MODES.has(input.guest_auth_mode)) {
+    throw new Error(
+      'guest_auth_mode must be "public", "password", or "regular".'
+    );
+  }
+  delete input.guest_password_hash;
+  if (typeof input.guest_password === "string" && input.guest_password.length > 0) {
+    input.guest_password_hash = await hashSharePassword(input.guest_password);
+  }
+  delete input.guest_password;
+  if (input.guest_auth_mode !== void 0 && input.guest_auth_mode !== "password") {
+    input.guest_password_hash = null;
+  }
+  return input;
+};
+
 // src/graphql/mutations/index.ts
+var VALID_RIGHTS_MODES = ["private", "users", "roles", "teams", "public"];
 var postprocessDeletion = async ({
   table,
   requestedFields,
@@ -14401,7 +15234,9 @@ function createMutations(table, providers, contexts, tools, config) {
           entity: table.name.singular,
           target_resource_id: id,
           access_type: "Role",
-          role_id: user.role,
+          // auth.ts hydrates user.role into the full roles row when it
+          // exists; unhydrated it is still the uuid string.
+          role_id: user.role?.id ?? user.role,
           rights: "write"
         }).first();
         if (rbacRecord) {
@@ -14414,7 +15249,8 @@ function createMutations(table, providers, contexts, tools, config) {
           entity: table.name.singular,
           target_resource_id: id,
           access_type: "Team",
-          team_id: user.team,
+          // Same best-effort hydration as user.role above.
+          team_id: user.team?.id ?? user.team,
           rights: "write"
         }).first();
         if (rbacRecord) {
@@ -14444,6 +15280,9 @@ function createMutations(table, providers, contexts, tools, config) {
       if (item.rights_mode) {
         item.rights_mode = "private";
       }
+      if (tableNamePlural === "agents" && "guest_access" in item) {
+        item.guest_access = false;
+      }
       if (item.created_at) {
         item.created_at = /* @__PURE__ */ new Date();
       }
@@ -14512,9 +15351,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await import_bcryptjs3.default.hash(input.password, SALT_ROUNDS);
+        input.password = await import_bcryptjs4.default.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -14528,10 +15370,15 @@ function createMutations(table, providers, contexts, tools, config) {
           input.id = db2.fn.uuid();
         }
       }
+      if (table.RBAC && input.rights_mode != null && !VALID_RIGHTS_MODES.includes(input.rights_mode)) {
+        throw new Error(
+          `Invalid rights_mode "${input.rights_mode}" \u2014 expected one of: ${VALID_RIGHTS_MODES.join(", ")}`
+        );
+      }
       const columns = await db2(tableNamePlural).columnInfo();
       const insert = db2(tableNamePlural).insert({
         ...input,
-        ...table.RBAC ? { rights_mode: "private" } : {}
+        ...table.RBAC ? { rights_mode: input.rights_mode ?? "private" } : {}
       }).returning(Object.keys(columns));
       if (args.upsert) {
         insert.onConflict().merge();
@@ -14579,9 +15426,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await import_bcryptjs3.default.hash(input.password, SALT_ROUNDS);
+        input.password = await import_bcryptjs4.default.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -14652,9 +15502,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await import_bcryptjs3.default.hash(input.password, SALT_ROUNDS);
+        input.password = await import_bcryptjs4.default.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -15138,6 +15991,7 @@ init_cjs_shims();
 init_pipeline();
 init_check_record_access();
 init_singleton();
+init_kb_editor_config();
 var getEnabledTools = async (agent, allExuluTools, allContexts, disabledTools = [], providers, user) => {
   let enabledTools = [];
   if (agent.tools) {
@@ -15155,6 +16009,9 @@ var getEnabledTools = async (agent, allExuluTools, allContexts, disabledTools =
             model: void 0
           });
         }
+        if (id === KB_EDITOR_TOOL_ID) {
+          return null;
+        }
         if (type === "agent") {
           if (id === agent.id) {
             return null;
@@ -15195,7 +16052,7 @@ init_resolve_model();
 init_client();
 var import_api = require("@opentelemetry/api");
 var import_uuid3 = require("uuid");
-var import_ai10 = require("ai");
+var import_ai7 = require("ai");
 var import_crypto_js7 = require("crypto-js");
 init_statistics();
 init_sanitize_tool_name();
@@ -15364,11 +16221,11 @@ var autoDeclineStaleApprovals = (messages) => {
 };
 
 // src/exulu/provider.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 init_tool();
 init_resolve_model();
 init_statistics2();
-var import_ai9 = require("ai");
+var import_ai6 = require("ai");
 
 // src/utils/generate-slug.ts
 init_cjs_shims();
@@ -15390,7 +16247,7 @@ init_entitlements();
 
 // src/exulu/task-description.ts
 init_cjs_shims();
-var import_ai8 = require("ai");
+var import_ai5 = require("ai");
 init_client();
 var AGENT_VISUALIZATION_ENABLED = process.env.NEXT_PUBLIC_AGENT_VISUALIZATION === "true";
 async function setSessionCurrentTask({
@@ -15405,7 +16262,7 @@ async function setSessionCurrentTask({
   }
   const truncated = userMessage.slice(0, 500);
   console.log("[EXULU] Generating text for session current task: " + truncated);
-  const { text } = await (0, import_ai8.generateText)({
+  const { text } = await (0, import_ai5.generateText)({
     model,
     prompt: `You are a task labeler for an agent monitoring dashboard visible to all employees.
 Given the user message below, write a 4\u20138 word present-tense description of what the AI assistant is working on.
@@ -15489,6 +16346,38 @@ var isRunSessionMetadata = (metadata) => {
   return typeof parsed === "object" && parsed !== null && !!parsed.job_result_id;
 };
 
+// src/exulu/auth/sanitize-ui-messages.ts
+init_cjs_shims();
+init_scrub_text();
+var sanitizeAuthPayloadsInUiMessages = (messages) => messages.map((message) => {
+  if (message.role !== "assistant" || !Array.isArray(message.parts)) {
+    return message;
+  }
+  let changed = false;
+  const parts = message.parts.map((part) => {
+    const output = part?.output;
+    if (output && typeof output === "object" && output.credentialRequest) {
+      changed = true;
+      return { ...part, output: { result: SCRUBBED_CREDENTIAL_TEXT } };
+    }
+    if (output && typeof output === "object" && output.oauth?.authorizationUrl) {
+      changed = true;
+      return { ...part, output: { result: SCRUBBED_OAUTH_TEXT } };
+    }
+    return part;
+  });
+  return changed ? { ...message, parts } : message;
+});
+
+// src/exulu/auth/guardrail.ts
+init_cjs_shims();
+var CREDENTIAL_GUARDRAIL = `Credential safety:
+Some tools collect credentials (API keys, passwords, tokens) through a secure form shown directly to the user in the chat UI. Credentials are never entered in the conversation itself.
+- Never ask the user to type credential values into the chat.
+- If the user pastes a credential value into the chat anyway, do not repeat it, do not store it, and do not pass it to any tool. Tell them to use the secure form instead (calling the tool again shows the form if it is no longer visible).
+- After the user confirms they submitted the form, call the tool again.`;
+var credentialGuardrailBlock = (currentTools) => currentTools?.some((t) => t.authentication?.authType === "user_credentials") ? CREDENTIAL_GUARDRAIL : null;
+
 // src/exulu/provider.ts
 var ExuluProvider = class {
   // Must begin with a letter (a-z) or underscore (_). Subsequent characters in a name can be letters, digits (0-9), or
@@ -15568,9 +16457,9 @@ var ExuluProvider = class {
       name: `${agent.name}`,
       type: "agent",
       category: "agents",
-      inputSchema: import_zod14.z.object({
-        prompt: import_zod14.z.string().describe("The prompt (usually a question for the agent) to send to the agent."),
-        information: import_zod14.z.string().describe("A summary of relevant context / information from the current session")
+      inputSchema: import_zod16.z.object({
+        prompt: import_zod16.z.string().describe("The prompt (usually a question for the agent) to send to the agent."),
+        information: import_zod16.z.string().describe("A summary of relevant context / information from the current session")
       }),
       description: `This tool calls an agent named: ${agent.name}. The agent does the following: ${agent.description}.`,
       config: [],
@@ -15695,7 +16584,7 @@ var ExuluProvider = class {
       const previousMessagesContent = previousMessages.map(
         (message) => JSON.parse(message.content)
       );
-      messages = await (0, import_ai9.validateUIMessages)({
+      messages = await (0, import_ai6.validateUIMessages)({
         // append the new message to the previous messages:
         messages: [...previousMessagesContent, ...messages]
       });
@@ -15858,6 +16747,10 @@ var ExuluProvider = class {
 
 When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
     'Inform the user that the action was not performed.`;
+    const credentialGuardrail = credentialGuardrailBlock(currentTools);
+    if (credentialGuardrail) {
+      system += "\n\n" + credentialGuardrail;
+    }
     if (prompt) {
       let result = { object: null, text: "" };
       let inputTokens = 0;
@@ -15866,7 +16759,7 @@ When a tool execution is not approved by the user, do not retry it unless explic
         "[EXULU] Generating text for agent: " + this.name,
         "with prompt: " + prompt?.slice(0, 100) + "..."
       );
-      const output = await (0, import_ai9.generateText)({
+      const output = await (0, import_ai6.generateText)({
         temperature: 0,
         // TODO Make this configurable
         model,
@@ -15878,7 +16771,7 @@ When a tool execution is not approved by the user, do not retry it unless explic
         // assistant's response, no follow-up text turn is wanted (same
         // reasoning as question_ask: the UI artifact is the message).
         prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget), imageAttachmentGuard()),
-        stopWhen: [(0, import_ai9.stepCountIs)(turnBudget), (0, import_ai9.hasToolCall)("image_generation")]
+        stopWhen: [(0, import_ai6.stepCountIs)(turnBudget), (0, import_ai6.hasToolCall)("image_generation")]
       });
       console.log("[EXULU] Output: " + JSON.stringify(output, null, 2));
       const {
@@ -15929,19 +16822,23 @@ When a tool execution is not approved by the user, do not retry it unless explic
         "[EXULU] Generating text for agent: " + this.name,
         "with messages: " + messages.length
       );
-      const { text, totalUsage } = await (0, import_ai9.generateText)({
+      const { text, totalUsage } = await (0, import_ai6.generateText)({
         temperature: 0,
         // TODO Make this configurable
         model,
         // Should be a LanguageModelV1
         system,
-        messages: await (0, import_ai9.convertToModelMessages)(messages, {
-          ignoreIncompleteToolCalls: true
+        // tools: applies each tool's toModelOutput to historical tool results;
+        // sanitize: guarantees auth payloads never reach the model regardless
+        // of part encoding (spec 2026-07-22 §1.2).
+        messages: await (0, import_ai6.convertToModelMessages)(sanitizeAuthPayloadsInUiMessages(messages), {
+          ignoreIncompleteToolCalls: true,
+          tools
         }),
         maxRetries: 2,
         tools,
         prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget), imageAttachmentGuard()),
-        stopWhen: [(0, import_ai9.stepCountIs)(turnBudget), (0, import_ai9.hasToolCall)("image_generation")]
+        stopWhen: [(0, import_ai6.stepCountIs)(turnBudget), (0, import_ai6.hasToolCall)("image_generation")]
       });
       if (statistics) {
         await Promise.all([
@@ -16112,7 +17009,7 @@ ${guardedText}
       previousMessagesContent = previousMessages2.map((message2) => JSON.parse(message2.content));
     }
     const model = languageModel;
-    messages = await (0, import_ai9.validateUIMessages)({
+    messages = await (0, import_ai6.validateUIMessages)({
       // append the new message to the previous messages:
       messages: [...previousMessagesContent, message]
     });
@@ -16256,6 +17153,10 @@ ${skillsList}
 
 When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
     'Inform the user that the action was not performed.`;
+    const credentialGuardrail = credentialGuardrailBlock(currentTools);
+    if (credentialGuardrail) {
+      system += "\n\n" + credentialGuardrail;
+    }
     console.log("[EXULU] Tools", currentTools?.map((x) => x.name));
     console.log("[EXULU] Skills", currentSkills?.map((x) => x.name));
     const tools = await convertExuluToolsToAiSdkTools(
@@ -16334,13 +17235,17 @@ When a tool execution is not approved by the user, do not retry it unless explic
       Object.keys(tools)
     );
     const turnBudget = resolveTurnStepBudget(maxStepCount, agent);
-    const result = (0, import_ai9.streamText)({
+    const result = (0, import_ai6.streamText)({
       temperature: 0,
       // TODO Make this configurable
       model,
       // Should be a LanguageModelV1
-      messages: await (0, import_ai9.convertToModelMessages)(messages, {
-        ignoreIncompleteToolCalls: true
+      // tools: applies each tool's toModelOutput to historical tool results;
+      // sanitize: guarantees auth payloads never reach the model regardless
+      // of part encoding (spec 2026-07-22 §1.2).
+      messages: await (0, import_ai6.convertToModelMessages)(sanitizeAuthPayloadsInUiMessages(messages), {
+        ignoreIncompleteToolCalls: true,
+        tools
       }),
       // PrepareStep could be used here to set the model
       // for the first step or change other parameters.
@@ -16360,7 +17265,7 @@ When a tool execution is not approved by the user, do not retry it unless explic
       },
       // todo allow configuring the step budget per skill
       prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget), imageAttachmentGuard()),
-      stopWhen: [(0, import_ai9.stepCountIs)(turnBudget), (0, import_ai9.hasToolCall)("image_generation")]
+      stopWhen: [(0, import_ai6.stepCountIs)(turnBudget), (0, import_ai6.hasToolCall)("image_generation")]
     });
     return {
       stream: result,
@@ -18614,7 +19519,7 @@ var transcriptionService = {
 
 // src/exulu/recall/service.ts
 init_cjs_shims();
-var import_ai11 = require("ai");
+var import_ai8 = require("ai");
 init_singleton();
 init_client();
 init_resolve_model();
@@ -18688,10 +19593,25 @@ var RecallApiError = class extends Error {
   }
 };
 var jitterMs = () => 1e3 * Math.ceil(Math.random() * 5);
+var API_TIMEOUT_MS = 6e4;
+var DOWNLOAD_TIMEOUT_MS = 3e5;
 async function fetch_with_retry(args) {
-  const { url, options, max_attempts = 6 } = args;
+  const { url, options, max_attempts = 6, timeout_ms, retry_on_reject } = args;
   for (let attempt = 1; attempt <= max_attempts; attempt++) {
-    const response = await fetch(url, options);
+    let response;
+    try {
+      response = await fetch(
+        url,
+        timeout_ms ? { ...options, signal: AbortSignal.timeout(timeout_ms) } : options
+      );
+    } catch (err) {
+      if (!retry_on_reject || attempt === max_attempts) throw err;
+      console.log(
+        `[EXULU-RECALL] fetch error from ${url} (${err.message}); retrying in ~5s (attempt ${attempt}/${max_attempts})`
+      );
+      await new Promise((resolve8) => setTimeout(resolve8, 5e3 + jitterMs()));
+      continue;
+    }
     let wait_for = null;
     switch (response.status) {
       case 429:
@@ -18732,7 +19652,9 @@ var request2 = async (path2, init = {}) => {
         ...init.body ? { "content-type": "application/json" } : {},
         ...init.headers ?? {}
       }
-    }
+    },
+    timeout_ms: API_TIMEOUT_MS,
+    retry_on_reject: (init.method ?? "GET").toUpperCase() === "GET"
   });
   if (!response.ok) {
     const body = await response.text();
@@ -18804,7 +19726,9 @@ var recallClient = {
   downloadTranscript: async (downloadUrl) => {
     const response = await fetch_with_retry({
       url: downloadUrl,
-      options: { method: "GET" }
+      options: { method: "GET" },
+      timeout_ms: DOWNLOAD_TIMEOUT_MS,
+      retry_on_reject: true
     });
     if (!response.ok) {
       const body = await response.text();
@@ -18858,6 +19782,12 @@ var durationFromSegments = (segments) => {
 // src/exulu/recall/service.ts
 var TABLE3 = "transcription_jobs";
 var DEFAULT_BOT_NAME = "Company Notetaker";
+var RECONCILE_STALE_MS = 10 * 60 * 1e3;
+var RECONCILE_PROBE_QUIET_MS = 60 * 60 * 1e3;
+var RECONCILE_GIVE_UP_MS = 24 * 60 * 60 * 1e3;
+var POST_PROCESSING_REDO_STALE_MS = 30 * 60 * 1e3;
+var POST_PROCESSING_PROMPT_TIMEOUT_MS = 10 * 60 * 1e3;
+var BOT_ENDED_STATUSES = ["done", "call_ended"];
 var log4 = (msg) => console.log(`[EXULU-RECALL] ${msg}`);
 var parseJson = (v) => {
   if (v == null) return null;
@@ -18934,7 +19864,9 @@ var recallService = {
       target_rights_mode: input.target_rights_mode ?? "private",
       target_rbac_users: input.target_rbac_users ? JSON.stringify(input.target_rbac_users) : null,
       target_rbac_roles: input.target_rbac_roles ? JSON.stringify(input.target_rbac_roles) : null,
-      post_processing_prompts: input.post_processing_prompts ? JSON.stringify(input.post_processing_prompts) : null,
+      // Normalized to NULL when empty so the reconcile sweep's redo select
+      // ("prompts configured but never ran") can never match a no-prompt row.
+      post_processing_prompts: input.post_processing_prompts?.length ? JSON.stringify(input.post_processing_prompts) : null,
       rights_mode: "private",
       created_by: input.userId,
       createdAt: now,
@@ -19003,7 +19935,13 @@ var recallService = {
       return;
     }
     const { db: db2 } = await postgresClient();
-    const claimed = await db2(TABLE3).where({ id: jobId }).whereNotIn("status", ["transcribing", "awaiting_review", "saved", "failed"]).update({
+    const claimed = await db2(TABLE3).where({ id: jobId }).whereNotIn("status", [
+      "transcribing",
+      "awaiting_review",
+      "saved",
+      "failed",
+      "cancelled"
+    ]).update({
       recall_recording_id: recordingId,
       status: "transcribing",
       updatedAt: /* @__PURE__ */ new Date()
@@ -19095,14 +20033,55 @@ var recallService = {
       log4(`post-processing for job ${jobId} skipped: no transcript.`);
       return [];
     }
+    const claimed = await db2(TABLE3).where({ id: jobId }).whereRaw(
+      `(post_processing_outputs IS NULL OR (post_processing_outputs::text = '[]' AND "updatedAt" < ?))`,
+      [new Date(Date.now() - POST_PROCESSING_REDO_STALE_MS)]
+    ).update({ post_processing_outputs: "[]", updatedAt: /* @__PURE__ */ new Date() });
+    if (!claimed) {
+      log4(`post-processing for job ${jobId} already in flight; skipping.`);
+      return [];
+    }
     const outputs = [];
     for (const p of prompts) {
       outputs.push(await this._runOnePrompt(job, p.prompt_id, p.agent_id));
+      await this._update(jobId, {});
     }
-    await this._update(jobId, {
-      post_processing_outputs: JSON.stringify(outputs)
-    });
-    return outputs;
+    return this._mergeOutputs(jobId, outputs);
+  },
+  /**
+   * Upsert entries into post_processing_outputs without clobbering concurrent
+   * writers: optimistic-concurrency loop — read, merge by {prompt_id,
+   * agent_id}, write only while the column still matches the snapshot.
+   */
+  async _mergeOutputs(jobId, entries) {
+    const { db: db2 } = await postgresClient();
+    for (let attempt = 1; attempt <= 5; attempt++) {
+      const row = await db2(TABLE3).where({ id: jobId }).first();
+      if (!row) return entries;
+      const raw = row.post_processing_outputs ?? null;
+      const snapshot = raw == null ? null : typeof raw === "string" ? raw : JSON.stringify(raw);
+      const current = parseJson(raw) ?? [];
+      const merged = [
+        ...current.filter(
+          (o) => !entries.some(
+            (e) => e.prompt_id === o.prompt_id && e.agent_id === o.agent_id
+          )
+        ),
+        ...entries
+      ];
+      const updated = await db2(TABLE3).where({ id: jobId }).whereRaw(
+        "post_processing_outputs::jsonb IS NOT DISTINCT FROM ?::jsonb",
+        [snapshot]
+      ).update({
+        post_processing_outputs: JSON.stringify(merged),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      if (updated) return merged;
+    }
+    log4(
+      `post-processing outputs for job ${jobId} kept changing under the merge; leaving the concurrent writer's data in place.`
+    );
+    return entries;
   },
   /**
    * Manual single-prompt run (re-run from the review sheet). Upserts the matching
@@ -19113,13 +20092,14 @@ var recallService = {
     const dbRow = await db2(TABLE3).where({ id: jobId }).first();
     if (!dbRow) throw new Error(`transcription_job ${jobId} not found`);
     const job = this._row(dbRow);
+    const claimInFlight = dbRow.post_processing_outputs != null && (job.post_processing_outputs?.length ?? 0) === 0 && Date.now() - new Date(job.updatedAt).getTime() < POST_PROCESSING_REDO_STALE_MS;
+    if (claimInFlight) {
+      throw new Error(
+        "POST_PROCESSING_IN_FLIGHT: the automatic post-processing run is still in progress; its results will appear shortly."
+      );
+    }
     const result = await this._runOnePrompt(job, promptId, agentId);
-    const existing = job.post_processing_outputs ?? [];
-    const next = existing.filter(
-      (o) => !(o.prompt_id === promptId && o.agent_id === agentId)
-    );
-    next.push(result);
-    await this._update(jobId, { post_processing_outputs: JSON.stringify(next) });
+    await this._mergeOutputs(jobId, [result]);
     return result;
   },
   async _runOnePrompt(job, promptId, agentId) {
@@ -19144,7 +20124,7 @@ var recallService = {
         job.raw_segments ?? [],
         job.speakers ?? {}
       );
-      const { text } = await (0, import_ai11.generateText)({
+      const { text } = await (0, import_ai8.generateText)({
         model: resolved.languageModel,
         system: agent.instructions || void 0,
         prompt: `${prompt.content}
@@ -19153,7 +20133,8 @@ var recallService = {
 Meeting transcript:
 
 ${transcriptText}`,
-        maxRetries: 3
+        maxRetries: 3,
+        abortSignal: AbortSignal.timeout(POST_PROCESSING_PROMPT_TIMEOUT_MS)
       });
       return {
         prompt_id: promptId,
@@ -19177,6 +20158,206 @@ ${transcriptText}`,
       };
     }
   },
+  /**
+   * Reconciliation sweep: re-drive recall jobs whose webhook event was lost
+   * (ACK-first delivery + crash/restart = no redelivery). Called periodically
+   * from the reconcile loop. Returns the number of jobs it acted on.
+   *
+   * Idempotent by construction: every recovery path funnels into the same
+   * guarded transitions the webhook handlers use (_onRecordingDone's atomic
+   * claim, _onTranscriptDone's already-processed check, runPostProcessing's
+   * skip-if-outputs-exist), so a webhook racing the sweep is harmless.
+   */
+  async reconcileOnce(limit = 10) {
+    if (!recallEnabled()) return 0;
+    const { db: db2 } = await postgresClient();
+    const now = Date.now();
+    const stuck = await db2(TABLE3).where({ source: "recall" }).whereIn("status", ["queued", "transcribing"]).whereRaw(`("join_at" IS NULL OR "join_at" < ?)`, [
+      new Date(now - RECONCILE_STALE_MS)
+    ]).where("updatedAt", "<", new Date(now - RECONCILE_STALE_MS)).orderBy("updatedAt", "asc").limit(limit);
+    const redo = await db2(TABLE3).where({ source: "recall", status: "awaiting_review" }).whereNotNull("post_processing_prompts").whereRaw("post_processing_prompts::text <> '[]'").whereRaw("(raw_segments IS NOT NULL AND raw_segments::text <> '[]')").whereRaw(
+      "(post_processing_outputs IS NULL OR post_processing_outputs::text = '[]')"
+    ).where("updatedAt", "<", new Date(now - POST_PROCESSING_REDO_STALE_MS)).orderBy("updatedAt", "asc").limit(limit);
+    let acted = 0;
+    for (const dbRow of stuck) {
+      const job = this._row(dbRow);
+      try {
+        if (await this._reconcileStuckJob(job)) acted++;
+      } catch (err) {
+        if (await this._reconcileError(job, err)) acted++;
+      }
+    }
+    for (const dbRow of redo) {
+      try {
+        log4(`reconcile: re-running lost post-processing for job ${dbRow.id}`);
+        const outputs = await this.runPostProcessing(dbRow.id);
+        if (outputs.length > 0) acted++;
+      } catch (err) {
+        log4(
+          `post-processing redo failed for job ${dbRow.id}: ${err.message}`
+        );
+      }
+    }
+    return acted;
+  },
+  async _reconcileStuckJob(job) {
+    if (!job.recall_bot_id) {
+      await this._fail(job.id, "bot was never launched (lost during creation)");
+      return true;
+    }
+    if (job.status === "queued") return this._reconcileQueued(job);
+    if (job.status === "transcribing") return this._reconcileTranscribing(job);
+    return false;
+  },
+  /**
+   * A recovery step threw. 404 means the Recall object is gone — terminal.
+   * Otherwise apply the 24h give-up (API errors must not defer it forever),
+   * and touch the row so it rotates to the back of the sweep window.
+   */
+  async _reconcileError(job, err) {
+    const message = err.message ?? String(err);
+    if (err.status === 404) {
+      await this._fail(
+        job.id,
+        `Recall no longer knows this recording: ${message}`
+      );
+      return true;
+    }
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        `still stuck 24 hours after the meeting start (last error: ${message})`
+      );
+      return true;
+    }
+    log4(`reconcile failed for job ${job.id}: ${message}`);
+    await this._update(job.id, {});
+    return false;
+  },
+  /** A queued row: the recording.done event (or the whole bot lifecycle) was lost. */
+  async _reconcileQueued(job) {
+    const ended = !!job.bot_status && BOT_ENDED_STATUSES.includes(job.bot_status);
+    const quietMs = Date.now() - new Date(job.updatedAt).getTime();
+    if (!ended && quietMs < RECONCILE_PROBE_QUIET_MS) return false;
+    const bot = await recallClient.retrieveBot(job.recall_bot_id);
+    const code = bot?.status_changes?.at(-1)?.code ?? null;
+    if (code === "fatal") {
+      await this._fail(job.id, "bot fatal (recovered by reconciliation)");
+      return true;
+    }
+    const recording = bot?.recordings?.[0] ?? null;
+    if (recording?.id) {
+      const readiness = await this._recordingReadiness(recording);
+      if (readiness === "failed") {
+        await this._fail(job.id, "recording failed (found by reconciliation)");
+        return true;
+      }
+      if (readiness === "done") {
+        log4(`reconcile: driving lost recording.done for job ${job.id}`);
+        await this._onRecordingDone(job.id, recording.id);
+        return true;
+      }
+    } else if (code === "done") {
+      await this._fail(job.id, "bot finished without a recording");
+      return true;
+    }
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        "no recording within 24 hours of the meeting start"
+      );
+      return true;
+    }
+    await this._update(
+      job.id,
+      code && code !== job.bot_status ? { bot_status: code } : {}
+    );
+    return false;
+  },
+  /** Whether a recording is safe to transcribe, checking the full recording
+   *  object when the bot payload carries no status. */
+  async _recordingReadiness(recording) {
+    const codeOf = (c) => c === "done" ? "done" : c === "failed" ? "failed" : c ? "processing" : null;
+    const fromBot = codeOf(recording.status?.code);
+    if (fromBot) return fromBot;
+    if (recording.completed_at) return "done";
+    const full = await recallClient.retrieveRecording(recording.id);
+    const fromFull = codeOf(full?.status?.code);
+    if (fromFull) return fromFull;
+    return full?.completed_at || recordingDurationSeconds(full) != null ? "done" : "processing";
+  },
+  /**
+   * A transcribing row: transcript.done was lost, or the original
+   * recording.done handling crashed between the status claim and
+   * createAsyncTranscript (in which case Recall was never asked to
+   * transcribe and no transcript.* event will ever arrive).
+   */
+  async _reconcileTranscribing(job) {
+    let recordingId = job.recall_recording_id;
+    if (!recordingId && !job.recall_transcript_id) {
+      const bot = await recallClient.retrieveBot(job.recall_bot_id);
+      recordingId = bot?.recordings?.[0]?.id ?? null;
+    }
+    let transcriptId = job.recall_transcript_id;
+    if (!transcriptId) {
+      if (!recordingId) return this._transcribingNotReady(job);
+      const rec = await recallClient.retrieveRecording(recordingId);
+      const shortcut = rec?.media_shortcuts?.transcript;
+      if (shortcut?.id) {
+        transcriptId = shortcut.id;
+        await this._update(job.id, {
+          recall_recording_id: recordingId,
+          recall_transcript_id: transcriptId
+        });
+      } else {
+        const { db: db2 } = await postgresClient();
+        const claimed = await db2(TABLE3).where({ id: job.id, status: "transcribing" }).whereNull("recall_transcript_id").where("updatedAt", "<", new Date(Date.now() - RECONCILE_STALE_MS)).update({ recall_recording_id: recordingId, updatedAt: /* @__PURE__ */ new Date() });
+        if (!claimed) return false;
+        log4(
+          `reconcile: re-requesting transcript for job ${job.id} (lost before createAsyncTranscript)`
+        );
+        const transcript2 = await recallClient.createAsyncTranscript(
+          recordingId,
+          job.language || "auto"
+        );
+        await this._update(job.id, {
+          recall_transcript_id: transcript2.id ?? null
+        });
+        return true;
+      }
+    }
+    const transcript = await recallClient.retrieveTranscript(transcriptId);
+    const transcriptCode = transcript?.status?.code ?? null;
+    if (transcriptCode === "error" || transcriptCode === "failed") {
+      await this._fail(
+        job.id,
+        `transcript failed at Recall: ${transcript?.status?.sub_code || transcriptCode}`
+      );
+      return true;
+    }
+    if (transcript?.data?.download_url) {
+      log4(`reconcile: driving lost transcript.done for job ${job.id}`);
+      await this._onTranscriptDone(job.id, transcriptId, recordingId);
+      return true;
+    }
+    return this._transcribingNotReady(job);
+  },
+  /** Transcript not ready yet: wait (touch) or give up after the hard cap. */
+  async _transcribingNotReady(job) {
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        "transcript was not ready within 24 hours of the meeting start"
+      );
+      return true;
+    }
+    await this._update(job.id, {});
+    return false;
+  },
+  _pastGiveUp(job) {
+    const startedAt = new Date(job.join_at ?? job.createdAt).getTime();
+    return Number.isFinite(startedAt) && Date.now() - startedAt > RECONCILE_GIVE_UP_MS;
+  },
   async _findJob(botId, recordingId, transcriptId) {
     const { db: db2 } = await postgresClient();
     let dbRow;
@@ -19211,7 +20392,7 @@ ${transcriptText}`,
 
 // src/exulu/email-inbound/config.ts
 init_cjs_shims();
-init_token_store();
+init_credential_store();
 var EMAIL_INBOUND_CONFIG_KEY = "email_inbound";
 var parseValue = (value) => {
   if (!value) return {};
@@ -19410,7 +20591,8 @@ function createExuluContextsTypeDefs(table) {
   ${enumValues}
   }`;
   }).filter((enumDef) => enumDef !== null).join("\n");
-  let fields = table.fields.map((field) => {
+  const graphqlFields = table.fields.filter((field) => field.hidden !== true);
+  let fields = graphqlFields.map((field) => {
     let type;
     type = mapExuluFieldTypesToGraphqlTypes(field);
     const required = field.required ? "!" : "";
@@ -19431,6 +20613,7 @@ function createExuluContextsTypeDefs(table) {
     fields.push("  systemInstructions: String");
     fields.push("  workflows: AgentWorkflows");
     fields.push("  slug: String");
+    fields.push("  guest_has_password: Boolean");
   }
   if (table.name.singular === "workflow_template") {
     fields.push("  variables: [String]");
@@ -19447,16 +20630,20 @@ function createExuluContextsTypeDefs(table) {
     }
     `;
   const rbacInputField = table.RBAC ? "  RBAC: RBACInput" : "";
+  const inputFields = table.fields.filter((f) => f.name !== "guest_password_hash");
+  const inputExtra = table.name.singular === "agent" ? "  guest_password: String" : "";
   const inputDef = `
   input ${table.name.singular}Input {
-  ${table.fields.map((f) => `  ${f.name}: ${mapExuluFieldTypesToGraphqlTypes(f)}`).join("\n")}
+  ${inputFields.map((f) => `  ${f.name}: ${mapExuluFieldTypesToGraphqlTypes(f)}`).join("\n")}
+  ${inputExtra}
   ${rbacInputField}
   }
   `;
   return enumDefs + typeDef + inputDef;
 }
 function createExuluContextsFilterTypeDefs(table) {
-  const fieldFilters = table.fields.map((field) => {
+  const filterFields = table.fields.filter((field) => field.hidden !== true);
+  const fieldFilters = filterFields.map((field) => {
     let type;
     if (field.type === "enum" && field.enumValues) {
       type = `${field.name}Enum`;
@@ -19469,7 +20656,7 @@ function createExuluContextsFilterTypeDefs(table) {
   let operatorTypes = "";
   let enumFilterOperators = [];
   const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
-  enumFilterOperators = table.fields.filter((field) => field.type === "enum" && field.enumValues).map((field) => {
+  enumFilterOperators = filterFields.filter((field) => field.type === "enum" && field.enumValues).map((field) => {
     const enumTypeName = `${field.name}Enum`;
     return `
   input FilterOperator${enumTypeName} {
@@ -21028,12 +22215,12 @@ type LiteLLMModel {
         nonArchived().andWhere((b) => b.whereNull("chunks_count").orWhere("chunks_count", "<=", 0)).count("* as c").first(),
         nonArchived().where("embeddings_updated_at", "<=", staleCutoff).count("* as c").first()
       ]);
-      const num = (v) => v == null ? 0 : Number(v);
+      const num2 = (v) => v == null ? 0 : Number(v);
       return {
-        item_count: num(itemRow?.c),
-        chunk_total: num(chunkRow?.s),
-        stuck_count: num(stuckRow?.c),
-        stale_count: num(staleRow?.c)
+        item_count: num2(itemRow?.c),
+        chunk_total: num2(chunkRow?.s),
+        stuck_count: num2(stuckRow?.c),
+        stale_count: num2(staleRow?.c)
       };
     } catch (err) {
       console.error("[EXULU] computeContextAggregates failed for", contextId, err);
@@ -21239,6 +22426,7 @@ type LiteLLMModel {
       if (agenticRetrievalTool) {
         allTools.push(agenticRetrievalTool);
       }
+      allTools.push(createKbEditorPickerTool());
     }
     if (search && search.trim()) {
       const searchTerm = search.toLowerCase().trim();
@@ -21808,19 +22996,19 @@ var import_node_crypto14 = require("crypto");
 var import_api2 = require("@opentelemetry/api");
 init_check_record_access();
 var import_jszip3 = __toESM(require("jszip"), 1);
-var import_ai15 = require("ai");
+var import_ai12 = require("ai");
 var import_cookie_parser = __toESM(require("cookie-parser"), 1);
 init_statistics2();
 
 // src/exulu/suggestions.ts
 init_cjs_shims();
-var import_ai12 = require("ai");
-var import_zod15 = require("zod");
+var import_ai9 = require("ai");
+var import_zod17 = require("zod");
 var SUGGESTIONS_SYSTEM_PROMPT = "You generate short follow-up message suggestions for the user. You are NOT continuing the conversation as the assistant \u2014 you are predicting what the user might want to say next. Suggest up to 3 short follow-up questions or messages the user might want to send next. Each suggestion must be written from the user's perspective (first person) and be 12 words or fewer. You MUST submit your answer by calling the `submit_suggestions` tool exactly once. Do not emit any plain text \u2014 only the tool call.";
-var submitSuggestionsTool = (0, import_ai12.tool)({
+var submitSuggestionsTool = (0, import_ai9.tool)({
   description: "Submit the final list of follow-up message suggestions for the user. Must be called exactly once. Each suggestion is written from the user's perspective (first person) and is 12 words or fewer.",
-  inputSchema: import_zod15.z.object({
-    suggestions: import_zod15.z.array(import_zod15.z.string()).max(3)
+  inputSchema: import_zod17.z.object({
+    suggestions: import_zod17.z.array(import_zod17.z.string()).max(3)
   })
 });
 var MAX_CHARS_PER_MESSAGE = 1e4;
@@ -21856,11 +23044,11 @@ var generateSuggestions = async ({
 
 ${SUGGESTIONS_SYSTEM_PROMPT}` : SUGGESTIONS_SYSTEM_PROMPT;
   const trimmed = trimMessagesForSuggestions(messages);
-  const { toolCalls, totalUsage } = await (0, import_ai12.generateText)({
+  const { toolCalls, totalUsage } = await (0, import_ai9.generateText)({
     temperature: 0,
     model: languageModel,
     system,
-    messages: await (0, import_ai12.convertToModelMessages)(trimmed, {
+    messages: await (0, import_ai9.convertToModelMessages)(trimmed, {
       ignoreIncompleteToolCalls: true
     }),
     tools: { submit_suggestions: submitSuggestionsTool },
@@ -21914,7 +23102,7 @@ init_context_budget();
 // src/exulu/compact-session.ts
 init_cjs_shims();
 var import_node_crypto9 = require("crypto");
-var import_ai13 = require("ai");
+var import_ai10 = require("ai");
 init_truncate_tool_output();
 init_context_budget();
 var CompactionInsufficientError = class extends Error {
@@ -21973,7 +23161,7 @@ var compactSession = async ({
 }) => {
   const budget = deriveContextBudget(contextWindow);
   const rows = await getAgentMessages({ session: sessionID, user: user.id });
-  const all = await (0, import_ai13.validateUIMessages)({ messages: rows.map((r) => JSON.parse(r.content)) });
+  const all = await (0, import_ai10.validateUIMessages)({ messages: rows.map((r) => JSON.parse(r.content)) });
   const history = sliceHistoryAtCheckpoint(all);
   const { head, tail } = splitTail(history, budget.compactionTailTokens);
   if (head.length === 0) {
@@ -21988,7 +23176,7 @@ var compactSession = async ({
 
 Focus especially on: ${steer.trim()}` : SUMMARY_SYSTEM;
   const doSummarize = summarize ?? (async ({ system: sys, prompt, maxOutputTokens }) => {
-    const { text } = await (0, import_ai13.generateText)({
+    const { text } = await (0, import_ai10.generateText)({
       model: languageModel,
       system: sys,
       prompt,
@@ -22377,6 +23565,129 @@ init_admin_client();
 init_env();
 init_activity_client();
 init_budget_service();
+
+// src/exulu/litellm/usage-view.ts
+init_cjs_shims();
+init_tags();
+init_activity_client();
+init_budget_service();
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var MAX_WINDOW_DAYS = 92;
+var DEFAULT_WINDOW_DAYS = 30;
+var parseDateParam = (raw) => {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  if (typeof raw !== "string") return null;
+  if (DATE_ONLY_RE.test(raw)) return raw;
+  const dt = new Date(raw);
+  if (Number.isNaN(dt.getTime())) return null;
+  return dt.toISOString().slice(0, 10);
+};
+var ymdShift = (ymd2, days) => new Date(Date.parse(ymd2) + days * DAY_MS2).toISOString().slice(0, 10);
+function resolveUsageWindow(startRaw, endRaw, now = /* @__PURE__ */ new Date()) {
+  const start = parseDateParam(startRaw);
+  const end = parseDateParam(endRaw);
+  if (start === null || end === null) return null;
+  const end_date = end ?? now.toISOString().slice(0, 10);
+  let start_date = start ?? ymdShift(end_date, -(DEFAULT_WINDOW_DAYS - 1));
+  if (start_date > end_date) return null;
+  const days = Math.round((Date.parse(end_date) - Date.parse(start_date)) / DAY_MS2) + 1;
+  if (days > MAX_WINDOW_DAYS) {
+    start_date = ymdShift(end_date, -(MAX_WINDOW_DAYS - 1));
+  }
+  return { start_date, end_date };
+}
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var zeroMetrics = () => ({
+  spend: 0,
+  prompt_tokens: 0,
+  completion_tokens: 0,
+  total_tokens: 0,
+  successful_requests: 0,
+  failed_requests: 0,
+  api_requests: 0
+});
+var readMetrics = (source) => {
+  const m = source?.metrics ?? {};
+  return {
+    spend: num(m.spend ?? source?.spend),
+    prompt_tokens: num(m.prompt_tokens ?? source?.prompt_tokens),
+    completion_tokens: num(m.completion_tokens ?? source?.completion_tokens),
+    total_tokens: num(m.total_tokens ?? source?.total_tokens),
+    successful_requests: num(
+      m.successful_requests ?? source?.successful_requests
+    ),
+    failed_requests: num(m.failed_requests ?? source?.failed_requests),
+    api_requests: num(m.api_requests ?? source?.api_requests)
+  };
+};
+var addMetrics = (into, add) => {
+  into.spend += add.spend;
+  into.prompt_tokens += add.prompt_tokens;
+  into.completion_tokens += add.completion_tokens;
+  into.total_tokens += add.total_tokens;
+  into.successful_requests += add.successful_requests;
+  into.failed_requests += add.failed_requests;
+  into.api_requests += add.api_requests;
+};
+function projectMyUsage(raw) {
+  const results = Array.isArray(raw?.results) ? raw.results : Array.isArray(raw) ? raw : [];
+  const totals = zeroMetrics();
+  const byDate = /* @__PURE__ */ new Map();
+  const byModelMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const date = typeof result?.date === "string" ? result.date : null;
+    if (!date) continue;
+    const metrics = readMetrics(result);
+    addMetrics(totals, metrics);
+    const day = byDate.get(date) ?? zeroMetrics();
+    addMetrics(day, metrics);
+    byDate.set(date, day);
+    const models2 = result?.breakdown && typeof result.breakdown.models === "object" ? result.breakdown.models : {};
+    for (const [model, entry] of Object.entries(models2 ?? {})) {
+      const acc = byModelMap.get(model) ?? zeroMetrics();
+      addMetrics(acc, readMetrics(entry));
+      byModelMap.set(model, acc);
+    }
+  }
+  const daily = [...byDate.entries()].map(([date, m]) => ({ date, ...m })).sort((a, b) => a.date.localeCompare(b.date));
+  const byModel = [...byModelMap.entries()].map(([model, m]) => ({
+    model,
+    spend: m.spend,
+    prompt_tokens: m.prompt_tokens,
+    completion_tokens: m.completion_tokens,
+    total_tokens: m.total_tokens,
+    successful_requests: m.successful_requests,
+    failed_requests: m.failed_requests
+  })).sort((a, b) => b.spend - a.spend);
+  return { totals, daily, byModel };
+}
+async function getMyUsageView(userId, window) {
+  const settings = await getBudgetSettings();
+  if (!settings.show_user_budget_in_chat) return null;
+  const tag = budgetTagFor("user", userId);
+  if (!tag) return null;
+  const daysInRange = Math.round(
+    (Date.parse(window.end_date) - Date.parse(window.start_date)) / DAY_MS2
+  ) + 1;
+  const raw = await getTagDailyActivity({
+    startDate: window.start_date,
+    endDate: window.end_date,
+    tags: [tag],
+    page: 1,
+    pageSize: Math.min(daysInRange + 100, 1e4)
+  });
+  const { totals, daily, byModel } = projectMyUsage(raw);
+  return {
+    window,
+    display: settings.user_budget_display,
+    totals,
+    daily,
+    byModel
+  };
+}
+
+// src/exulu/routes.ts
 var import_multer = __toESM(require("multer"), 1);
 var import_busboy = __toESM(require("busboy"), 1);
 
@@ -22521,7 +23832,7 @@ function checkApiKeyScope(user, agentId) {
 // src/exulu/openai-gateway.ts
 init_cjs_shims();
 var import_express2 = require("express");
-var import_ai14 = require("ai");
+var import_ai11 = require("ai");
 
 // src/exulu/openai-transformer.ts
 init_cjs_shims();
@@ -22629,7 +23940,7 @@ function convertOpenAIToolsToAiSdkTools(tools) {
         t.function.name,
         {
           description: t.function.description ?? "",
-          inputSchema: (0, import_ai14.jsonSchema)({
+          inputSchema: (0, import_ai11.jsonSchema)({
             type: "object",
             properties: params.properties ?? {},
             ...params.required ? { required: params.required } : {}
@@ -23021,14 +24332,14 @@ ${project.description}` : ""}` : "",
           res.setHeader("Content-Type", "text/event-stream");
           res.setHeader("Cache-Control", "no-cache");
           res.setHeader("Connection", "keep-alive");
-          const result = (0, import_ai14.streamText)({
+          const result = (0, import_ai11.streamText)({
             model: languageModel,
             system: systemPrompt || void 0,
             messages: coreMessages,
             tools: hasTools ? activeTools : void 0,
             maxRetries: 2,
             prepareStep: clientTools.length > 0 ? void 0 : composePrepareSteps(contextGuard(contextWindow), gatewayRetrievalGuard, finalAnswerGuard(turnBudget), imageAttachmentGuard()),
-            stopWhen: clientTools.length > 0 ? void 0 : [(0, import_ai14.stepCountIs)(turnBudget)],
+            stopWhen: clientTools.length > 0 ? void 0 : [(0, import_ai11.stepCountIs)(turnBudget)],
             onError: (error) => {
               console.error("[OPENAI GATEWAY] stream error:", error);
             }
@@ -23061,14 +24372,14 @@ ${project.description}` : ""}` : "",
           const usage = await result.usage;
           await writeStatistics(agent, project, user, usage.inputTokens ?? 0, usage.outputTokens ?? 0);
         } else {
-          const { text, usage } = await (0, import_ai14.generateText)({
+          const { text, usage } = await (0, import_ai11.generateText)({
             model: languageModel,
             system: systemPrompt || void 0,
             messages: coreMessages,
             tools: hasTools ? activeTools : void 0,
             maxRetries: 2,
             prepareStep: clientTools.length > 0 ? void 0 : composePrepareSteps(contextGuard(contextWindow), gatewayRetrievalGuard, finalAnswerGuard(turnBudget), imageAttachmentGuard()),
-            stopWhen: clientTools.length > 0 ? void 0 : [(0, import_ai14.stepCountIs)(turnBudget)]
+            stopWhen: clientTools.length > 0 ? void 0 : [(0, import_ai11.stepCountIs)(turnBudget)]
           });
           res.json(transformCompletion(text, usage.inputTokens ?? 0, usage.outputTokens ?? 0, ctx));
           await writeStatistics(agent, project, user, usage.inputTokens ?? 0, usage.outputTokens ?? 0);
@@ -23100,11 +24411,11 @@ var getEnabledSkills = async (agent, disabledSkills = []) => {
   return enabledSkills;
 };
 
-// src/exulu/oauth/callback-handler.ts
+// src/exulu/auth/callback-handler.ts
 init_cjs_shims();
 init_registry();
 init_flow();
-init_token_store();
+init_credential_store();
 var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 var renderResultPage = ({ success, message }) => `<!doctype html>
 <html lang="en">
@@ -23156,7 +24467,7 @@ var handleOauthCallback = async (req, res) => {
       "This authorization link is invalid or has expired. Return to your chat and run the tool again to get a fresh link."
     );
   }
-  const config = oauthRegistry.getByProvider(parsed.provider);
+  const config = authRegistry.getByProvider(parsed.provider);
   if (!config) {
     return send(
       404,
@@ -23164,13 +24475,31 @@ var handleOauthCallback = async (req, res) => {
       `No OAuth configuration is registered for provider "${parsed.provider}".`
     );
   }
+  if (config.authType !== "oauth") {
+    return send(
+      500,
+      false,
+      `Provider "${parsed.provider}" is not configured for OAuth. This callback only handles OAuth flows.`
+    );
+  }
   try {
     const record = await exchangeCodeForTokens({
       config,
       code,
       codeVerifier: parsed.codeVerifier
     });
-    await oauthTokenStore.upsert(parsed.provider, parsed.userId, parsed.toolId, record);
+    await credentialStore.upsert({
+      provider: parsed.provider,
+      userId: parsed.userId,
+      authType: "oauth",
+      data: {
+        accessToken: record.accessToken,
+        refreshToken: record.refreshToken ?? null,
+        tokenType: record.tokenType ?? null,
+        scopes: record.scopes ?? null,
+        expiresAt: record.expiresAt ? record.expiresAt.toISOString() : null
+      }
+    });
   } catch (caught) {
     console.error("[EXULU] OAuth code exchange failed:", caught);
     return send(
@@ -23182,6 +24511,113 @@ var handleOauthCallback = async (req, res) => {
   return send(200, true, "You can close this tab and return to your chat.");
 };
 
+// src/exulu/auth/submit-handler.ts
+init_cjs_shims();
+var import_zod18 = require("zod");
+init_registry();
+init_credential_store();
+init_credentials_request();
+var bodySchema = import_zod18.z.object({
+  nonce: import_zod18.z.string().min(1),
+  values: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.string())
+});
+async function handleCredentialSubmit(req, res) {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const sessionUserId = authResult.user.id;
+  let parsed;
+  try {
+    parsed = bodySchema.parse(req.body);
+  } catch (caught) {
+    res.status(400).json({ ok: false, error: "invalid body" });
+    return;
+  }
+  const { nonce, values } = parsed;
+  let nonceData;
+  try {
+    nonceData = verifyCredentialNonce(nonce);
+  } catch (e) {
+    res.status(401).json({
+      ok: false,
+      error: /expired/i.test(e.message) ? "nonce expired" : "nonce invalid"
+    });
+    return;
+  }
+  if (sessionUserId !== Number(nonceData.userId)) {
+    res.status(403).json({ ok: false, error: "userId mismatch" });
+    return;
+  }
+  const config = authRegistry.getByProvider(nonceData.provider);
+  if (!config || config.authType !== "user_credentials") {
+    res.status(400).json({
+      ok: false,
+      error: "provider is not a user_credentials provider"
+    });
+    return;
+  }
+  const expectedFields = new Set(config.fields.map((f) => f.name));
+  const submittedFields = new Set(Object.keys(values));
+  if (expectedFields.size !== submittedFields.size || [...expectedFields].some((f) => !submittedFields.has(f))) {
+    res.status(400).json({
+      ok: false,
+      error: "field set mismatch"
+    });
+    return;
+  }
+  if (config.validate) {
+    try {
+      await config.validate(values);
+    } catch (e) {
+      res.status(400).json({
+        ok: false,
+        error: `validation failed: ${e.message}`
+      });
+      return;
+    }
+  }
+  if (!Number.isInteger(sessionUserId) || sessionUserId <= 0) {
+    res.status(401).json({ ok: false, error: "session invalid" });
+    return;
+  }
+  await credentialStore.upsert({
+    provider: nonceData.provider,
+    userId: sessionUserId,
+    authType: "user_credentials",
+    data: values
+  });
+  res.status(200).json({ ok: true });
+}
+
+// src/exulu/auth/manage-handlers.ts
+init_cjs_shims();
+init_credential_store();
+var handleCredentialList = async (req, res) => {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(authResult.code ?? 401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const credentials = await credentialStore.listByUser(authResult.user.id);
+  res.status(200).json({ ok: true, credentials });
+};
+var handleCredentialDelete = async (req, res) => {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(authResult.code ?? 401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const provider = req.params.provider;
+  if (!provider) {
+    res.status(400).json({ ok: false, error: "provider is required" });
+    return;
+  }
+  await credentialStore.delete(provider, authResult.user.id);
+  res.status(200).json({ ok: true });
+};
+
 // src/exulu/routes.ts
 init_flow();
 
@@ -23235,52 +24671,125 @@ var verifyRecallRequest = (headers, rawBody, secret = recallVerificationSecret()
   return passed ? { ok: true } : { ok: false, reason: "signature mismatch" };
 };
 
-// src/exulu/shared-artifacts.ts
+// src/exulu/public-agents.ts
 init_cjs_shims();
-var import_bcryptjs4 = __toESM(require("bcryptjs"), 1);
-var normalizeS3Key = (key, bucket) => {
-  const segments = key.split("/").filter((s, i) => !(i === 0 && s === "")).map((s) => decodeURIComponent(s));
-  if (segments[0] === bucket) segments.shift();
-  return segments.join("/");
-};
-var isHtmlKey = (key) => /\.html?$/i.test(key);
-var deriveFilename = (key) => {
-  const base = key.split("/").pop() ?? key;
-  return base.split("_EXULU_").pop() ?? base;
-};
-var slugifyShareName = (input) => deriveFilename(input).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-var isExpired = (expiresAt, now) => {
-  if (!expiresAt) return false;
-  return new Date(expiresAt).getTime() <= now.getTime();
-};
-var validateCreateInput = (input, now) => {
-  if (!input.s3key) return { ok: false, message: "s3key is required." };
-  if (!input.name) return { ok: false, message: "name is required." };
-  const mode = input.auth_mode;
-  if (mode !== "public" && mode !== "password" && mode !== "regular") {
-    return { ok: false, message: "auth_mode must be public, password, or regular." };
-  }
-  if (mode === "password" && !input.password) {
-    return { ok: false, message: "A password is required for password mode." };
+var publicAgentView = (row, slug) => ({
+  id: row.id,
+  name: row.name ?? "",
+  description: row.description ?? "",
+  image: row.image ?? null,
+  welcomemessage: row.welcomemessage ?? "",
+  slug,
+  guest_auth_mode: row.guest_auth_mode || "regular",
+  guest_has_cover: !!row.guest_cover_image
+});
+var evaluateGuestChatAccess = async (agent, userId, guestPassword) => {
+  if (agent.guest_access) {
+    if (userId != null) return { allowed: true, via: "guest" };
+    const mode = agent.guest_auth_mode || "regular";
+    if (mode === "public") return { allowed: true, via: "guest" };
+    if (mode === "password") {
+      if (agent.guest_password_hash && guestPassword) {
+        const ok = await verifySharePassword(guestPassword, agent.guest_password_hash);
+        if (ok) return { allowed: true, via: "guest" };
+        return { allowed: false, status: 401, message: "Incorrect password." };
+      }
+      return { allowed: false, status: 401, message: "Password required." };
+    }
+    return { allowed: false, status: 401, message: "Authentication required." };
   }
-  if (input.expires_at && Number.isNaN(new Date(input.expires_at).getTime())) {
-    return { ok: false, message: "expires_at is not a valid date." };
+  if (userId == null && agent.rights_mode === "public") {
+    return { allowed: true, via: "rbac-public" };
   }
-  if (input.expires_at && isExpired(input.expires_at, now)) {
-    return { ok: false, message: "expires_at must be in the future." };
+  return { allowed: false, status: 401, message: "Authentication required." };
+};
+
+// src/exulu/guest-rate-limit.ts
+init_cjs_shims();
+var MINUTE_MS = 6e4;
+var HOUR_MS2 = 36e5;
+var perMinuteLimit = () => parseInt(process.env.EXULU_GUEST_RATE_PER_MINUTE || "10", 10);
+var perHourLimit = () => parseInt(process.env.EXULU_GUEST_RATE_PER_HOUR || "60", 10);
+var maxMessageChars = () => parseInt(process.env.EXULU_GUEST_MAX_MESSAGE_CHARS || "8000", 10);
+var maxTotalChars = () => parseInt(process.env.EXULU_GUEST_MAX_TOTAL_CHARS || "32000", 10);
+var MAX_PART_COUNT = 100;
+var windows = /* @__PURE__ */ new Map();
+var guestRateLimitExceeded = (ip, now = Date.now()) => {
+  const state = windows.get(ip) ?? {
+    minuteStart: now,
+    minuteCount: 0,
+    hourStart: now,
+    hourCount: 0,
+    lastSeen: now
+  };
+  if (now - state.minuteStart >= MINUTE_MS) {
+    state.minuteStart = now;
+    state.minuteCount = 0;
+  }
+  if (now - state.hourStart >= HOUR_MS2) {
+    state.hourStart = now;
+    state.hourCount = 0;
+  }
+  state.minuteCount += 1;
+  state.hourCount += 1;
+  state.lastSeen = now;
+  windows.set(ip, state);
+  if (windows.size > 1e4) {
+    for (const [key, value] of windows) {
+      if (now - value.lastSeen >= HOUR_MS2) windows.delete(key);
+    }
+    if (windows.size > 1e4) {
+      const sorted = [...windows.entries()].sort(
+        (a, b) => a[1].lastSeen - b[1].lastSeen
+      );
+      for (const [key] of sorted) {
+        if (windows.size <= 1e4) break;
+        windows.delete(key);
+      }
+    }
   }
-  return { ok: true };
+  return state.minuteCount > perMinuteLimit() || state.hourCount > perHourLimit();
 };
-var hashSharePassword = (password) => import_bcryptjs4.default.hash(password, 10);
-var verifySharePassword = (password, hash) => import_bcryptjs4.default.compare(password, hash);
-var contentHeadersFor = (key, contentType, filename) => {
-  if (isHtmlKey(key)) return { contentType: "text/html; charset=utf-8" };
-  return {
-    contentType: contentType || "application/octet-stream",
-    disposition: `attachment; filename="${filename.replace(/"/g, "")}"`
+var partsTooLong = (parts) => Array.isArray(parts) && parts.some(
+  (p) => typeof p?.text === "string" && p.text.length > maxMessageChars()
+);
+var collectTextParts = (b) => {
+  const parts = [];
+  const addFromParts = (ps) => {
+    if (!Array.isArray(ps)) return;
+    for (const p of ps) {
+      if (typeof p?.text === "string") parts.push(p.text);
+    }
   };
+  if (b.message) addFromParts(b.message.parts);
+  if (Array.isArray(b.messages)) {
+    for (const m of b.messages) addFromParts(m?.parts);
+  }
+  return parts;
+};
+var guestMessageTooLong = (body) => {
+  const b = body;
+  if (!b) return false;
+  if (b.message && partsTooLong(b.message.parts)) return true;
+  if (Array.isArray(b.messages)) {
+    if (b.messages.some((m) => partsTooLong(m?.parts))) return true;
+  }
+  const allParts = collectTextParts(b);
+  if (allParts.length > MAX_PART_COUNT) return true;
+  const totalChars = allParts.reduce((sum, t) => sum + t.length, 0);
+  if (totalChars > maxTotalChars()) return true;
+  return false;
+};
+var extractClientIp = (req) => {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (process.env.EXULU_TRUST_PROXY === "true") {
+    if (typeof forwarded === "string" && forwarded.length > 0) {
+      const parts = forwarded.split(",");
+      return parts[parts.length - 1].trim();
+    }
+  }
+  return req.ip || req.socket?.remoteAddress || "unknown";
 };
-var getSharedArtifactByName = (db2, name) => db2("shared_artifacts").where({ name }).first();
 
 // src/skills/skill-access.ts
 init_cjs_shims();
@@ -23645,6 +25154,9 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
     })
   );
   app.get(OAUTH_CALLBACK_PATH, handleOauthCallback);
+  app.post("/credentials/submit", handleCredentialSubmit);
+  app.get("/credentials", handleCredentialList);
+  app.delete("/credentials/:provider", handleCredentialDelete);
   app.post("/test", async (req, res) => {
     const { item_name, context_id } = req.body;
     let itemFilters = [];
@@ -23988,17 +25500,33 @@ Mood: friendly and intelligent.
       }
       console.log("[EXULU] agent.rights_mode", agent.rights_mode);
       const authenticationResult = await requestValidators.authenticate(req);
-      if (!authenticationResult.user?.id && agent.rights_mode !== "public") {
-        res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
+      const user = authenticationResult.user;
+      if (!user?.id) {
+        const ip = extractClientIp(req);
+        if (guestRateLimitExceeded(ip)) {
+          res.status(429).json({ detail: "Too many requests. Try again later." });
+          return;
+        }
+        if (guestMessageTooLong(req.body)) {
+          res.status(413).json({ detail: "Message too long." });
+          return;
+        }
+      }
+      const guestGate = await evaluateGuestChatAccess(
+        agent,
+        user?.id,
+        req.headers["x-guest-password"]
+      );
+      if (!user?.id && !guestGate.allowed) {
+        res.status(guestGate.status).json({ detail: guestGate.message });
         return;
       }
-      const user = authenticationResult.user;
       const scopeCheck = checkApiKeyScope(user, instance2);
       if (!scopeCheck.allowed) {
         res.status(scopeCheck.code).json({ detail: scopeCheck.reason });
         return;
       }
-      const hasAccessToAgent = await checkRecordAccess(agent, "read", user);
+      const hasAccessToAgent = guestGate.allowed || await checkRecordAccess(agent, "read", user);
       if (!hasAccessToAgent) {
         res.status(401).json({
           message: "You don't have access to this agent."
@@ -24148,7 +25676,7 @@ ${customInstructions}` : agent.instructions;
             else message2 = JSON.stringify(error);
             return mapStreamErrorMessage(message2);
           },
-          generateMessageId: (0, import_ai15.createIdGenerator)({
+          generateMessageId: (0, import_ai12.createIdGenerator)({
             prefix: "msg_",
             size: 16
           }),
@@ -25356,6 +26884,32 @@ ${style.markdown}` : params.prompt;
     }
     res.status(200).json({ budget: await getUserBudgetView(authResult.user.id) });
   });
+  app.get("/me/usage", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const window = resolveUsageWindow(req.query.start_date, req.query.end_date);
+    if (!window) {
+      res.status(400).json({
+        detail: "start_date and end_date must be YYYY-MM-DD or ISO datetimes, with start_date <= end_date."
+      });
+      return;
+    }
+    try {
+      res.status(200).json({ usage: await getMyUsageView(authResult.user.id, window) });
+    } catch (err) {
+      if (err instanceof LiteLLMAdminError) {
+        res.status(502).json({ detail: err.message });
+        return;
+      }
+      console.error("[EXULU] /me/usage failed", err);
+      res.status(500).json({
+        detail: err instanceof Error ? err.message : "Usage query failed."
+      });
+    }
+  });
   app.put(
     "/admin/budgets/:entityType/bulk",
     async (req, res) => {
@@ -25469,10 +27023,10 @@ ${style.markdown}` : params.prompt;
     }
     return { user: authResult.user };
   };
-  const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+  const DATE_ONLY_RE2 = /^\d{4}-\d{2}-\d{2}$/;
   const normaliseDateParam = (raw) => {
     if (typeof raw !== "string" || raw.length === 0) return null;
-    if (DATE_ONLY_RE.test(raw)) return raw;
+    if (DATE_ONLY_RE2.test(raw)) return raw;
     const dt = new Date(raw);
     if (Number.isNaN(dt.getTime())) return null;
     return dt.toISOString().slice(0, 10);
@@ -27069,6 +28623,93 @@ ${style.markdown}` : params.prompt;
     if (headers.disposition) res.setHeader("Content-Disposition", headers.disposition);
     res.send(bytes);
   });
+  const resolvePublicAgentSlug = async (agentModel) => {
+    if (isLiteLLMEnabled()) return "/agents/litellm/run";
+    if (!agentModel) return "";
+    const { db: db2 } = await postgresClient();
+    const modelRow = await db2.from("models").where({ id: agentModel }).first();
+    const provider = modelRow?.provider ? providers.find((a) => a.id === modelRow.provider) : void 0;
+    return provider?.slug || "";
+  };
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const getGuestAgentById = async (id) => {
+    if (!UUID_RE.test(id)) return void 0;
+    const { db: db2 } = await postgresClient();
+    return db2.from("agents").where({ id, guest_access: true, active: true }).first();
+  };
+  app.get("/public-agents", async (_req, res) => {
+    const { db: db2 } = await postgresClient();
+    const rows = await db2.from("agents").where({ guest_access: true, active: true }).select(
+      "id",
+      "name",
+      "description",
+      "image",
+      "welcomemessage",
+      "model",
+      "guest_auth_mode",
+      "guest_cover_image"
+    );
+    const views = await Promise.all(
+      rows.map(
+        async (row) => publicAgentView(row, await resolvePublicAgentSlug(row.model))
+      )
+    );
+    res.json(views);
+  });
+  app.get("/public-agents/:id/meta", async (req, res) => {
+    const row = await getGuestAgentById(req.params.id ?? "");
+    if (!row) {
+      res.status(404).json({ detail: "Not found." });
+      return;
+    }
+    res.json(publicAgentView(row, await resolvePublicAgentSlug(row.model)));
+  });
+  app.get("/public-agents/:id/cover", async (req, res) => {
+    const row = await getGuestAgentById(req.params.id ?? "");
+    if (!row?.guest_cover_image) {
+      res.status(404).json({ detail: "Not found." });
+      return;
+    }
+    let bytes;
+    try {
+      bytes = await getS3ObjectBytes(row.guest_cover_image, config);
+    } catch (e) {
+      if (e?.name === "NoSuchKey" || e?.name === "NotFound" || e?.$metadata?.httpStatusCode === 404) {
+        res.status(404).json({ detail: "Cover not found." });
+        return;
+      }
+      console.error("[EXULU] public-agent cover read failed", e);
+      res.status(500).json({ detail: "Failed to read cover." });
+      return;
+    }
+    const ext = row.guest_cover_image.split(".").pop()?.toLowerCase();
+    const contentType = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : "image/jpeg";
+    res.setHeader("Content-Type", contentType);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Cache-Control", "public, max-age=300");
+    res.send(bytes);
+  });
+  app.post(
+    "/public-agents/:id/verify-password",
+    async (req, res) => {
+      const ip = extractClientIp(req);
+      if (guestRateLimitExceeded(ip)) {
+        res.status(429).json({ detail: "Too many requests. Try again later." });
+        return;
+      }
+      const row = await getGuestAgentById(req.params.id ?? "");
+      if (!row || row.guest_auth_mode !== "password") {
+        res.status(404).json({ detail: "Not found." });
+        return;
+      }
+      const password = typeof req.body?.password === "string" ? req.body.password : "";
+      if (!row.guest_password_hash || !await verifySharePassword(password, row.guest_password_hash)) {
+        res.status(401).json({ detail: "Incorrect password." });
+        return;
+      }
+      res.status(204).end();
+    }
+  );
   app.use(import_express5.default.static("public"));
   await registerOpenAIGatewayRoutes(app, providers, tools, contexts, config);
   return app;
@@ -27147,7 +28788,7 @@ init_check_record_access();
 init_resolve_model();
 init_supervisor();
 init_client();
-var import_zod16 = require("zod");
+var import_zod19 = require("zod");
 init_convert_exulu_tools_to_ai_sdk_tools();
 init_singleton();
 var SESSION_ID_HEADER = "mcp-session-id";
@@ -27221,7 +28862,7 @@ var ExuluMCP = class {
           title: tool4.name + " agent",
           description: tool4.description,
           inputSchema: {
-            inputs: tool4.inputSchema || import_zod16.z.object({})
+            inputs: tool4.inputSchema || import_zod19.z.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -27273,7 +28914,7 @@ var ExuluMCP = class {
           title: "Get List of Prompt Templates",
           description: "Retrieves a list of prompt templates available for this agent. Returns the name, description, and ID of each template.",
           inputSchema: {
-            inputs: import_zod16.z.object({})
+            inputs: import_zod19.z.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -27319,8 +28960,8 @@ var ExuluMCP = class {
           title: "Get Prompt Template Details",
           description: "Retrieves the full details of a specific prompt template by ID, including the actual template content with variables.",
           inputSchema: {
-            inputs: import_zod16.z.object({
-              id: import_zod16.z.string().describe("The ID of the prompt template to retrieve")
+            inputs: import_zod19.z.object({
+              id: import_zod19.z.string().describe("The ID of the prompt template to retrieve")
             })
           }
         },
@@ -28395,7 +30036,7 @@ init_cjs_shims();
 
 // src/exulu/evals.ts
 init_cjs_shims();
-var import_ai16 = require("ai");
+var import_ai13 = require("ai");
 init_entitlements();
 var ExuluEval = class {
   id;
@@ -28435,8 +30076,8 @@ var ExuluEval = class {
 // src/templates/evals/index.ts
 init_resolve_model();
 init_singleton();
-var import_zod17 = require("zod");
-var import_ai17 = require("ai");
+var import_zod20 = require("zod");
+var import_ai14 = require("ai");
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
     return new ExuluEval({
@@ -28481,15 +30122,15 @@ var llmAsJudgeEval = () => {
           rbacBypass: true
         });
         console.log("[EXULU] prompt", prompt);
-        const { output } = await (0, import_ai17.generateText)({
+        const { output } = await (0, import_ai14.generateText)({
           temperature: 0,
           model: resolved.languageModel,
           system: "",
           prompt,
           maxRetries: 2,
-          output: import_ai17.Output.object({
-            schema: import_zod17.z.object({
-              score: import_zod17.z.number().min(0).max(100).describe("The score between 0 and 100.")
+          output: import_ai14.Output.object({
+            schema: import_zod20.z.object({
+              score: import_zod20.z.number().min(0).max(100).describe("The score between 0 and 100.")
             })
           })
         });
@@ -28720,15 +30361,15 @@ Usage:
 - If no todos exist yet, an empty list will be returned`;
 
 // src/templates/tools/todo/todo.ts
-var import_zod18 = __toESM(require("zod"), 1);
+var import_zod21 = __toESM(require("zod"), 1);
 init_tool();
 init_check_record_access();
 init_client();
-var TodoSchema = import_zod18.default.object({
-  content: import_zod18.default.string().describe("Brief description of the task"),
-  status: import_zod18.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  priority: import_zod18.default.string().describe("Priority level of the task: high, medium, low"),
-  id: import_zod18.default.string().describe("Unique identifier for the todo item")
+var TodoSchema = import_zod21.default.object({
+  content: import_zod21.default.string().describe("Brief description of the task"),
+  status: import_zod21.default.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+  priority: import_zod21.default.string().describe("Priority level of the task: high, medium, low"),
+  id: import_zod21.default.string().describe("Unique identifier for the todo item")
 });
 var TodoWriteTool = new ExuluTool({
   id: "todo_write",
@@ -28744,8 +30385,8 @@ var TodoWriteTool = new ExuluTool({
       default: todowrite_default
     }
   ],
-  inputSchema: import_zod18.default.object({
-    todos: import_zod18.default.array(TodoSchema).describe("The updated todo list")
+  inputSchema: import_zod21.default.object({
+    todos: import_zod21.default.array(TodoSchema).describe("The updated todo list")
   }),
   execute: async (inputs) => {
     const { sessionID, todos, user } = inputs;
@@ -28780,7 +30421,7 @@ var TodoReadTool = new ExuluTool({
   id: "todo_read",
   name: "Todo Read",
   description: "Use this tool to read your todo list",
-  inputSchema: import_zod18.default.object({}),
+  inputSchema: import_zod21.default.object({}),
   type: "function",
   category: "todo",
   config: [
@@ -28825,7 +30466,7 @@ init_cjs_shims();
 var questionread_default = 'Use this tool to read questions you\'ve asked and check if they\'ve been answered by the user. This tool helps you track the status of questions and retrieve the user\'s selected answers.\n\n## When to Use This Tool\n\nUse this tool proactively in these situations:\n- After asking a question to check if the user has responded\n- To retrieve the user\'s answer before proceeding with implementation\n- To review all questions and answers in the current session\n- When you need to reference a previous answer\n\n## How It Works\n\n- This tool takes no parameters (leave the input blank or empty)\n- Returns an array of all questions in the session\n- Each question includes:\n  - `id`: Unique identifier for the question\n  - `question`: The question text\n  - `answerOptions`: Array of answer options with their IDs and text\n  - `status`: Either "pending" (not answered) or "answered"\n  - `selectedAnswerId`: The ID of the chosen answer (only present if answered)\n\n## Usage Pattern\n\nTypically you\'ll:\n1. Use Question Ask to pose a question\n2. Wait for the user to respond\n3. Use Question Read to check the answer\n4. Find the selected answer by matching the `selectedAnswerId` with an option in `answerOptions`\n5. Proceed with implementation based on the user\'s choice\n\n## Example Response\n\n```json\n[\n  {\n    "id": "question123",\n    "question": "Which authentication method would you like to implement?",\n    "answerOptions": [\n      { "id": "ans1", "text": "JWT tokens" },\n      { "id": "ans2", "text": "OAuth 2.0" },\n      { "id": "ans3", "text": "Session-based auth" },\n      { "id": "ans4", "text": "None of the above..." }\n    ],\n    "status": "answered",\n    "selectedAnswerId": "ans1"\n  }\n]\n```\n\nIn this example, the user selected "JWT tokens" (id: ans1).\n\n## Important Notes\n\n- If no questions exist in the session, an empty array will be returned\n- Questions remain in the session even after being answered for reference\n- Use the `selectedAnswerId` to find which answer option the user chose by matching it against the `id` field in `answerOptions`\n';
 
 // src/templates/tools/question/question.ts
-var import_zod20 = __toESM(require("zod"), 1);
+var import_zod23 = __toESM(require("zod"), 1);
 init_tool();
 init_client();
 
@@ -28917,21 +30558,21 @@ After asking a question, use the Question Read tool to check if the user has ans
 `;
 
 // src/templates/tools/question/question-ask.ts
-var import_zod19 = __toESM(require("zod"), 1);
+var import_zod22 = __toESM(require("zod"), 1);
 init_tool();
 init_check_record_access();
 init_client();
 var import_node_crypto16 = require("crypto");
-var AnswerOptionSchema = import_zod19.default.object({
-  id: import_zod19.default.string().describe("Unique identifier for the answer option"),
-  text: import_zod19.default.string().describe("The text of the answer option")
+var AnswerOptionSchema = import_zod22.default.object({
+  id: import_zod22.default.string().describe("Unique identifier for the answer option"),
+  text: import_zod22.default.string().describe("The text of the answer option")
 });
-var _QuestionSchema = import_zod19.default.object({
-  id: import_zod19.default.string().describe("Unique identifier for the question"),
-  question: import_zod19.default.string().describe("The question to ask the user"),
-  answerOptions: import_zod19.default.array(AnswerOptionSchema).describe("Array of possible answer options"),
-  selectedAnswerId: import_zod19.default.string().optional().describe("The ID of the answer option selected by the user"),
-  status: import_zod19.default.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
+var _QuestionSchema = import_zod22.default.object({
+  id: import_zod22.default.string().describe("Unique identifier for the question"),
+  question: import_zod22.default.string().describe("The question to ask the user"),
+  answerOptions: import_zod22.default.array(AnswerOptionSchema).describe("Array of possible answer options"),
+  selectedAnswerId: import_zod22.default.string().optional().describe("The ID of the answer option selected by the user"),
+  status: import_zod22.default.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
 });
 var QuestionAskTool = new ExuluTool({
   id: "question_ask",
@@ -28948,9 +30589,9 @@ var QuestionAskTool = new ExuluTool({
       default: questionask_default
     }
   ],
-  inputSchema: import_zod19.default.object({
-    question: import_zod19.default.string().describe("The question to ask the user"),
-    answerOptions: import_zod19.default.array(import_zod19.default.string()).describe("Array of possible answer options (strings)")
+  inputSchema: import_zod22.default.object({
+    question: import_zod22.default.string().describe("The question to ask the user"),
+    answerOptions: import_zod22.default.array(import_zod22.default.string()).describe("Array of possible answer options (strings)")
   }),
   execute: async (inputs) => {
     const { sessionID, question, answerOptions, user } = inputs;
@@ -29023,7 +30664,7 @@ var QuestionReadTool = new ExuluTool({
   name: "Question Read",
   needsApproval: false,
   description: "Use this tool to read questions and their answers",
-  inputSchema: import_zod20.default.object({}),
+  inputSchema: import_zod23.default.object({}),
   type: "function",
   category: "question",
   config: [
@@ -29055,15 +30696,15 @@ var questionTools = [QuestionAskTool, QuestionReadTool];
 // src/templates/tools/perplexity.ts
 init_cjs_shims();
 init_tool();
-var import_zod21 = __toESM(require("zod"), 1);
+var import_zod24 = __toESM(require("zod"), 1);
 var import_perplexity_ai = __toESM(require("@perplexity-ai/perplexity_ai"), 1);
 var internetSearchTool = new ExuluTool({
   id: "internet_search",
   name: "Internet Search",
   description: "Search the internet for information.",
-  inputSchema: import_zod21.default.object({
-    query: import_zod21.default.string().describe("The query to the tool."),
-    search_recency_filter: import_zod21.default.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
+  inputSchema: import_zod24.default.object({
+    query: import_zod24.default.string().describe("The query to the tool."),
+    search_recency_filter: import_zod24.default.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
   }),
   category: "internet_search",
   type: "web_search",
@@ -29158,7 +30799,7 @@ var perplexityTools = [internetSearchTool];
 init_cjs_shims();
 init_tool();
 var nodemailer = __toESM(require("nodemailer"), 1);
-var import_zod22 = require("zod");
+var import_zod25 = require("zod");
 var transporter = null;
 function getTransporter(config) {
   if (!transporter) {
@@ -29182,11 +30823,11 @@ var emailTool = new ExuluTool({
   id: "email",
   name: "Email",
   description: "Send an email.",
-  inputSchema: import_zod22.z.object({
-    recipient: import_zod22.z.string().describe("The recipient of the email."),
-    subject: import_zod22.z.string().describe("The subject of the email."),
-    html: import_zod22.z.string().describe("The HTML body of the email."),
-    text: import_zod22.z.string().describe("The text body of the email.")
+  inputSchema: import_zod25.z.object({
+    recipient: import_zod25.z.string().describe("The recipient of the email."),
+    subject: import_zod25.z.string().describe("The subject of the email."),
+    html: import_zod25.z.string().describe("The HTML body of the email."),
+    text: import_zod25.z.string().describe("The text body of the email.")
   }),
   type: "function",
   config: [{
@@ -29257,7 +30898,7 @@ init_tool();
 init_supervisor();
 init_client();
 init_check_record_access();
-var import_zod23 = require("zod");
+var import_zod26 = require("zod");
 var _cachedImageModels;
 var setCachedImageModels = (models2) => {
   _cachedImageModels = models2;
@@ -29318,8 +30959,8 @@ var createImageGenerationWidgetTool = (models2) => {
     needsApproval: false,
     type: "function",
     config: [],
-    inputSchema: import_zod23.z.object({
-      prompt: import_zod23.z.string().describe(
+    inputSchema: import_zod26.z.object({
+      prompt: import_zod26.z.string().describe(
         "Initial image prompt. The user can edit it before generating."
       )
     }),
@@ -29646,6 +31287,43 @@ var startTranscriptionPollingLoop = () => {
   process.on("SIGTERM", stop);
 };
 
+// src/exulu/recall/reconcile-loop.ts
+init_cjs_shims();
+var RECONCILE_INTERVAL_MS = 6e4;
+var timer2 = null;
+var stopped2 = false;
+var tick2 = async () => {
+  if (stopped2) return;
+  try {
+    const acted = await recallService.reconcileOnce();
+    if (acted > 0) {
+      console.log(`[EXULU-RECALL] reconcile tick recovered ${acted} job(s)`);
+    }
+  } catch (err) {
+    console.error(
+      `[EXULU-RECALL] reconcile tick failed: ${err.message}`
+    );
+  } finally {
+    if (!stopped2) {
+      timer2 = setTimeout(tick2, RECONCILE_INTERVAL_MS);
+    }
+  }
+};
+var startRecallReconcileLoop = () => {
+  if (timer2) return;
+  stopped2 = false;
+  timer2 = setTimeout(tick2, RECONCILE_INTERVAL_MS);
+  const stop = () => {
+    stopped2 = true;
+    if (timer2) {
+      clearTimeout(timer2);
+      timer2 = null;
+    }
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+};
+
 // src/exulu/app/index.ts
 var isDev = process.env.NODE_ENV !== "production";
 var lineLimitFormat = import_winston2.default.format((info) => {
@@ -29880,6 +31558,9 @@ var ExuluApp = class {
         );
       }
       logRecallStartup();
+      if (recallEnabled()) {
+        startRecallReconcileLoop();
+      }
       return this._expressApp;
     }
   };
@@ -30834,6 +32515,7 @@ var RecursiveChunker = class _RecursiveChunker extends BaseChunker {
 
 // src/exulu/read-api.ts
 init_cjs_shims();
+init_table_names();
 init_client();
 var authorizedRead = async (context, user, role, opts = {}) => {
   if (!opts.itemIds?.length && !opts.externalIds?.length) {
@@ -30937,7 +32619,6 @@ var {
   promptFavoritesSchema: promptFavoritesSchema3,
   transcriptionJobsSchema: transcriptionJobsSchema3,
   imageGenerationsSchema: imageGenerationsSchema2,
-  oauthTokensSchema: oauthTokensSchema2,
   sharedArtifactsSchema: sharedArtifactsSchema2
 } = coreSchemas.get();
 var addMissingFields = async (knex, tableName, fields, skipFields = []) => {
@@ -30960,6 +32641,18 @@ var addMissingFields = async (knex, tableName, fields, skipFields = []) => {
     console.log(`[EXULU] Field '${sanitizedName}' already exists in ${tableName} table.`);
   }
 };
+var migrateUserCredentialsDataColumn = async (knex) => {
+  const dataType = await knex.raw(
+    `SELECT data_type FROM information_schema.columns
+      WHERE table_name = 'user_credentials' AND column_name = 'data'`
+  );
+  if (dataType.rows?.[0]?.data_type === "jsonb") {
+    console.log("[EXULU] Migrating user_credentials.data jsonb -> text.");
+    await knex.raw(
+      "ALTER TABLE user_credentials ALTER COLUMN data TYPE text USING data::text"
+    );
+  }
+};
 var up = async function(knex) {
   console.log("[EXULU] Database up.");
   const schemas = [
@@ -30981,7 +32674,6 @@ var up = async function(knex) {
     promptFavoritesSchema3(),
     transcriptionJobsSchema3(),
     imageGenerationsSchema2(),
-    oauthTokensSchema2(),
     sharedArtifactsSchema2(),
     rbacSchema3(),
     agentsSchema3(),
@@ -31015,10 +32707,9 @@ var up = async function(knex) {
     console.log(`[EXULU] Creating ${schema.name.plural} table.`, schema.fields);
     await createTable(schema);
   }
-  await knex.raw("DROP INDEX IF EXISTS oauth_tokens_tool_id_user_id_unique");
-  await knex.raw(
-    "CREATE UNIQUE INDEX IF NOT EXISTS oauth_tokens_provider_user_id_unique ON oauth_tokens (provider, user_id)"
-  );
+  await knex.raw("DROP TABLE IF EXISTS oauth_tokens CASCADE;");
+  await knex.raw(userCredentialsSchema());
+  await migrateUserCredentialsDataColumn(knex);
   if (await knex.schema.hasColumn("job_results", "workflow") && await knex.schema.hasColumn("job_results", "trigger_metadata")) {
     await knex.raw(
       "CREATE INDEX IF NOT EXISTS job_results_email_dedup_idx ON job_results (workflow, (trigger_metadata->>'message_id'))"
@@ -31212,6 +32903,11 @@ var execute = async ({ contexts }) => {
       evals: "read"
     }).returning("id");
   }
+  const existingExternalRole = await db2.from("roles").where({ name: "external" }).first();
+  if (!existingExternalRole) {
+    console.log("[EXULU] Creating external role.");
+    await db2.from("roles").insert({ name: "external" }).returning("id");
+  }
   const existingUser = await db2.from("users").where({ email: "admin@exulu.com" }).first();
   if (!existingUser) {
     const password = await encryptString("admin");
@@ -32055,8 +33751,8 @@ var MarkdownChunker = class {
 init_cjs_shims();
 var fs4 = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
-var import_ai18 = require("ai");
-var import_zod24 = require("zod");
+var import_ai15 = require("ai");
+var import_zod27 = require("zod");
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_crypto2 = require("crypto");
 init_with_retry();
@@ -32520,18 +34216,18 @@ If the page contains a flow-chart, schematic, technical drawing or control board
 
 ### 7. Only populate \`corrected_text\` when \`needs_correction\` is true. If the OCR output is accurate, return \`needs_correction: false\` and \`corrected_content: null\`.
 `;
-  const result = await (0, import_ai18.generateText)({
+  const result = await (0, import_ai15.generateText)({
     model,
-    output: import_ai18.Output.object({
-      schema: import_zod24.z.object({
-        needs_correction: import_zod24.z.boolean(),
-        corrected_text: import_zod24.z.string().nullable(),
-        current_page_table: import_zod24.z.object({
-          headers: import_zod24.z.array(import_zod24.z.string()),
-          is_continuation: import_zod24.z.boolean()
+    output: import_ai15.Output.object({
+      schema: import_zod27.z.object({
+        needs_correction: import_zod27.z.boolean(),
+        corrected_text: import_zod27.z.string().nullable(),
+        current_page_table: import_zod27.z.object({
+          headers: import_zod27.z.array(import_zod27.z.string()),
+          is_continuation: import_zod27.z.boolean()
         }).nullable(),
-        confidence: import_zod24.z.enum(["high", "medium", "low"]),
-        reasoning: import_zod24.z.string()
+        confidence: import_zod27.z.enum(["high", "medium", "low"]),
+        reasoning: import_zod27.z.string()
       })
     }),
     messages: [
@@ -33042,6 +34738,7 @@ async function rerank(input) {
 // src/index.ts
 init_pipeline();
 init_statistics();
+init_errors();
 var ExuluJobs = {
   redis: redisClient
 };
@@ -33156,6 +34853,7 @@ var ExuluPython = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CredentialInvalidError,
   EXULU_JOB_STATUS_ENUM,
   EXULU_STATISTICS_TYPE_ENUM,
   ExuluApp,