@exulu/backend 3.0.0 → 3.1.0

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

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