@diegoaltoworks/chatter 0.58.0 → 0.60.0

package/dist/channels/telegram/index.js

@@ -25,6 +25,9 @@ __export(index_exports, {
   TelegramApiError: () => TelegramApiError,
   createTelegramApi: () => createTelegramApi,
   createTelegramChannel: () => createTelegramChannel,
+  createTelegramSender: () => createTelegramSender,
+  createTelegramUpdateHandler: () => createTelegramUpdateHandler,
+  createTelegramWebhookRoute: () => createTelegramWebhookRoute,
   mentionsBot: () => mentionsBot,
   messageEntities: () => messageEntities,
   messageText: () => messageText,
@@ -188,6 +191,17 @@ function createTelegramApi(config) {
         message_id: messageId,
         reaction: [{ type: "emoji", emoji }]
       });
+    },
+    async setWebhook(url, options) {
+      await call("setWebhook", {
+        url,
+        // Only what this channel interprets — see the matching comment on getUpdates.
+        allowed_updates: ["message"],
+        ...options?.secretToken ? { secret_token: options.secretToken } : {}
+      });
+    },
+    async deleteWebhook() {
+      await call("deleteWebhook");
     }
   };
 }
@@ -208,56 +222,6 @@ function createConsoleLogger(level = "info") {
   };
 }
 
