@diegoaltoworks/chatter 0.61.0 → 0.63.0

package/dist/channels/whatsapp/index.js

@@ -35,6 +35,7 @@ __export(index_exports, {
   LEASE_WAIT_MS: () => LEASE_WAIT_MS,
   acquireSessionLease: () => acquireSessionLease,
   canAcquireLease: () => canAcquireLease,
+  createTursoWaAuthKV: () => createTursoWaAuthKV,
   createTursoWaLeaseStore: () => createTursoWaLeaseStore,
   createWhatsAppChannel: () => createWhatsAppChannel,
   createWhatsAppImageHandler: () => createWhatsAppImageHandler,
@@ -50,12 +51,14 @@ __export(index_exports, {
   jidsMatch: () => jidsMatch,
   loadBaileys: () => loadBaileys,
   messageContext: () => messageContext,
+  normalizeWaMediaPayload: () => normalizeWaMediaPayload,
   reconnectDelayMs: () => reconnectDelayMs,
   resolveWaMessage: () => resolveWaMessage,
   senderNameFor: () => senderNameFor,
   senderPhoneFor: () => senderPhoneFor,
   shutdownWaSessions: () => shutdownWaSessions,
   stripOwnMentions: () => stripOwnMentions,
+  useAuthState: () => useAuthState,
   useTursoAuthState: () => useTursoAuthState
 });
 module.exports = __toCommonJS(index_exports);
@@ -129,27 +132,55 @@ function ensureAuthSchema(client) {
   }
   return ready;
 }
-async function useTursoAuthState(db, secret, sessionId, runtime) {
-  await ensureAuthSchema(db);
+function createTursoWaAuthKV(db) {
+  return {
+    async read(id) {
+      await ensureAuthSchema(db);
+      const result = await db.execute({
+        sql: "SELECT value FROM wa_auth WHERE id = ?",
+        args: [id]
+      });
+      const row = result.rows[0];
+      return row ? row.value : null;
+    },
+    async write(id, value) {
+      await ensureAuthSchema(db);
+      await db.execute({
+        sql: "INSERT OR REPLACE INTO wa_auth (id, value) VALUES (?, ?)",
+        args: [id, value]
+      });
+    },
+    async remove(id) {
+      await ensureAuthSchema(db);
+      await db.execute({ sql: "DELETE FROM wa_auth WHERE id = ?", args: [id] });
+    },
+    // Mirrors isAuthRowForSession - keep the two in sync.
+    async clear(sessionId) {
+      await ensureAuthSchema(db);
+      if (sessionId === "default") {
+        await db.execute("DELETE FROM wa_auth WHERE id NOT LIKE 's:%'");
+      } else {
+        await db.execute({
+          sql: "DELETE FROM wa_auth WHERE id LIKE ?",
+          args: [`s:${sessionId}/%`]
+        });
+      }
+    }
+  };
+}
+async function useAuthState(store, secret, sessionId, runtime) {
   const rowId = (id) => sessionId === "default" ? id : `s:${sessionId}/${id}`;
   async function read(id) {
-    const result = await db.execute({
-      sql: "SELECT value FROM wa_auth WHERE id = ?",
-      args: [rowId(id)]
-    });
-    const row = result.rows[0];
-    if (!row) return null;
-    return JSON.parse(await decrypt(row.value, secret), runtime.bufferJSON.reviver);
+    const value = await store.read(rowId(id));
+    if (value === null) return null;
+    return JSON.parse(await decrypt(value, secret), runtime.bufferJSON.reviver);
   }
   async function write(id, value) {
     const payload = await encrypt(JSON.stringify(value, runtime.bufferJSON.replacer), secret);
-    await db.execute({
-      sql: "INSERT OR REPLACE INTO wa_auth (id, value) VALUES (?, ?)",
-      args: [rowId(id), payload]
-    });
+    await store.write(rowId(id), payload);
   }
   async function remove(id) {
-    await db.execute({ sql: "DELETE FROM wa_auth WHERE id = ?", args: [rowId(id)] });
+    await store.remove(rowId(id));
   }
   const creds = await read("creds") ?? runtime.initAuthCreds();
   return {
@@ -186,18 +217,13 @@ async function useTursoAuthState(db, secret, sessionId, runtime) {
       }
     },
     saveCreds: () => write("creds", creds),
-    clear: async () => {
-      if (sessionId === "default") {
-        await db.execute("DELETE FROM wa_auth WHERE id NOT LIKE 's:%'");
-      } else {
-        await db.execute({
-          sql: "DELETE FROM wa_auth WHERE id LIKE ?",
-          args: [`s:${sessionId}/%`]
-        });
-      }
-    }
+    // Scoped to THIS session - never nuke a sibling number's pairing.
+    clear: () => store.clear(sessionId)
   };
 }
+async function useTursoAuthState(db, secret, sessionId, runtime) {
+  return useAuthState(createTursoWaAuthKV(db), secret, sessionId, runtime);
+}
 
 // src/channels/whatsapp/baileys.ts
 function wrapMissingBaileysError(cause) {
@@ -260,6 +286,11 @@ function createConsoleLogger(level = "info") {
   };
 }
 
+// src/channels/backoff.ts
+function exponentialBackoffMs(baseMs, maxMs, n) {
+  return Math.min(baseMs * 2 ** Math.max(0, Math.min(n, 20)), maxMs);
+}
+
 // src/channels/whatsapp/lease.ts
 var LEASE_STALE_MS = 9e4;
 var LEASE_HEARTBEAT_MS = 3e4;
@@ -318,7 +349,7 @@ function createTursoWaLeaseStore(client) {
 var RECONNECT_DELAY_MS = 5e3;
 var RECONNECT_MAX_DELAY_MS = 10 * 60 * 1e3;
 function reconnectDelayMs(failures) {
-  return Math.min(RECONNECT_DELAY_MS * 2 ** Math.min(failures, 20), RECONNECT_MAX_DELAY_MS);
+  return exponentialBackoffMs(RECONNECT_DELAY_MS, RECONNECT_MAX_DELAY_MS, failures);
 }
 async function shutdownWaSessions(sessions) {
   await Promise.all(
@@ -329,11 +360,17 @@ async function shutdownWaSessions(sessions) {
     })
   );
 }
-async function loseSession(sessionId, sessions) {
+function claimSession(sessionId, sessions) {
   const handle = sessions.get(sessionId);
-  if (!handle) return;
+  if (!handle) return void 0;
   sessions.delete(sessionId);
+  return handle;
+}
+async function loseSession(sessionId, sessions) {
+  const handle = claimSession(sessionId, sessions);
+  if (!handle) return false;
   await shutdownWaSessions(/* @__PURE__ */ new Map([[sessionId, handle]]));
+  return true;
 }
 async function acquireSessionLease(sessionId, deps) {
   const { leaseStore, instanceId, sessions, isStopped, connect } = deps;
@@ -369,7 +406,9 @@ async function acquireSessionLease(sessionId, deps) {
     void leaseStore.tryAcquire(sessionId, instanceId, now(), staleMs).then((stillHeld) => {
       if (stillHeld || isStopped()) return;
       logger.error(`WhatsApp[${sessionId}]: lost the lease to another instance \u2014 disconnecting`);
-      void loseSession(sessionId, sessions).then(retry);
+      void loseSession(sessionId, sessions).then((lost) => {
+        if (lost) retry();
+      });
     }).catch((error) => logger.warn(`WhatsApp[${sessionId}]: lease heartbeat failed:`, error));
   }, heartbeatMs);
   if (typeof heartbeat === "object" && "unref" in heartbeat) heartbeat.unref();
@@ -381,6 +420,10 @@ async function acquireSessionLease(sessionId, deps) {
   try {
     await connect(sessionId);
   } catch (error) {
+    if (deps.onConnectFailed) {
+      deps.onConnectFailed(sessionId, error);
+      return;
+    }
     logger.error(`WhatsApp[${sessionId}]: connect failed right after acquiring the lease:`, error);
     await loseSession(sessionId, sessions);
     retry();
@@ -389,9 +432,18 @@ async function acquireSessionLease(sessionId, deps) {
 function senderNameFor(channelName, sessionId) {
   return sessionId === "default" ? channelName : `${channelName}:${sessionId}`;
 }
+function normalizeWaMediaPayload(payload) {
+  const media = typeof payload === "string" ? { url: payload } : payload;
+  if (!media || typeof media !== "object" || typeof media.url !== "string" || !media.url) {
+    throw new TypeError(
+      `WhatsApp sendMedia payload must be a URL string or { url, caption? }, got: ${typeof payload}`
+    );
+  }
+  return media;
+}
 function createWhatsAppChannel(config) {
   assertStrongSecret(config.sessionSecret, "WhatsApp sessionSecret (e.g. WA_SESSION_SECRET)");
-  const channelName = "whatsapp";
+  const channelName = config.name ?? "whatsapp";
   const sessionIds = config.sessionIds && config.sessionIds.length > 0 ? config.sessionIds : ["default"];
   const now = config.now ?? Date.now;
   const schedule = config.schedule ?? ((fn, ms) => void setTimeout(fn, ms));
@@ -409,10 +461,59 @@ function createWhatsAppChannel(config) {
     name: channelName,
     async start(deps) {
       const log = config.logger ?? deps.logger ?? createConsoleLogger();
-      const db = deps.db;
-      const leaseStore = createTursoWaLeaseStore(db);
+      if ((!config.leaseStore || !config.authStore) && !deps.db) {
+        throw new Error(
+          "The WhatsApp channel needs a libsql client for auth state and the session lease: set config.database (config.retriever alone does not open one), or supply both config.leaseStore and config.authStore."
+        );
+      }
+      const leaseStore = config.leaseStore ?? createTursoWaLeaseStore(deps.db);
+      const authStore = config.authStore ?? createTursoWaAuthKV(deps.db);
       senders = deps.senders;
       await loadBaileys2();
+      const leaseDeps = {
+        leaseStore,
+        instanceId,
+        sessions,
+        isStopped: () => stopped,
+        connect,
+        now,
+        staleMs,
+        heartbeatMs,
+        waitMs,
+        schedule,
+        logger: log,
+        onConnectFailed: recoverFromFailedConnect
+      };
+      function nextRetryDelayMs(sessionId) {
+        const failures = failureCounts.get(sessionId) ?? 0;
+        failureCounts.set(sessionId, failures + 1);
+        return reconnectDelayMs(failures);
+      }
+      function attemptConnect(sessionId) {
+        void connect(sessionId).catch((error) => recoverFromFailedConnect(sessionId, error));
+      }
+      function recoverFromFailedConnect(sessionId, error) {
+        if (stopped) return;
+        const handle = claimSession(sessionId, sessions);
+        if (!handle) return;
+        const delay = nextRetryDelayMs(sessionId);
+        log.error(
+          `WhatsApp[${sessionId}]: connect attempt failed, releasing the lease and retrying in ${Math.round(delay / 1e3)}s:`,
+          error
+        );
+        schedule(
+          () => void acquireSessionLease(sessionId, leaseDeps).catch(
+            (retryError) => log.error(`WhatsApp[${sessionId}]: lease re-check failed:`, retryError)
+          ),
+          delay
+        );
+        void shutdownWaSessions(/* @__PURE__ */ new Map([[sessionId, handle]])).catch(
+          (teardownError) => log.warn(
+            `WhatsApp[${sessionId}]: teardown after a failed connect failed:`,
+            teardownError
+          )
+        );
+      }
       async function connect(sessionId) {
         if (stopped || !sessions.has(sessionId)) return;
         const baileys = await loadBaileys2();
@@ -421,8 +522,8 @@ function createWhatsAppChannel(config) {
           initAuthCreds: baileys.initAuthCreds,
           appStateSyncKeyFromObject: (value) => baileys.proto.Message.AppStateSyncKeyData.fromObject(value)
         };
-        const { state, saveCreds } = await useTursoAuthState(
-          db,
+        const { state, saveCreds } = await useAuthState(
+          authStore,
           config.sessionSecret,
           sessionId,
           runtime
@@ -431,7 +532,7 @@ function createWhatsAppChannel(config) {
           log.warn(
             `WhatsApp[${sessionId}]: no paired session found \u2014 pair it first (see docs/channels.md). Re-checking in 60s.`
           );
-          schedule(() => void connect(sessionId).catch(() => void 0), 6e4);
+          schedule(() => attemptConnect(sessionId), 6e4);
           return;
         }
         const { version } = await baileys.fetchLatestBaileysVersion();
@@ -466,6 +567,13 @@ function createWhatsAppChannel(config) {
               sendText: async (chatId, text) => {
                 await sock.sendMessage(chatId, { text });
               },
+              sendMedia: async (chatId, payload) => {
+                const { url, caption } = normalizeWaMediaPayload(payload);
+                await sock.sendMessage(
+                  chatId,
+                  caption !== void 0 ? { image: { url }, caption } : { image: { url } }
+                );
+              },
               sendReaction: async (chatId, messageRef, emoji) => {
                 await sock.sendMessage(chatId, {
                   react: { text: emoji, key: messageRef }
@@ -490,17 +598,11 @@ function createWhatsAppChannel(config) {
               return;
             }
             if (!stopped && sessions.has(sessionId)) {
-              const delay = reconnectDelayMs(failureCounts.get(sessionId) ?? 0);
-              failureCounts.set(sessionId, (failureCounts.get(sessionId) ?? 0) + 1);
+              const delay = nextRetryDelayMs(sessionId);
               log.warn(
                 `WhatsApp[${sessionId}]: connection closed (${statusCode ?? "?"}), reconnecting in ${Math.round(delay / 1e3)}s...`
               );
-              schedule(
-                () => void connect(sessionId).catch(
-                  (error) => log.error(`WhatsApp[${sessionId}]: reconnect failed:`, error)
-                ),
-                delay
-              );
+              schedule(() => attemptConnect(sessionId), delay);
             }
           }
         });
@@ -518,19 +620,9 @@ function createWhatsAppChannel(config) {
         }
       }
       for (const sessionId of sessionIds) {
-        void acquireSessionLease(sessionId, {
-          leaseStore,
-          instanceId,
-          sessions,
-          isStopped: () => stopped,
-          connect,
-          now,
-          staleMs,
-          heartbeatMs,
-          waitMs,
-          schedule,
-          logger: log
-        }).catch((error) => log.error(`WhatsApp[${sessionId}]: failed to start:`, error));
+        void acquireSessionLease(sessionId, leaseDeps).catch(
+          (error) => log.error(`WhatsApp[${sessionId}]: failed to start:`, error)
+        );
       }
     },
     async stop() {
@@ -741,7 +833,8 @@ async function answerOnce({
 async function applyTransformReply(transformReply, input, logger) {
   if (!transformReply) return input.text;
   try {
-    return await transformReply(input);
+    const result = await transformReply(input);
+    return typeof result === "string" ? result : null;
   } catch (error) {
     logger?.error(
       `transformReply threw for channel "${input.channel}"; sending the original reply`,
@@ -803,6 +896,7 @@ async function prepareChat({
   sender,
   rewriteQuery,
   rerankContext,
+  fallbackFn,
   logger
 }) {
   const lastUserMsg = lastUserMessage(messages);
@@ -819,21 +913,39 @@ async function prepareChat({
       logger?.error("rewriteQuery threw; falling back to the original query", error);
     }
   }
-  let ctx = await store.query(query, topK, buckets ?? defaultBuckets(mode));
+  const resolvedBuckets = buckets ?? defaultBuckets(mode);
+  const retrievedChunks = await store.query(query, topK, resolvedBuckets);
+  let ctx = retrievedChunks;
   if (rerankContext) {
     try {
-      const reranked = await rerankContext({ query, chunks: ctx });
+      const reranked = await rerankContext({ query, chunks: [...ctx] });
       if (Array.isArray(reranked) && reranked.every((c) => typeof c === "string")) ctx = reranked;
     } catch (error) {
       logger?.error("rerankContext threw; falling back to the original chunks", error);
     }
   }
+  let fallback;
+  if (ctx.length === 0 && fallbackFn) {
+    try {
+      const guidance = await fallbackFn({
+        query,
+        mode,
+        buckets: resolvedBuckets,
+        sender,
+        retrievedChunks
+      });
+      if (typeof guidance === "string" && guidance.trim()) fallback = guidance.trim();
+    } catch (error) {
+      logger?.error("fallbackFn threw; proceeding without fallback guidance", error);
+    }
+  }
   const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
   const hint = channelHint?.trim();
   const system = [
     prompts.baseSystemRules,
     persona,
     ...hint ? [hint] : [],
+    ...fallback ? [fallback] : [],
     `${label}:
 ${ctx.join("\n\n")}`
   ].join("\n\n");
@@ -841,7 +953,7 @@ ${ctx.join("\n\n")}`
 }
 
 // src/history/compaction.ts
-var DEFAULT_TIMEOUT_MS = 8e3;
+var COMPACTION_TIMEOUT_MS = 8e3;
 var LOAD_ALL = Number.MAX_SAFE_INTEGER;
 var SUMMARY_PREFIX = "Summary of earlier conversation: ";
 function defaultSummarize(client, model) {
@@ -869,7 +981,7 @@ function createHistoryCompactor(deps, options) {
     throw new Error(`Invalid history compaction keep: ${keep}`);
   }
   const summarize = options.summarize ?? defaultSummarize(deps.client, options.model);
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const timeoutMs = options.timeoutMs ?? COMPACTION_TIMEOUT_MS;
   return {
     async maybeCompact(store, conversationId) {
       const turns = await store.load(conversationId, LOAD_ALL);
@@ -910,6 +1022,16 @@ function createHistoryCompactor(deps, options) {
 }
 
 // src/channels/pipeline.ts
+function resolveBrainHooks(config, fallback) {
+  return {
+    answerFn: config.answerFn ?? fallback?.answerFn,
+    bucketsFor: config.bucketsFor ?? fallback?.bucketsFor,
+    rewriteQuery: config.rewriteQuery ?? fallback?.rewriteQuery,
+    rerankContext: config.rerankContext ?? fallback?.rerankContext,
+    fallbackFn: config.fallbackFn ?? fallback?.fallbackFn,
+    transformReply: config.transformReply ?? fallback?.transformReply
+  };
+}
 var DEFAULT_HISTORY_LIMIT = 20;
 var DEFAULT_GROUP_RATE_LIMIT = { max: 30, windowMs: 60 * 60 * 1e3 };
 var DEFAULT_DM_RATE_LIMIT = { max: 20, windowMs: 60 * 60 * 1e3 };
@@ -994,6 +1116,7 @@ function createInboundPipeline(deps, config) {
       sender,
       rewriteQuery: config.rewriteQuery,
       rerankContext: config.rerankContext,
+      fallbackFn: config.fallbackFn,
       logger: config.logger
     });
     const { content: produced } = await answerOnce({
@@ -1129,13 +1252,9 @@ function createWhatsAppInboundHandler(config) {
     { client: config.client, store: config.store, prompts: config.prompts },
     {
       channel: "whatsapp",
-      answerFn: config.answerFn,
-      bucketsFor: config.bucketsFor,
-      rewriteQuery: config.rewriteQuery,
-      rerankContext: config.rerankContext,
-      transformReply: config.transformReply,
+      ...resolveBrainHooks(config, config.serverConfig),
       model: config.model,
-      channelHint: config.channelHint,
+      channelHint: config.channelHint ?? "Channel: WhatsApp.",
       personaResolver: personaResolver ? ({ sender, text }) => personaResolver({ senderPhone: sender, text }) : void 0,
       history: config.history,
       allowedChats,
@@ -1296,6 +1415,7 @@ function createWhatsAppMessageRouter(config) {
   LEASE_WAIT_MS,
   acquireSessionLease,
   canAcquireLease,
+  createTursoWaAuthKV,
   createTursoWaLeaseStore,
   createWhatsAppChannel,
   createWhatsAppImageHandler,
@@ -1311,11 +1431,13 @@ function createWhatsAppMessageRouter(config) {
   jidsMatch,
   loadBaileys,
   messageContext,
+  normalizeWaMediaPayload,
   reconnectDelayMs,
   resolveWaMessage,
   senderNameFor,
   senderPhoneFor,
   shutdownWaSessions,
   stripOwnMentions,
+  useAuthState,
   useTursoAuthState
 });