@diegoaltoworks/chatter 0.54.2 → 0.56.0

package/dist/channels/telegram/index.js

@@ -0,0 +1,710 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/channels/telegram/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TELEGRAM_API_BASE: () => TELEGRAM_API_BASE,
+  TELEGRAM_TEXT_LIMIT: () => TELEGRAM_TEXT_LIMIT,
+  TelegramApiError: () => TelegramApiError,
+  createTelegramApi: () => createTelegramApi,
+  createTelegramChannel: () => createTelegramChannel,
+  mentionsBot: () => mentionsBot,
+  messageEntities: () => messageEntities,
+  messageText: () => messageText,
+  nextOffset: () => nextOffset,
+  pollBackoffMs: () => pollBackoffMs,
+  redactToken: () => redactToken,
+  retryDelayMs: () => retryDelayMs,
+  runLongPoll: () => runLongPoll,
+  splitTelegramText: () => splitTelegramText,
+  telegramSenderKey: () => telegramSenderKey,
+  toChannelMessage: () => toChannelMessage,
+  toTelegramMediaRequest: () => toTelegramMediaRequest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/channels/telegram/api.ts
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_TEXT_LIMIT = 4096;
+var TelegramApiError = class extends Error {
+  errorCode;
+  retryAfterMs;
+  constructor(message, options) {
+    super(message);
+    this.name = "TelegramApiError";
+    this.errorCode = options?.errorCode;
+    this.retryAfterMs = options?.retryAfterMs;
+  }
+};
+function redactToken(text, token) {
+  if (!token) return text;
+  return text.split(token).join("***");
+}
+function splitTelegramText(text, limit = TELEGRAM_TEXT_LIMIT) {
+  if (!text.trim()) return [];
+  if (text.length <= limit) return [text];
+  const chunks = [];
+  let rest = text;
+  while (rest.length > limit) {
+    const window = rest.slice(0, limit);
+    const boundary = ["\n\n", "\n", " "].map((separator) => window.lastIndexOf(separator)).find((index) => index > 0);
+    const cut = boundary ?? limit;
+    chunks.push(rest.slice(0, cut).trimEnd());
+    rest = rest.slice(cut).trimStart();
+  }
+  if (rest) chunks.push(rest);
+  return chunks;
+}
+var MEDIA_METHODS = {
+  photo: { method: "sendPhoto", field: "photo" },
+  document: { method: "sendDocument", field: "document" },
+  video: { method: "sendVideo", field: "video" },
+  audio: { method: "sendAudio", field: "audio" }
+};
+function toTelegramMediaRequest(chatId, payload) {
+  const media = typeof payload === "string" ? { url: payload } : payload;
+  if (!media || typeof media !== "object" || typeof media.url !== "string" || !media.url) {
+    throw new TypeError(
+      "Telegram sendMedia payload must be a URL string or { url, kind?, caption? } \u2014 got: " + typeof payload
+    );
+  }
+  const kind = media.kind ?? "photo";
+  const target = MEDIA_METHODS[kind];
+  if (!target) {
+    throw new TypeError(
+      `Telegram sendMedia kind must be one of ${Object.keys(MEDIA_METHODS).join(", ")} \u2014 got "${kind}"`
+    );
+  }
+  return {
+    method: target.method,
+    body: {
+      chat_id: chatId,
+      [target.field]: media.url,
+      ...media.caption ? { caption: media.caption } : {}
+    }
+  };
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createTelegramApi(config) {
+  const token = config.botToken;
+  if (!token.trim()) throw new Error("Telegram botToken is required (e.g. TELEGRAM_BOT_TOKEN)");
+  const baseUrl = (config.baseUrl ?? TELEGRAM_API_BASE).replace(/\/+$/, "");
+  const doFetch = config.fetch ?? globalThis.fetch;
+  async function call(method, body, signal) {
+    let response;
+    try {
+      response = await doFetch(`${baseUrl}/bot${token}/${method}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body ?? {}),
+        signal
+      });
+    } catch (error) {
+      throw new TelegramApiError(
+        `${method} request failed: ${redactToken(errorText(error), token)}`
+      );
+    }
+    let envelope;
+    try {
+      envelope = await response.json();
+    } catch {
+      throw new TelegramApiError(
+        `${method} returned a non-JSON response (HTTP ${response.status})`
+      );
+    }
+    if (!envelope?.ok) {
+      const retryAfter = envelope?.parameters?.retry_after;
+      throw new TelegramApiError(
+        `${method} failed (HTTP ${response.status}): ${redactToken(envelope?.description ?? "unknown error", token)}`,
+        {
+          errorCode: envelope?.error_code,
+          retryAfterMs: typeof retryAfter === "number" ? retryAfter * 1e3 : void 0
+        }
+      );
+    }
+    return envelope.result;
+  }
+  return {
+    call,
+    getMe: () => call("getMe"),
+    getUpdates: ({ offset, timeoutSeconds, signal }) => call(
+      "getUpdates",
+      {
+        ...offset === void 0 ? {} : { offset },
+        timeout: timeoutSeconds,
+        // Only what this channel interprets: asking for every update type
+        // would have Telegram queue edits, reactions and channel posts this
+        // channel then silently discards.
+        allowed_updates: ["message"]
+      },
+      signal
+    ),
+    async sendMessage(chatId, text, options) {
+      const chunks = splitTelegramText(text);
+      for (const [index, chunk] of chunks.entries()) {
+        await call("sendMessage", {
+          chat_id: chatId,
+          text: chunk,
+          // Threading belongs on the first chunk only — every chunk quoting
+          // the same incoming message reads as several separate replies.
+          ...index === 0 && options?.replyToMessageId ? {
+            reply_parameters: {
+              message_id: options.replyToMessageId,
+              // The quoted message can be gone by the time we answer
+              // (deleted, or an old message in a cleared chat); sending
+              // unthreaded beats failing the whole reply.
+              allow_sending_without_reply: true
+            }
+          } : {}
+        });
+      }
+    },
+    async sendMedia(chatId, payload) {
+      const { method, body } = toTelegramMediaRequest(chatId, payload);
+      await call(method, body);
+    },
+    async setMessageReaction(chatId, messageId, emoji) {
+      await call("setMessageReaction", {
+        chat_id: chatId,
+        message_id: messageId,
+        reaction: [{ type: "emoji", emoji }]
+      });
+    }
+  };
+}
+
+// src/core/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createConsoleLogger(level = "info") {
+  const threshold = LEVEL_ORDER[level];
+  const write = (at) => (...args) => {
+    if (LEVEL_ORDER[at] < threshold) return;
+    console.error(`[${at}]`, ...args);
+  };
+  return {
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error")
+  };
+}
+
+// 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 = [
+    /system prompt/i,
+    /hidden instruction/i,
+    /here (are|is) (my|the) rules/i,
+    /BEGIN SYSTEM PROMPT/i,
+    /tool instructions/i
+  ];
+  return flags.some((rx) => rx.test(text));
+}
+function scrubOutput(text) {
+  return text.replace(/sk-[A-Za-z0-9]{15,}/g, "[REDACTED]").replace(/AIza[0-9A-Za-z_-]{30,}/g, "[REDACTED]");
+}
+function guardOutput(text) {
+  if (detectLeakage(text)) {
+    return "Sorry, I can't share internal instructions. How else can I help?";
+  }
+  return scrubOutput(text);
+}
+
+// src/core/llm.ts
+var DEFAULT_MODEL = "gpt-4o";
+async function completeOnce({
+  client,
+  system,
+  messages,
+  temperature = 0.2,
+  model = DEFAULT_MODEL
+}) {
+  const res = await client.chat.completions.create({
+    model,
+    temperature,
+    messages: [{ role: "system", content: system }, ...messages]
+  });
+  const text = res.choices[0]?.message?.content ?? "";
+  return {
+    content: guardOutput(text),
+    usage: res.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+
+// src/core/answer.ts
+var noUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+async function runAnswerFn(answerFn, { system, messages, mode, sender, conversationId }) {
+  const result = await answerFn({ system, messages, mode, sender, conversationId });
+  const raw = typeof result === "string" ? result : result?.content;
+  const usage = typeof result === "string" ? void 0 : result?.usage;
+  return {
+    content: guardOutput(typeof raw === "string" ? raw : ""),
+    usage: usage ?? noUsage()
+  };
+}
+async function answerOnce({
+  answerFn,
+  client,
+  system,
+  messages,
+  mode,
+  sender,
+  conversationId,
+  temperature,
+  model
+}) {
+  if (answerFn) {
+    return runAnswerFn(answerFn, { system, messages, mode, sender, conversationId });
+  }
+  return completeOnce({ client, system, messages, temperature, model });
+}
+async function applyTransformReply(transformReply, input, logger) {
+  if (!transformReply) return input.text;
+  try {
+    return await transformReply(input);
+  } catch (error) {
+    logger?.error(
+      `transformReply threw for channel "${input.channel}"; sending the original reply`,
+      error
+    );
+    return input.text;
+  }
+}
+
+// src/core/buckets.ts
+function defaultBuckets(mode) {
+  return ["base", mode];
+}
+function isIdentified(sender) {
+  return typeof sender === "string" && sender.trim().length > 0;
+}
+function normalize(buckets) {
+  const out = [];
+  for (const raw of buckets) {
+    if (typeof raw !== "string") continue;
+    const bucket = raw.trim();
+    if (bucket && !out.includes(bucket)) out.push(bucket);
+  }
+  return out;
+}
+async function resolveBuckets({
+  mode,
+  sender,
+  bucketsFor
+}) {
+  if (!bucketsFor) return void 0;
+  const identified = isIdentified(sender);
+  const requested = await bucketsFor(identified ? { mode, sender } : { mode });
+  if (!Array.isArray(requested)) return void 0;
+  const cleaned = normalize(requested);
+  if (identified) return cleaned;
+  const ceiling = new Set(defaultBuckets(mode));
+  return cleaned.filter((bucket) => ceiling.has(bucket));
+}
+
+// src/core/messages.ts
+function lastUserMessage(messages) {
+  return [...messages].reverse().find((m) => m.role === "user");
+}
+
+// src/core/pipeline.ts
+var MODE_SETTINGS = {
+  public: { topK: 6, label: "Context" },
+  private: { topK: 8, label: "Internal Context" }
+};
+async function prepareChat({
+  store,
+  prompts,
+  mode,
+  messages,
+  personaLayer,
+  channelHint,
+  buckets
+}) {
+  const lastUserMsg = lastUserMessage(messages);
+  if (!lastUserMsg) {
+    throw new Error("no user message found in conversation");
+  }
+  const { topK, label } = MODE_SETTINGS[mode];
+  const ctx = await store.query(lastUserMsg.content, topK, buckets ?? defaultBuckets(mode));
+  const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
+  const hint = channelHint?.trim();
+  const system = [
+    prompts.baseSystemRules,
+    persona,
+    ...hint ? [hint] : [],
+    `${label}:
+${ctx.join("\n\n")}`
+  ].join("\n\n");
+  return { system, messages, context: ctx };
+}
+
+// src/channels/pipeline.ts
+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 };
+async function resolvePersonaLayer(config, ctx) {
+  if (!config.personaResolver) return void 0;
+  try {
+    return await config.personaResolver(ctx);
+  } catch {
+    return void 0;
+  }
+}
+function createInboundPipeline(deps, config) {
+  const mutedChats = /* @__PURE__ */ new Set();
+  const now = config.now ?? Date.now;
+  const group = config.groupRateLimit ?? DEFAULT_GROUP_RATE_LIMIT;
+  const dm = config.dmRateLimit ?? DEFAULT_DM_RATE_LIMIT;
+  const underGroupRateLimit = createSlidingWindowRateLimiter(group.max, group.windowMs, now);
+  const underDmRateLimit = createSlidingWindowRateLimiter(dm.max, dm.windowMs, now);
+  const mode = "public";
+  return async function handleInboundMessage(msg, turn) {
+    const allowedChats = config.allowedChats ?? [];
+    const action = decideChannelAction(msg, {
+      allowedChats,
+      mutedChats,
+      muteRegex: config.muteRegex,
+      unmuteRegex: config.unmuteRegex
+    });
+    if (action === "mute") {
+      mutedChats.add(msg.chatId);
+      if (config.muteReply) await turn.reply.sendGateReply(msg.chatId, config.muteReply);
+      return { action: "mute" };
+    }
+    if (action === "unmute") {
+      mutedChats.delete(msg.chatId);
+      if (config.unmuteReply) await turn.reply.sendGateReply(msg.chatId, config.unmuteReply);
+      return { action: "unmute" };
+    }
+    if (action === "ignore") {
+      return { action: "ignore" };
+    }
+    if (!underReplyRateLimit(msg, { dm: underDmRateLimit, group: underGroupRateLimit })) {
+      return { action: "rate-limited" };
+    }
+    const sender = typeof turn.sender === "function" ? await turn.sender() : turn.sender ?? msg.senderId;
+    const conversationId = turn.conversationId ?? msg.chatId;
+    if (turn.intercept && await turn.intercept(sender)) {
+      return { action: "intercepted" };
+    }
+    const personaLayer = await resolvePersonaLayer(config, { sender, text: msg.text });
+    const buckets = await resolveBuckets({ mode, sender, bucketsFor: config.bucketsFor });
+    const priorTurns = config.history ? await config.history.store.load(
+      conversationId,
+      config.history.limit ?? DEFAULT_HISTORY_LIMIT
+    ) : [];
+    const messages = [...priorTurns, { role: "user", content: msg.text }];
+    await config.history?.store.append(conversationId, { role: "user", content: msg.text });
+    const { system } = await prepareChat({
+      store: deps.store,
+      prompts: deps.prompts,
+      mode,
+      messages,
+      personaLayer,
+      channelHint: config.channelHint,
+      buckets
+    });
+    const { content: produced } = await answerOnce({
+      answerFn: config.answerFn,
+      client: deps.client,
+      system,
+      messages,
+      mode,
+      sender,
+      conversationId,
+      model: config.model
+    });
+    const content = await applyTransformReply(
+      config.transformReply,
+      { channel: config.channel ?? "channel", sender, conversationId, text: produced },
+      config.logger
+    );
+    if (!content) {
+      return { action: "ignore" };
+    }
+    await config.history?.store.append(conversationId, { role: "assistant", content });
+    await turn.reply.sendAnswer(msg.chatId, content);
+    return { action: "reply", content };
+  };
+}
+
+// src/channels/telegram/updates.ts
+function messageText(message) {
+  return message.text ?? message.caption ?? "";
+}
+function messageEntities(message) {
+  return (message.text !== void 0 ? message.entities : message.caption_entities) ?? [];
+}
+function mentionsBot(message, me) {
+  const text = messageText(message);
+  const handle = me.username ? `@${me.username.toLowerCase()}` : void 0;
+  return messageEntities(message).some((entity) => {
+    if (entity.type === "text_mention") return entity.user?.id === me.id;
+    if (!handle) return false;
+    const token = text.slice(entity.offset, entity.offset + entity.length).toLowerCase();
+    if (entity.type === "mention") return token === handle;
+    if (entity.type === "bot_command") return token.endsWith(handle);
+    return false;
+  });
+}
+function toChannelMessage(update, me) {
+  const message = update.message;
+  if (!message?.from) return void 0;
+  return {
+    chatId: String(message.chat.id),
+    senderId: String(message.from.id),
+    text: messageText(message),
+    isDirectMessage: message.chat.type === "private",
+    mentionsBot: mentionsBot(message, me),
+    isReplyToBot: message.reply_to_message?.from?.id === me.id,
+    // A single bot token is a single identity, so unlike WhatsApp's
+    // multi-session loop guard this is a plain equality check.
+    fromBot: message.from.id === me.id,
+    // What `setMessageReaction` targets — see `ChannelSenderRegistry.sendReaction`.
+    messageRef: message.message_id
+  };
+}
+function nextOffset(update) {
+  return update.update_id + 1;
+}
+function telegramSenderKey(senderId) {
+  return `tg:${senderId}`;
+}
+
+// src/channels/telegram/poll.ts
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 6e4;
+function pollBackoffMs(failures) {
+  return Math.min(BASE_DELAY_MS * 2 ** Math.min(failures, 20), MAX_DELAY_MS);
+}
+function retryDelayMs(error, failures) {
+  const retryAfterMs = error instanceof TelegramApiError ? error.retryAfterMs : void 0;
+  return retryAfterMs ?? pollBackoffMs(failures);
+}
+async function runLongPoll(deps) {
+  const logger = deps.logger ?? createConsoleLogger();
+  const label = deps.label ?? "Telegram";
+  let offset = deps.initialOffset;
+  let failures = 0;
+  while (!deps.isStopped()) {
+    let updates;
+    try {
+      updates = await deps.getUpdates(offset);
+    } catch (error) {
+      if (deps.isStopped()) break;
+      failures += 1;
+      const delay = retryDelayMs(error, failures);
+      logger.warn(`${label}: getUpdates failed, retrying in ${Math.round(delay / 1e3)}s:`, error);
+      await deps.sleep(delay);
+      continue;
+    }
+    failures = 0;
+    for (const update of updates) {
+      offset = nextOffset(update);
+      deps.onOffset?.(offset);
+      if (deps.isStopped()) break;
+      try {
+        await deps.handleUpdate(update);
+      } catch (error) {
+        logger.warn(`${label}: update ${update.update_id} handling failed:`, error);
+      }
+    }
+  }
+  return offset;
+}
+
+// src/channels/telegram/channel.ts
+var DEFAULT_POLL_TIMEOUT_SECONDS = 30;
+function defaultSleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer === "object" && "unref" in timer) timer.unref();
+  });
+}
+function createTelegramChannel(config) {
+  const channelName = config.name ?? "telegram";
+  const allowedChats = config.allowedChats ?? [];
+  const sleep = config.sleep ?? defaultSleep;
+  const pollTimeoutSeconds = config.pollTimeoutSeconds ?? DEFAULT_POLL_TIMEOUT_SECONDS;
+  let stopped = false;
+  let registered = false;
+  let abort;
+  let senders;
+  return {
+    name: channelName,
+    async start(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}]`;
+      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);
+      senders = deps.senders;
+      registered = true;
+      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,
+          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 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)
+        });
+      }
+      abort = new AbortController();
+      const signal = abort.signal;
+      void runLongPoll({
+        getUpdates: (offset) => api.getUpdates({ offset, timeoutSeconds: pollTimeoutSeconds, signal }),
+        handleUpdate,
+        isStopped: () => stopped,
+        sleep,
+        initialOffset: config.initialOffset,
+        onOffset: config.onOffset,
+        logger: log,
+        label
+      }).catch((error) => log.error(`${label}: poll loop ended unexpectedly:`, error));
+      log.info(`${label}: polling for updates as @${me.username ?? me.id}`);
+    },
+    stop() {
+      stopped = true;
+      abort?.abort();
+      if (registered) {
+        senders?.unregister(channelName);
+        registered = false;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TELEGRAM_API_BASE,
+  TELEGRAM_TEXT_LIMIT,
+  TelegramApiError,
+  createTelegramApi,
+  createTelegramChannel,
+  mentionsBot,
+  messageEntities,
+  messageText,
+  nextOffset,
+  pollBackoffMs,
+  redactToken,
+  retryDelayMs,
+  runLongPoll,
+  splitTelegramText,
+  telegramSenderKey,
+  toChannelMessage,
+  toTelegramMediaRequest
+});