-// src/channels/gates.ts
-function matches(re, text) {
-  return new RegExp(re.source, re.flags.replace(/[gy]/g, "")).test(text);
-}
-function isBlockedByAllowlist(msg, config) {
-  return !msg.fromBot && msg.text.trim().length > 0 && !msg.isDirectMessage && config.allowedChats.length > 0 && !config.allowedChats.includes(msg.chatId);
-}
-function decideChannelAction(msg, config) {
-  if (msg.fromBot || !msg.text.trim()) return "ignore";
-  if (!msg.isDirectMessage) {
-    if (isBlockedByAllowlist(msg, config)) return "ignore";
-    if (config.muteRegex && matches(config.muteRegex, msg.text)) return "mute";
-    if (config.unmuteRegex && matches(config.unmuteRegex, msg.text)) return "unmute";
-    if (config.mutedChats.has(msg.chatId)) return "ignore";
-    return msg.mentionsBot || msg.isReplyToBot ? "reply" : "ignore";
-  }
-  return "reply";
-}
-function createSlidingWindowRateLimiter(maxPerWindow, windowMs, now = Date.now) {
-  const log = /* @__PURE__ */ new Map();
-  let lastSweep = now();
-  function sweep(current) {
-    if (current - lastSweep < windowMs) return;
-    lastSweep = current;
-    const cutoff = current - windowMs;
-    for (const [key, entries] of log) {
-      if (!entries.some((t) => t > cutoff)) log.delete(key);
-    }
-  }
-  function allow(key) {
-    const current = now();
-    sweep(current);
-    const cutoff = current - windowMs;
-    const entries = (log.get(key) ?? []).filter((t) => t > cutoff);
-    if (entries.length >= maxPerWindow) {
-      if (entries.length > 0) log.set(key, entries);
-      else log.delete(key);
-      return false;
-    }
-    entries.push(current);
-    log.set(key, entries);
-    return true;
-  }
-  allow.size = () => log.size;
-  return allow;
-}
-function underReplyRateLimit(msg, limiters) {
-  return msg.isDirectMessage ? limiters.dm(msg.chatId) : limiters.group(msg.chatId);
-}
-
 // src/core/guardrails.ts
 function detectLeakage(text) {
   const flags = [
@@ -429,6 +393,125 @@ ${ctx.join("\n\n")}`
   return { system, messages, context: ctx };
 }
 
+// src/history/compaction.ts
+var DEFAULT_TIMEOUT_MS = 8e3;
+var LOAD_ALL = Number.MAX_SAFE_INTEGER;
+var SUMMARY_PREFIX = "Summary of earlier conversation: ";
+function defaultSummarize(client, model) {
+  return async ({ turns }) => {
+    const transcript = turns.map((turn) => `${turn.role}: ${turn.content}`).join("\n");
+    const { content } = await answerOnce({
+      client,
+      system: "Summarize the conversation turns below into a short paragraph a reader would need to continue the conversation. Preserve names, facts, and decisions; drop pleasantries. Reply with the summary only, no preamble.",
+      messages: [{ role: "user", content: transcript }],
+      // No `answerFn`: compaction is an internal chatter operation, not a
+      // chat surface, so it must not conscript a caller's brain hook, which
+      // is shaped to answer the user, not to summarize on the engine's behalf.
+      mode: "public",
+      model
+    });
+    return content;
+  };
+}
+function createHistoryCompactor(deps, options) {
+  const { threshold, keep, logger } = options;
+  if (!Number.isInteger(threshold) || threshold < 1) {
+    throw new Error(`Invalid history compaction threshold: ${threshold}`);
+  }
+  if (!Number.isInteger(keep) || keep < 0 || keep >= threshold) {
+    throw new Error(`Invalid history compaction keep: ${keep}`);
+  }
+  const summarize = options.summarize ?? defaultSummarize(deps.client, options.model);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return {
+    async maybeCompact(store, conversationId) {
+      const turns = await store.load(conversationId, LOAD_ALL);
+      if (turns.length < threshold) return;
+      const older = turns.slice(0, turns.length - keep);
+      let summary;
+      let timer;
+      try {
+        summary = await Promise.race([
+          summarize({ conversationId, turns: older }),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("history compaction timed out")), timeoutMs);
+          })
+        ]);
+      } catch (error) {
+        logger?.error(
+          `history compaction summarize failed for "${conversationId}"; history left untouched`,
+          error
+        );
+        return;
+      } finally {
+        clearTimeout(timer);
+      }
+      const trimmed = summary.trim();
+      if (!trimmed) return;
+      const fresh = await store.load(conversationId, LOAD_ALL);
+      const recent = fresh.slice(older.length);
+      await store.clear(conversationId);
+      await store.append(conversationId, {
+        role: "assistant",
+        content: `${SUMMARY_PREFIX}${trimmed}`
+      });
+      for (const turn of recent) {
+        await store.append(conversationId, turn);
+      }
+    }
+  };
+}
+
+// src/channels/gates.ts
+function matches(re, text) {
+  return new RegExp(re.source, re.flags.replace(/[gy]/g, "")).test(text);
+}
+function isBlockedByAllowlist(msg, config) {
+  return !msg.fromBot && msg.text.trim().length > 0 && !msg.isDirectMessage && config.allowedChats.length > 0 && !config.allowedChats.includes(msg.chatId);
+}
+function decideChannelAction(msg, config) {
+  if (msg.fromBot || !msg.text.trim()) return "ignore";
+  if (!msg.isDirectMessage) {
+    if (isBlockedByAllowlist(msg, config)) return "ignore";
+    if (config.muteRegex && matches(config.muteRegex, msg.text)) return "mute";
+    if (config.unmuteRegex && matches(config.unmuteRegex, msg.text)) return "unmute";
+    if (config.mutedChats.has(msg.chatId)) return "ignore";
+    return msg.mentionsBot || msg.isReplyToBot ? "reply" : "ignore";
+  }
+  return "reply";
+}
+function createSlidingWindowRateLimiter(maxPerWindow, windowMs, now = Date.now) {
+  const log = /* @__PURE__ */ new Map();
+  let lastSweep = now();
+  function sweep(current) {
+    if (current - lastSweep < windowMs) return;
+    lastSweep = current;
+    const cutoff = current - windowMs;
+    for (const [key, entries] of log) {
+      if (!entries.some((t) => t > cutoff)) log.delete(key);
+    }
+  }
+  function allow(key) {
+    const current = now();
+    sweep(current);
+    const cutoff = current - windowMs;
+    const entries = (log.get(key) ?? []).filter((t) => t > cutoff);
+    if (entries.length >= maxPerWindow) {
+      if (entries.length > 0) log.set(key, entries);
+      else log.delete(key);
+      return false;
+    }
+    entries.push(current);
+    log.set(key, entries);
+    return true;
+  }
+  allow.size = () => log.size;
+  return allow;
+}
+function underReplyRateLimit(msg, limiters) {
+  return msg.isDirectMessage ? limiters.dm(msg.chatId) : limiters.group(msg.chatId);
+}
+
 // src/channels/pipeline.ts
 var DEFAULT_HISTORY_LIMIT = 20;
 var DEFAULT_GROUP_RATE_LIMIT = { max: 30, windowMs: 60 * 60 * 1e3 };
@@ -459,6 +542,10 @@ function createInboundPipeline(deps, config) {
   const underGroupRateLimit = createSlidingWindowRateLimiter(group.max, group.windowMs, now);
   const underDmRateLimit = createSlidingWindowRateLimiter(dm.max, dm.windowMs, now);
   const mode = "public";
+  const compactor = config.history?.compaction ? createHistoryCompactor(
+    { client: deps.client },
+    { model: config.model, ...config.history.compaction }
+  ) : void 0;
   return async function handleInboundMessage(msg, turn) {
     const allowedChats = config.allowedChats ?? [];
     const action = decideChannelAction(msg, {
@@ -534,6 +621,14 @@ function createInboundPipeline(deps, config) {
       await config.history?.store.append(conversationId, { role: "assistant", content });
     }
     await turn.reply.sendAnswer(msg.chatId, content);
+    const history = config.history;
+    if (compactor && historyEnabled && history) {
+      try {
+        await compactor.maybeCompact(history.store, conversationId);
+      } catch (error) {
+        config.logger?.error(`history compaction failed for "${conversationId}"`, error);
+      }
+    }
     return { action: "reply", content };
   };
 }
@@ -581,6 +676,41 @@ function telegramSenderKey(senderId) {
   return `tg:${senderId}`;
 }
 
+// src/channels/telegram/handler.ts
+function createTelegramUpdateHandler(deps) {
+  const { api, me, pipeline, allowedChats, logger, label } = deps;
+  const loggedUnallowedChats = /* @__PURE__ */ new Set();
+  return async function handleUpdate(update) {
+    const message = update.message;
+    const msg = toChannelMessage(update, me);
+    if (!msg || !message) return;
+    if (isBlockedByAllowlist(msg, { allowedChats })) {
+      if (!loggedUnallowedChats.has(msg.chatId)) {
+        loggedUnallowedChats.add(msg.chatId);
+        logger.warn(`${label}: skipped chat ${msg.chatId} - not in allowedChats`);
+      }
+    }
+    const reply = {
+      // Threaded onto the incoming message: in a busy group an untethered
+      // answer reads as a non-sequitur.
+      sendAnswer: (chatId, text) => api.sendMessage(chatId, text, { replyToMessageId: message.message_id }),
+      sendGateReply: (chatId, text) => api.sendMessage(chatId, text)
+    };
+    await pipeline(msg, {
+      reply,
+      conversationId: msg.chatId,
+      sender: telegramSenderKey(msg.senderId)
+    });
+  };
+}
+function createTelegramSender(api) {
+  return {
+    sendText: (chatId, text) => api.sendMessage(chatId, text),
+    sendMedia: (chatId, payload) => api.sendMedia(chatId, payload),
+    sendReaction: (chatId, messageRef, emoji) => api.setMessageReaction(chatId, Number(messageRef), emoji)
+  };
+}
+
 // src/channels/telegram/poll.ts
 var BASE_DELAY_MS = 1e3;
 var MAX_DELAY_MS = 6e4;
@@ -651,12 +781,7 @@ function createTelegramChannel(config) {
       });
       const me = await api.getMe();
       const label = `Telegram[${me.username ?? me.id}]`;
-      const sender = {
-        sendText: (chatId, text) => api.sendMessage(chatId, text),
-        sendMedia: (chatId, payload) => api.sendMedia(chatId, payload),
-        sendReaction: (chatId, messageRef, emoji) => api.setMessageReaction(chatId, Number(messageRef), emoji)
-      };
-      deps.senders.register(channelName, sender);
+      deps.senders.register(channelName, createTelegramSender(api));
       senders = deps.senders;
       registered = true;
       const pipeline = createInboundPipeline(
@@ -683,29 +808,14 @@ function createTelegramChannel(config) {
           logger: log
         }
       );
-      const loggedUnallowedChats = /* @__PURE__ */ new Set();
-      async function handleUpdate(update) {
-        const message = update.message;
-        const msg = toChannelMessage(update, me);
-        if (!msg || !message) return;
-        if (isBlockedByAllowlist(msg, { allowedChats })) {
-          if (!loggedUnallowedChats.has(msg.chatId)) {
-            loggedUnallowedChats.add(msg.chatId);
-            log.warn(`${label}: skipped chat ${msg.chatId} - not in allowedChats`);
-          }
-        }
-        const reply = {
-          // Threaded onto the incoming message: in a busy group an untethered
-          // answer reads as a non-sequitur.
-          sendAnswer: (chatId, text) => api.sendMessage(chatId, text, { replyToMessageId: message.message_id }),
-          sendGateReply: (chatId, text) => api.sendMessage(chatId, text)
-        };
-        await pipeline(msg, {
-          reply,
-          conversationId: msg.chatId,
-          sender: telegramSenderKey(msg.senderId)
-        });
-      }
+      const handleUpdate = createTelegramUpdateHandler({
+        api,
+        me,
+        pipeline,
+        allowedChats,
+        logger: log,
+        label
+      });
       abort = new AbortController();
       const signal = abort.signal;
       void runLongPoll({
@@ -730,6 +840,196 @@ function createTelegramChannel(config) {
     }
   };
 }
+
+// src/channels/telegram/webhook.ts
+var import_node_crypto = require("node:crypto");
+
+// node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  res;
+  status;
+  /**
+   * Creates an instance of `HTTPException`.
+   * @param status - HTTP status code for the exception. Defaults to 500.
+   * @param options - Additional options for the exception.
+   */
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  /**
+   * Returns the response object associated with the exception.
+   * If a response object is not provided, a new response is created with the error message and status code.
+   * @returns The response object.
+   */
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
+  }
+};
+
+// node_modules/hono/dist/middleware/body-limit/index.js
+var ERROR_MESSAGE = "Payload Too Large";
+var bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+    const hasContentLength = c.req.raw.headers.has("content-length");
+    if (hasContentLength && !hasTransferEncoding) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const chunks = [];
+    const rawReader = c.req.raw.body.getReader();
+    for (; ; ) {
+      const { done, value } = await rawReader.read();
+      if (done) {
+        break;
+      }
+      size += value.length;
+      if (size > maxSize) {
+        return onError(c);
+      }
+      chunks.push(value);
+    }
+    const requestInit = {
+      body: new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        }
+      }),
+      duplex: "half"
+    };
+    c.req.raw = new Request(c.req.raw, requestInit);
+    return next();
+  };
+};
+
+// src/middleware/bodyLimit.ts
+var DEFAULT_MAX_REQUEST_BYTES = 262144;
+function chatBodyLimit(maxSize = DEFAULT_MAX_REQUEST_BYTES, toError = (message) => ({ error: message })) {
+  return bodyLimit({
+    maxSize,
+    onError: (c) => c.json(toError("Request body too large"), 413)
+  });
+}
+
+// src/channels/telegram/webhook.ts
+var SECRET_TOKEN_HEADER = "x-telegram-bot-api-secret-token";
+function secureCompare(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return bufA.length === bufB.length && (0, import_node_crypto.timingSafeEqual)(bufA, bufB);
+}
+var SECRET_TOKEN_PATTERN = /^[A-Za-z0-9_-]{1,256}$/;
+function createTelegramWebhookRoute(config) {
+  const webhookSecret = config.webhookSecret;
+  if (!webhookSecret?.trim()) {
+    throw new Error("Telegram webhook requires webhookSecret (it fails closed without one)");
+  }
+  if (!SECRET_TOKEN_PATTERN.test(webhookSecret)) {
+    throw new Error(
+      "Telegram webhookSecret must match /^[A-Za-z0-9_-]{1,256}$/ (Telegram's own secret_token charset)"
+    );
+  }
+  const channelName = config.name ?? "telegram";
+  const allowedChats = config.allowedChats ?? [];
+  const path = config.path ?? "/webhooks/telegram";
+  return async (app, deps) => {
+    const log = config.logger ?? deps.logger ?? createConsoleLogger();
+    const api = config.api ?? createTelegramApi({
+      botToken: config.botToken,
+      fetch: config.fetch,
+      baseUrl: config.apiBaseUrl
+    });
+    const me = await api.getMe();
+    const label = `Telegram[${me.username ?? me.id}] (webhook)`;
+    deps.senders.register(channelName, createTelegramSender(api));
+    const pipeline = createInboundPipeline(
+      { 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,
+        model: config.model,
+        channelHint: config.channelHint ?? "Channel: Telegram.",
+        personaResolver: config.personaResolver,
+        history: config.history,
+        allowedChats,
+        muteRegex: config.muteRegex,
+        unmuteRegex: config.unmuteRegex,
+        muteReply: config.muteReply,
+        unmuteReply: config.unmuteReply,
+        dmRateLimit: config.dmRateLimit,
+        groupRateLimit: config.groupRateLimit,
+        now: config.now,
+        logger: log
+      }
+    );
+    const handleUpdate = createTelegramUpdateHandler({
+      api,
+      me,
+      pipeline,
+      allowedChats,
+      logger: log,
+      label
+    });
+    app.post(
+      path,
+      chatBodyLimit(deps.config.server?.maxRequestBytes),
+      // Reject oversized bodies first
+      async (c) => {
+        const provided = c.req.header(SECRET_TOKEN_HEADER);
+        if (!provided || !secureCompare(provided, webhookSecret)) {
+          log.warn(`${label}: rejected webhook POST - missing or invalid secret token`);
+          return c.text("", 403);
+        }
+        let body;
+        try {
+          body = await c.req.json();
+        } catch {
+          return c.text("", 400);
+        }
+        if (typeof body !== "object" || body === null) {
+          return c.text("", 400);
+        }
+        const update = body;
+        try {
+          await handleUpdate(update);
+        } catch (error) {
+          log.warn(`${label}: update handling failed:`, error);
+        }
+        return c.text("", 200);
+      }
+    );
+    log.info(`${label}: webhook mounted at ${path} as @${me.username ?? me.id}`);
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TELEGRAM_API_BASE,
@@ -737,6 +1037,9 @@ function createTelegramChannel(config) {
   TelegramApiError,
   createTelegramApi,
   createTelegramChannel,
+  createTelegramSender,
+  createTelegramUpdateHandler,
+  createTelegramWebhookRoute,
   mentionsBot,
   messageEntities,
   messageText,