@diegoaltoworks/chatter 0.61.0 → 0.62.0

package/dist/channels/matrix/index.js

@@ -20,12 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/channels/matrix/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_MAX_MEDIA_BYTES: () => DEFAULT_MAX_MEDIA_BYTES,
   MAX_TRACKED_SENT_EVENTS: () => MAX_TRACKED_SENT_EVENTS,
   MatrixApiError: () => MatrixApiError,
   createMatrixApi: () => createMatrixApi,
   createMatrixChannel: () => createMatrixChannel,
   createMatrixSender: () => createMatrixSender,
   createMatrixSyncHandler: () => createMatrixSyncHandler,
+  directInviteFrom: () => directInviteFrom,
+  directMappingFromEvents: () => directMappingFromEvents,
+  directMappingRooms: () => directMappingRooms,
   directRoomIds: () => directRoomIds,
   isReplyToBot: () => isReplyToBot,
   matrixSenderKey: () => matrixSenderKey,
@@ -36,7 +40,9 @@ __export(index_exports, {
   retryDelayMs: () => retryDelayMs,
   runMatrixSyncLoop: () => runMatrixSyncLoop,
   syncBackoffMs: () => syncBackoffMs,
-  toChannelMessage: () => toChannelMessage
+  toChannelMessage: () => toChannelMessage,
+  toDirectMapping: () => toDirectMapping,
+  withDirectRoom: () => withDirectRoom
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -57,6 +63,7 @@ function redactToken(text, token) {
   if (!token) return text;
   return text.split(token).join("***");
 }
+var DEFAULT_MAX_MEDIA_BYTES = 25 * 1024 * 1024;
 var MEDIA_MSGTYPE = {
   image: "m.image",
   file: "m.file",
@@ -86,6 +93,55 @@ function toMediaRequest(payload) {
   }
   return { kind, url: media.url, caption: media.caption, filename: media.filename };
 }
+function assertHttpsMediaUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new TypeError(
+      `Matrix sendMedia url must be an mxc:// URI or an https URL - could not parse "${url}"`
+    );
+  }
+  if (parsed.protocol !== "https:") {
+    throw new TypeError(
+      `Matrix sendMedia url must be an mxc:// URI or an https URL - got "${parsed.protocol}"`
+    );
+  }
+}
+async function readCappedBytes(response, maxBytes) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    throw new Error(`media source declares ${declared} bytes, over the ${maxBytes} byte cap`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const bytes2 = new Uint8Array(await response.arrayBuffer());
+    if (bytes2.byteLength > maxBytes) {
+      throw new Error(`media source is ${bytes2.byteLength} bytes, over the ${maxBytes} byte cap`);
+    }
+    return bytes2;
+  }
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      throw new Error(`media source exceeds the ${maxBytes} byte cap`);
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
 function createMatrixApi(config) {
   const token = config.accessToken;
   if (!token.trim()) throw new Error("Matrix accessToken is required (e.g. MATRIX_ACCESS_TOKEN)");
@@ -93,6 +149,7 @@ function createMatrixApi(config) {
   if (!homeserverUrl)
     throw new Error("Matrix homeserverUrl is required (e.g. https://matrix.example.org)");
   const doFetch = config.fetch ?? globalThis.fetch;
+  const maxMediaBytes = config.maxMediaBytes ?? DEFAULT_MAX_MEDIA_BYTES;
   async function call(method, path, options) {
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(options?.query ?? {})) {
@@ -186,13 +243,14 @@ function createMatrixApi(config) {
     const media = toMediaRequest(payload);
     let contentUri = media.url;
     if (!contentUri.startsWith("mxc://")) {
+      assertHttpsMediaUrl(media.url);
       let bytes;
       let contentType = "application/octet-stream";
       try {
         const fetched = await doFetch(media.url);
         if (!fetched.ok) throw new Error(`fetching media source returned HTTP ${fetched.status}`);
         contentType = fetched.headers.get("content-type") ?? contentType;
-        bytes = new Uint8Array(await fetched.arrayBuffer());
+        bytes = await readCappedBytes(fetched, maxMediaBytes);
       } catch (error) {
         throw new MatrixApiError(`could not fetch media source for upload: ${errorText(error)}`);
       }
@@ -244,6 +302,13 @@ function createMatrixApi(config) {
         if (error instanceof MatrixApiError && error.errcode === "M_NOT_FOUND") return void 0;
         throw error;
       }
+    },
+    async setAccountData(userId, type, content) {
+      await call(
+        "PUT",
+        `/_matrix/client/v3/user/${encodeURIComponent(userId)}/account_data/${encodeURIComponent(type)}`,
+        { body: content }
+      );
     }
   };
 }
@@ -336,7 +401,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`,
@@ -398,6 +464,7 @@ async function prepareChat({
   sender,
   rewriteQuery,
   rerankContext,
+  fallbackFn,
   logger
 }) {
   const lastUserMsg = lastUserMessage(messages);
@@ -414,21 +481,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");
@@ -436,7 +521,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) {
@@ -464,7 +549,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);
@@ -555,6 +640,16 @@ function underReplyRateLimit(msg, limiters) {
 }
 
 // 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 };
@@ -639,6 +734,7 @@ function createInboundPipeline(deps, config) {
       sender,
       rewriteQuery: config.rewriteQuery,
       rerankContext: config.rerankContext,
+      fallbackFn: config.fallbackFn,
       logger: config.logger
     });
     const { content: produced } = await answerOnce({
@@ -675,6 +771,14 @@ function createInboundPipeline(deps, config) {
   };
 }
 
+// src/channels/polling.ts
+function defaultSleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer === "object" && "unref" in timer) timer.unref();
+  });
+}
+
 // src/channels/matrix/updates.ts
 function messageText(content) {
   return content.body ?? "";
@@ -710,23 +814,44 @@ function recordSentEventId(sentEventIds, eventId) {
     if (oldest !== void 0) sentEventIds.delete(oldest);
   }
 }
-function directRoomIds(accountDataEvents) {
+function toDirectMapping(content) {
+  const mapping = {};
+  for (const [peer, value] of Object.entries(content ?? {})) {
+    if (!Array.isArray(value)) continue;
+    const rooms = value.filter((roomId) => typeof roomId === "string");
+    if (rooms.length > 0) mapping[peer] = rooms;
+  }
+  return mapping;
+}
+function directMappingRooms(mapping) {
+  return new Set(Object.values(mapping).flat());
+}
+function directMappingFromEvents(accountDataEvents) {
   const direct = accountDataEvents.find((event) => event.type === "m.direct");
-  const mapping = direct?.content ?? {};
-  const rooms = /* @__PURE__ */ new Set();
-  for (const value of Object.values(mapping)) {
-    if (Array.isArray(value)) {
-      for (const roomId of value) {
-        if (typeof roomId === "string") rooms.add(roomId);
-      }
-    }
+  return direct ? toDirectMapping(direct.content) : void 0;
+}
+function directRoomIds(accountDataEvents) {
+  return directMappingRooms(directMappingFromEvents(accountDataEvents) ?? {});
+}
+function withDirectRoom(mapping, peer, roomId) {
+  const existing = mapping[peer] ?? [];
+  if (existing.includes(roomId)) return void 0;
+  return { ...mapping, [peer]: [...existing, roomId] };
+}
+function directInviteFrom(room, me) {
+  for (const event of room.invite_state?.events ?? []) {
+    if (event.type !== "m.room.member" || event.state_key !== me.userId) continue;
+    const content = event.content ?? {};
+    if (content.membership !== "invite") continue;
+    if (content.is_direct === true) return event.sender;
   }
-  return rooms;
+  return void 0;
 }
 function toChannelMessage(roomId, event, me, directRooms, sentEventIds) {
   if (event.type !== "m.room.message") return void 0;
   const content = event.content;
   if (!content.msgtype) return void 0;
+  if (content["m.relates_to"]?.rel_type === "m.replace") return void 0;
   return {
     chatId: roomId,
     senderId: event.sender,
@@ -755,19 +880,44 @@ function createMatrixSyncHandler(deps) {
   const { api, me, pipeline, allowedChats, sentEventIds, logger, label } = deps;
   const autoJoin = deps.autoJoin ?? true;
   const loggedUnallowedChats = /* @__PURE__ */ new Set();
-  let directRooms = new Set(deps.initialDirectRooms ?? []);
+  const loggedDeclinedInvites = /* @__PURE__ */ new Set();
+  let directMapping = { ...deps.initialDirect ?? {} };
+  let directRooms = directMappingRooms(directMapping);
+  async function rememberDirectRoom(peer, roomId) {
+    directRooms.add(roomId);
+    const merged = withDirectRoom(directMapping, peer, roomId);
+    if (!merged) return;
+    directMapping = merged;
+    try {
+      await api.setAccountData(me.userId, "m.direct", directMapping);
+    } catch (error) {
+      logger.warn(`${label}: could not record ${roomId} in m.direct:`, error);
+    }
+  }
   return async function handleSync(response) {
-    if (response.account_data?.events?.some((event) => event.type === "m.direct")) {
-      directRooms = directRoomIds(response.account_data.events);
+    const syncedDirect = directMappingFromEvents(response.account_data?.events ?? []);
+    if (syncedDirect) {
+      directMapping = syncedDirect;
+      directRooms = directMappingRooms(directMapping);
     }
     if (autoJoin) {
-      for (const roomId of Object.keys(response.rooms?.invite ?? {})) {
+      for (const [roomId, room] of Object.entries(response.rooms?.invite ?? {})) {
+        if (allowedChats.length > 0 && !allowedChats.includes(roomId)) {
+          if (!loggedDeclinedInvites.has(roomId)) {
+            loggedDeclinedInvites.add(roomId);
+            logger.warn(`${label}: left invite to ${roomId} pending - not in allowedChats`);
+          }
+          continue;
+        }
+        const directInviter = directInviteFrom(room, me);
         try {
           await api.joinRoom(roomId);
           logger.info(`${label}: joined ${roomId} (accepted invite)`);
         } catch (error) {
           logger.warn(`${label}: failed to join ${roomId}:`, error);
+          continue;
         }
+        if (directInviter) await rememberDirectRoom(directInviter, roomId);
       }
     }
     for (const [roomId, room] of Object.entries(response.rooms?.join ?? {})) {
@@ -816,11 +966,16 @@ function createMatrixSender(api, sentEventIds) {
   };
 }
 
+// src/channels/backoff.ts
+function exponentialBackoffMs(baseMs, maxMs, n) {
+  return Math.min(baseMs * 2 ** Math.max(0, Math.min(n, 20)), maxMs);
+}
+
 // src/channels/matrix/sync.ts
 var BASE_DELAY_MS = 1e3;
 var MAX_DELAY_MS = 6e4;
 function syncBackoffMs(failures) {
-  return Math.min(BASE_DELAY_MS * 2 ** Math.min(failures, 20), MAX_DELAY_MS);
+  return exponentialBackoffMs(BASE_DELAY_MS, MAX_DELAY_MS, failures);
 }
 function retryDelayMs(error, failures) {
   const retryAfterMs = error instanceof MatrixApiError ? error.retryAfterMs : void 0;
@@ -844,9 +999,9 @@ async function runMatrixSyncLoop(deps) {
       continue;
     }
     failures = 0;
+    if (deps.isStopped()) break;
     since = response.next_batch;
     deps.onSince?.(since);
-    if (deps.isStopped()) break;
     try {
       await deps.handleSync(response);
     } catch (error) {
@@ -858,12 +1013,6 @@ async function runMatrixSyncLoop(deps) {
 
 // src/channels/matrix/channel.ts
 var DEFAULT_SYNC_TIMEOUT_MS = 3e4;
-function defaultSleep(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    if (typeof timer === "object" && "unref" in timer) timer.unref();
-  });
-}
 function createMatrixChannel(config) {
   const channelName = config.name ?? "matrix";
   const allowedChats = config.allowedChats ?? [];
@@ -871,6 +1020,7 @@ function createMatrixChannel(config) {
   const syncTimeoutMs = config.syncTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS;
   let stopped = false;
   let registered = false;
+  let abort;
   let senders;
   const sentEventIds = /* @__PURE__ */ new Set();
   return {
@@ -880,14 +1030,15 @@ function createMatrixChannel(config) {
       const api = config.api ?? createMatrixApi({
         homeserverUrl: config.homeserverUrl,
         accessToken: config.accessToken,
-        fetch: config.fetch
+        fetch: config.fetch,
+        maxMediaBytes: config.maxMediaBytes
       });
       const me = await api.whoami();
       const label = `Matrix[${me.userId}]`;
-      let initialDirectRooms;
+      let initialDirect;
       try {
         const direct = await api.getAccountData(me.userId, "m.direct");
-        if (direct) initialDirectRooms = directRoomIds([{ type: "m.direct", content: direct }]);
+        if (direct) initialDirect = toDirectMapping(direct);
       } catch (error) {
         log.warn(`${label}: could not load m.direct account data at start:`, error);
       }
@@ -898,11 +1049,7 @@ function createMatrixChannel(config) {
         { client: deps.client, store: deps.store, prompts: deps.prompts },
         {
           channel: channelName,
-          answerFn: config.answerFn ?? deps.config.answerFn,
-          bucketsFor: config.bucketsFor ?? deps.config.bucketsFor,
-          rewriteQuery: config.rewriteQuery ?? deps.config.rewriteQuery,
-          rerankContext: config.rerankContext ?? deps.config.rerankContext,
-          transformReply: config.transformReply ?? deps.config.transformReply,
+          ...resolveBrainHooks(config, deps.config),
           model: config.model,
           channelHint: config.channelHint ?? "Channel: Matrix.",
           personaResolver: config.personaResolver,
@@ -925,12 +1072,14 @@ function createMatrixChannel(config) {
         allowedChats,
         sentEventIds,
         autoJoin: config.autoJoin,
-        initialDirectRooms,
+        initialDirect,
         logger: log,
         label
       });
+      abort = new AbortController();
+      const signal = abort.signal;
       void runMatrixSyncLoop({
-        sync: (since) => api.sync({ since, timeoutMs: syncTimeoutMs }),
+        sync: (since) => api.sync({ since, timeoutMs: syncTimeoutMs, signal }),
         handleSync,
         isStopped: () => stopped,
         sleep,
@@ -943,6 +1092,7 @@ function createMatrixChannel(config) {
     },
     stop() {
       stopped = true;
+      abort?.abort();
       if (registered) {
         senders?.unregister(channelName);
         registered = false;
@@ -952,12 +1102,16 @@ function createMatrixChannel(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_MAX_MEDIA_BYTES,
   MAX_TRACKED_SENT_EVENTS,
   MatrixApiError,
   createMatrixApi,
   createMatrixChannel,
   createMatrixSender,
   createMatrixSyncHandler,
+  directInviteFrom,
+  directMappingFromEvents,
+  directMappingRooms,
   directRoomIds,
   isReplyToBot,
   matrixSenderKey,
@@ -968,5 +1122,7 @@ function createMatrixChannel(config) {
   retryDelayMs,
   runMatrixSyncLoop,
   syncBackoffMs,
-  toChannelMessage
+  toChannelMessage,
+  toDirectMapping,
+  withDirectRoom
 });