@melandlabs/integrations-telegram 0.1.0

package/dist/index.js

@@ -0,0 +1,1810 @@
+import { MessagePlatformAdapter } from '@melandlabs/integrations-channels';
+import { delay, isEmptyMessage, timeBeforeHours } from '@melandlabs/integrations-channels/sources/types';
+import { isTelegramContactMeta } from '@melandlabs/integrations/contacts';
+import bigInt from 'big-integer';
+import { TelegramClient } from 'telegram';
+import { CustomFile } from 'telegram/client/uploads';
+import { StringSession } from 'telegram/sessions';
+import { Api } from 'telegram/tl';
+import MarkdownIt from 'markdown-it';
+import { homedir } from 'os';
+import { join } from 'path';
+import { loadChannelDay, saveChannelMessage, clearChannelConversationFromAllDays, clearChannelForUserPrefix } from '@melandlabs/ai/store';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function createMarkdownIt() {
+  const md = new MarkdownIt({
+    html: false,
+    linkify: true,
+    breaks: false,
+    typographer: false
+  });
+  md.enable("strikethrough");
+  md.enable("table");
+  return md;
+}
+function initCellState() {
+  return {
+    text: "",
+    styles: [],
+    openStyles: [],
+    links: [],
+    linkStack: []
+  };
+}
+function finishCell(cell) {
+  closeRemainingStyles(cell);
+  return { text: cell.text, styles: cell.styles, links: cell.links };
+}
+function resolveTarget(state) {
+  return state.table?.currentCell ?? state;
+}
+function appendText(state, value) {
+  if (!value) return;
+  resolveTarget(state).text += value;
+}
+function openStyle(state, style) {
+  const target = resolveTarget(state);
+  target.openStyles.push({ style, start: target.text.length });
+}
+function closeStyle(state, style) {
+  const target = resolveTarget(state);
+  for (let i = target.openStyles.length - 1; i >= 0; i--) {
+    if (target.openStyles[i]?.style === style) {
+      const start = target.openStyles[i].start;
+      target.openStyles.splice(i, 1);
+      const end = target.text.length;
+      if (end > start) {
+        target.styles.push({ start, end, style });
+      }
+      return;
+    }
+  }
+}
+function closeRemainingStyles(target) {
+  for (let i = target.openStyles.length - 1; i >= 0; i--) {
+    const open = target.openStyles[i];
+    const end = target.text.length;
+    if (end > open.start) {
+      target.styles.push({ start: open.start, end, style: open.style });
+    }
+  }
+  target.openStyles = [];
+}
+function getAttr(token, name) {
+  if (token.attrGet) return token.attrGet(name);
+  if (token.attrs) {
+    for (const [key, value] of token.attrs) {
+      if (key === name) return value;
+    }
+  }
+  return null;
+}
+function renderTableAsBullets(state) {
+  if (!state.table) return;
+  const headers = state.table.headers;
+  const rows = state.table.rows;
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
+    if (row.length === 0) continue;
+    const labelStart = state.text.length;
+    state.text += row[0].text;
+    if (state.text.length > labelStart) {
+      state.styles.push({
+        start: labelStart,
+        end: state.text.length,
+        style: "bold"
+      });
+    }
+    state.text += "\n";
+    for (let ci = 1; ci < row.length; ci++) {
+      const headerText = headers[ci]?.text ?? `Column ${ci}`;
+      state.text += "\u2022 ";
+      state.text += `${headerText}: `;
+      state.text += `${row[ci].text}
+`;
+    }
+  }
+}
+function renderTableAsCode(state) {
+  if (!state.table) return;
+  const headers = state.table.headers;
+  const rows = state.table.rows;
+  const colCount = Math.max(headers.length, ...rows.map((r) => r.length));
+  if (colCount === 0) return;
+  const widths = Array.from({ length: colCount }, () => 0);
+  const updateWidths = (cells) => {
+    for (let i = 0; i < colCount; i++) {
+      widths[i] = Math.max(widths[i], cells[i]?.text.length ?? 0);
+    }
+  };
+  updateWidths(headers);
+  for (const row of rows) updateWidths(row);
+  const codeStart = state.text.length;
+  const appendRow = (cells) => {
+    state.text += "|";
+    for (let i = 0; i < colCount; i++) {
+      state.text += " ";
+      const cell = cells[i];
+      state.text += cell ? cell.text : "";
+      const pad = widths[i] - (cell?.text.length ?? 0);
+      state.text += `${" ".repeat(Math.max(0, pad))} |`;
+    }
+    state.text += "\n";
+  };
+  const appendDivider = () => {
+    state.text += "|";
+    for (let i = 0; i < colCount; i++) {
+      state.text += ` ${"-".repeat(Math.max(3, widths[i]))} |`;
+    }
+    state.text += "\n";
+  };
+  appendRow(headers);
+  appendDivider();
+  for (const row of rows) appendRow(row);
+  const codeEnd = state.text.length;
+  if (codeEnd > codeStart) {
+    state.styles.push({ start: codeStart, end: codeEnd, style: "code_block" });
+  }
+}
+function processTokens(tokens, state) {
+  for (const token of tokens) {
+    switch (token.type) {
+      case "inline":
+        if (token.children) processTokens(token.children, state);
+        break;
+      case "text":
+        appendText(state, token.content ?? "");
+        break;
+      case "em_open":
+        openStyle(state, "italic");
+        break;
+      case "em_close":
+        closeStyle(state, "italic");
+        break;
+      case "strong_open":
+        openStyle(state, "bold");
+        break;
+      case "strong_close":
+        closeStyle(state, "bold");
+        break;
+      case "s_open":
+        openStyle(state, "strikethrough");
+        break;
+      case "s_close":
+        closeStyle(state, "strikethrough");
+        break;
+      case "spoiler_open":
+        if (state.spoilerEnabled) openStyle(state, "spoiler");
+        break;
+      case "spoiler_close":
+        if (state.spoilerEnabled) closeStyle(state, "spoiler");
+        break;
+      case "code_inline": {
+        const content = token.content ?? "";
+        const target = resolveTarget(state);
+        const start = target.text.length;
+        target.text += content;
+        target.styles.push({
+          start,
+          end: start + content.length,
+          style: "code"
+        });
+        break;
+      }
+      case "link_open": {
+        const href = getAttr(token, "href") ?? "";
+        const target = resolveTarget(state);
+        target.linkStack.push({ href, labelStart: target.text.length });
+        break;
+      }
+      case "link_close": {
+        const target = resolveTarget(state);
+        const link = target.linkStack.pop();
+        if (link?.href) {
+          const href = link.href.trim();
+          if (href) {
+            target.links.push({
+              start: link.labelStart,
+              end: target.text.length,
+              href
+            });
+          }
+        }
+        break;
+      }
+      case "image":
+        appendText(state, token.content ?? "");
+        break;
+      case "softbreak":
+      case "hardbreak":
+        appendText(state, "\n");
+        break;
+      case "paragraph_close": {
+        if (state.listStack.length === 0 && !state.table) {
+          state.text += "\n\n";
+        }
+        break;
+      }
+      case "heading_open":
+        if (state.headingStyle === "bold") openStyle(state, "bold");
+        break;
+      case "heading_close":
+        if (state.headingStyle === "bold") closeStyle(state, "bold");
+        if (state.listStack.length === 0 && !state.table) state.text += "\n\n";
+        break;
+      case "blockquote_open":
+        if (state.blockquotePrefix) state.text += state.blockquotePrefix;
+        openStyle(state, "blockquote");
+        break;
+      case "blockquote_close":
+        closeStyle(state, "blockquote");
+        break;
+      case "bullet_list_open":
+        if (state.listStack.length > 0) state.text += "\n";
+        state.listStack.push({ type: "bullet", index: 0 });
+        break;
+      case "bullet_list_close":
+        state.listStack.pop();
+        if (state.listStack.length === 0) state.text += "\n";
+        break;
+      case "ordered_list_open": {
+        if (state.listStack.length > 0) state.text += "\n";
+        const start = Number(getAttr(token, "start") ?? "1");
+        state.listStack.push({ type: "ordered", index: start - 1 });
+        break;
+      }
+      case "ordered_list_close":
+        state.listStack.pop();
+        if (state.listStack.length === 0) state.text += "\n";
+        break;
+      case "list_item_open": {
+        const top = state.listStack[state.listStack.length - 1];
+        if (top) {
+          top.index++;
+          const indent = "  ".repeat(Math.max(0, state.listStack.length - 1));
+          const prefix = top.type === "ordered" ? `${top.index}. ` : "\u2022 ";
+          state.text += `${indent}${prefix}`;
+        }
+        break;
+      }
+      case "list_item_close":
+        if (!state.text.endsWith("\n")) state.text += "\n";
+        break;
+      case "code_block":
+      case "fence": {
+        let code = token.content ?? "";
+        if (!code.endsWith("\n")) code += "\n";
+        const target = resolveTarget(state);
+        const start = target.text.length;
+        target.text += code;
+        target.styles.push({
+          start,
+          end: start + code.length,
+          style: "code_block"
+        });
+        if (state.listStack.length === 0) target.text += "\n";
+        break;
+      }
+      case "html_block":
+      case "html_inline":
+        appendText(state, token.content ?? "");
+        break;
+      case "table_open":
+        if (state.tableMode !== "off") {
+          state.table = {
+            headers: [],
+            rows: [],
+            currentRow: [],
+            currentCell: null,
+            inHeader: false
+          };
+        }
+        break;
+      case "table_close":
+        if (state.table) {
+          if (state.tableMode === "bullets") renderTableAsBullets(state);
+          else if (state.tableMode === "code") renderTableAsCode(state);
+        }
+        state.table = null;
+        break;
+      case "thead_open":
+        if (state.table) state.table.inHeader = true;
+        break;
+      case "thead_close":
+        if (state.table) state.table.inHeader = false;
+        break;
+      case "tbody_open":
+      case "tbody_close":
+        break;
+      case "tr_open":
+        if (state.table) state.table.currentRow = [];
+        break;
+      case "tr_close":
+        if (state.table) {
+          if (state.table.inHeader) {
+            state.table.headers = state.table.currentRow;
+          } else {
+            state.table.rows.push(state.table.currentRow);
+          }
+          state.table.currentRow = [];
+        }
+        break;
+      case "th_open":
+      case "td_open":
+        if (state.table) state.table.currentCell = initCellState();
+        break;
+      case "th_close":
+      case "td_close":
+        if (state.table?.currentCell) {
+          state.table.currentRow.push(finishCell(state.table.currentCell));
+          state.table.currentCell = null;
+        }
+        break;
+      case "hr":
+        state.text += "\u2500\u2500\u2500\n\n";
+        break;
+      default:
+        if (token.children) processTokens(token.children, state);
+        break;
+    }
+  }
+}
+function markdownToIR(markdown, options = {}) {
+  const md = createMarkdownIt();
+  const env = { listStack: [] };
+  const tokens = md.parse(markdown ?? "", env);
+  const state = {
+    text: "",
+    styles: [],
+    openStyles: [],
+    links: [],
+    linkStack: [],
+    listStack: [],
+    headingStyle: options.headingStyle ?? "none",
+    blockquotePrefix: options.blockquotePrefix ?? "",
+    table: null,
+    tableMode: options.tableMode ?? "code",
+    spoilerEnabled: options.enableSpoilers ?? true
+  };
+  processTokens(tokens, state);
+  closeRemainingStyles(resolveTarget(state));
+  const trimmedLen = state.text.trimEnd().length;
+  let codeBlockEnd = 0;
+  for (const span of state.styles) {
+    if (span.style !== "code_block") continue;
+    if (span.end > codeBlockEnd) codeBlockEnd = span.end;
+  }
+  const finalLen = Math.max(trimmedLen, codeBlockEnd);
+  return {
+    text: finalLen === state.text.length ? state.text : state.text.slice(0, finalLen),
+    styles: mergeStyleSpans(clampStyleSpans(state.styles, finalLen)),
+    links: clampLinkSpans(state.links, finalLen)
+  };
+}
+function clampStyleSpans(spans, maxLen) {
+  return spans.map((s) => ({
+    ...s,
+    start: Math.max(0, Math.min(s.start, maxLen)),
+    end: Math.max(0, Math.min(s.end, maxLen))
+  })).filter((s) => s.end > s.start);
+}
+function clampLinkSpans(spans, maxLen) {
+  return spans.map((s) => ({
+    ...s,
+    start: Math.max(0, Math.min(s.start, maxLen)),
+    end: Math.max(0, Math.min(s.end, maxLen))
+  })).filter((s) => s.end > s.start);
+}
+function mergeStyleSpans(spans) {
+  if (spans.length === 0) return [];
+  const sorted = [...spans].sort((a, b) => {
+    if (a.start !== b.start) return a.start - b.start;
+    if (a.end !== b.end) return b.end - a.end;
+    return a.style.localeCompare(b.style);
+  });
+  const merged = [];
+  for (const s of sorted) {
+    const prev = merged[merged.length - 1];
+    if (prev && prev.style === s.style && (s.start < prev.end || s.start === prev.end && s.style !== "blockquote")) {
+      prev.end = Math.max(prev.end, s.end);
+      continue;
+    }
+    merged.push({ ...s });
+  }
+  return merged;
+}
+var STYLE_RANK = /* @__PURE__ */ new Map([
+  ["blockquote", 0],
+  ["code_block", 1],
+  ["code", 2],
+  ["bold", 3],
+  ["italic", 4],
+  ["strikethrough", 5],
+  ["spoiler", 6]
+]);
+function sortStyleSpans(spans) {
+  return [...spans].sort((a, b) => {
+    if (a.start !== b.start) return a.start - b.start;
+    if (a.end !== b.end) return b.end - a.end;
+    return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+  });
+}
+function renderMarkdownWithMarkers(ir, options) {
+  const { escapeText: escFn, styleMarkers: markers, buildLink } = options;
+  const content = ir.text;
+  if (!content) return "";
+  const styled = sortStyleSpans(ir.styles.filter((s) => Boolean(markers[s.style])));
+  const boundaries = /* @__PURE__ */ new Set();
+  boundaries.add(0);
+  boundaries.add(content.length);
+  const startsAt = /* @__PURE__ */ new Map();
+  for (const span of styled) {
+    if (span.start === span.end) continue;
+    boundaries.add(span.start);
+    boundaries.add(span.end);
+    const bucket = startsAt.get(span.start);
+    if (bucket) bucket.push(span);
+    else startsAt.set(span.start, [span]);
+  }
+  for (const spans of startsAt.values()) {
+    spans.sort((a, b) => {
+      if (a.end !== b.end) return b.end - a.end;
+      return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+    });
+  }
+  const linkStarts = /* @__PURE__ */ new Map();
+  if (buildLink) {
+    for (const link of ir.links) {
+      if (link.start === link.end) continue;
+      const rendered = buildLink(link, content);
+      if (!rendered) continue;
+      boundaries.add(rendered.start);
+      boundaries.add(rendered.end);
+      const bucket = linkStarts.get(rendered.start);
+      if (bucket) bucket.push(rendered);
+      else linkStarts.set(rendered.start, [rendered]);
+    }
+  }
+  const points = [...boundaries].sort((a, b) => a - b);
+  const stack = [];
+  let out = "";
+  for (let i = 0; i < points.length; i++) {
+    const pos = points[i];
+    while (stack.length && stack[stack.length - 1]?.end === pos) {
+      const item = stack.pop();
+      if (item) out += item.close;
+    }
+    const openingItems = [];
+    const openingLinks = linkStarts.get(pos);
+    if (openingLinks) {
+      for (let idx = 0; idx < openingLinks.length; idx++) {
+        const l = openingLinks[idx];
+        openingItems.push({
+          end: l.end,
+          open: l.open,
+          close: l.close,
+          kind: "link",
+          index: idx
+        });
+      }
+    }
+    const openingStyles = startsAt.get(pos);
+    if (openingStyles) {
+      for (let idx = 0; idx < openingStyles.length; idx++) {
+        const span = openingStyles[idx];
+        const marker = markers[span.style];
+        if (!marker) continue;
+        openingItems.push({
+          end: span.end,
+          open: marker.open,
+          close: marker.close,
+          kind: "style",
+          style: span.style,
+          index: idx
+        });
+      }
+    }
+    if (openingItems.length > 0) {
+      openingItems.sort((a, b) => {
+        if (a.end !== b.end) return b.end - a.end;
+        if (a.kind !== b.kind) return a.kind === "link" ? -1 : 1;
+        if (a.kind === "style" && b.kind === "style") {
+          return (STYLE_RANK.get(a.style ?? "bold") ?? 0) - (STYLE_RANK.get(b.style ?? "bold") ?? 0);
+        }
+        return a.index - b.index;
+      });
+      for (const item of openingItems) {
+        out += item.open;
+        stack.push({ close: item.close, end: item.end });
+      }
+    }
+    const next = points[i + 1];
+    if (next === void 0) break;
+    if (next > pos) out += escFn(content.slice(pos, next));
+  }
+  return out;
+}
+var TELEGRAM_STYLE_MARKERS = {
+  bold: { open: "<b>", close: "</b>" },
+  italic: { open: "<i>", close: "</i>" },
+  strikethrough: { open: "<s>", close: "</s>" },
+  code: { open: "<code>", close: "</code>" },
+  code_block: { open: "<pre><code>", close: "</code></pre>" },
+  spoiler: { open: "<tg-spoiler>", close: "</tg-spoiler>" },
+  blockquote: { open: "<blockquote>", close: "</blockquote>" }
+};
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttr(text) {
+  return escapeHtml(text).replace(/"/g, "&quot;");
+}
+function buildTelegramLink(link, text) {
+  const href = link.href.trim();
+  if (!href || link.start === link.end) return null;
+  return {
+    start: link.start,
+    end: link.end,
+    open: `<a href="${escapeHtmlAttr(href)}">`,
+    close: "</a>"
+  };
+}
+function markdownToTelegramHtml(markdown) {
+  if (!markdown?.trim()) return "";
+  try {
+    const ir = markdownToIR(markdown, {
+      linkify: true,
+      enableSpoilers: true,
+      headingStyle: "none",
+      blockquotePrefix: "",
+      tableMode: "code"
+    });
+    return renderMarkdownWithMarkers(ir, {
+      styleMarkers: TELEGRAM_STYLE_MARKERS,
+      escapeText: escapeHtml,
+      buildLink: buildTelegramLink
+    });
+  } catch (err) {
+    console.error("[Telegram Markdown] Conversion failed, falling back to plain text:", err);
+    return escapeHtml(markdown);
+  }
+}
+var DEBUG = process.env.DEBUG_TELEGRAM === "true";
+var maxDialogCount = 50;
+var maxMessageCount = 200;
+var DEFAULT_MAX_MESSAGE_CHUNK_COUNT = 40;
+var TELEGRAM_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+var dialogCacheFetchLimit = 200;
+var CONNECT_TIMEOUT_MS = 6e4;
+var SEND_MESSAGE_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, operationName) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`${operationName} timed out after ${ms}ms`));
+    }, ms);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch((err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+var TelegramAdapter = class extends MessagePlatformAdapter {
+  client;
+  messages;
+  botId;
+  appId;
+  appHash;
+  session;
+  name = "Telegram";
+  ownerUserId;
+  ownerUserType;
+  fileIngester;
+  clientRegistry;
+  // Caches with TTL (1 hour default)
+  senderCache = {};
+  chatCache = {};
+  dialogs = [];
+  dialogEntityCache = {};
+  dialogsFetchedAt = 0;
+  contactMetadata = {};
+  cacheTTL = 36e5;
+  // 1 hour in milliseconds
+  botToken;
+  ownUserId;
+  // Flag indicating if using shared client from User Listener (should not disconnect when shared)
+  _isSharedClient = false;
+  asyncIteratorState = {
+    dialogs: [],
+    currentDialogIndex: 0,
+    currentMessageIndex: 0,
+    offsetDate: 0,
+    isInitialized: false
+  };
+  constructor(opts) {
+    super();
+    this.session = new StringSession(opts?.session ?? "");
+    this.botId = opts?.botId ?? "";
+    this.appId = opts?.appId ?? Number(process.env.TG_APP_ID ?? "0");
+    this.appHash = opts?.appHash ?? process.env.TG_APP_HASH ?? "";
+    const sessionKey = opts?.session ?? "";
+    const clientRegistry = opts?.clientRegistry;
+    let sharedClient;
+    if (!opts?.botToken && sessionKey && clientRegistry) {
+      sharedClient = clientRegistry.getClientBySessionKey(sessionKey);
+    }
+    if (sharedClient) {
+      this.client = sharedClient;
+      this._isSharedClient = true;
+      if (DEBUG)
+        console.log(
+          `[Bot ${opts?.botId}] [telegram] Reusing existing connection from User Listener to avoid session conflict`
+        );
+    } else {
+      this.client = new TelegramClient(this.session, this.appId, this.appHash, {
+        connectionRetries: 10,
+        timeout: 60,
+        requestRetries: 5,
+        floodSleepThreshold: 60
+      });
+    }
+    this.botToken = opts?.botToken;
+    this.messages = [];
+    this.ownerUserId = opts?.ownerUserId;
+    this.ownerUserType = opts?.ownerUserType;
+    this.fileIngester = opts?.fileIngester;
+    this.clientRegistry = clientRegistry;
+    if (opts?.cacheTTL) {
+      this.cacheTTL = opts.cacheTTL;
+    }
+  }
+  primeContactMetadata(contactId, metadata) {
+    if (!contactId || !metadata) {
+      return;
+    }
+    if (isTelegramContactMeta(metadata)) {
+      this.contactMetadata[contactId] = {
+        ...metadata,
+        peerId: metadata.peerId ?? contactId
+      };
+    }
+  }
+  async connect() {
+    try {
+      if (this._isSharedClient) {
+        if (!this.client.connected) {
+          console.warn(
+            `[Bot ${this.botId}] [telegram] Shared client disconnected, falling back to independent connection`
+          );
+          this._isSharedClient = false;
+          this.client = new TelegramClient(this.session, this.appId, this.appHash, {
+            connectionRetries: 10,
+            timeout: 60,
+            requestRetries: 5,
+            floodSleepThreshold: 60
+          });
+        } else {
+          return;
+        }
+      }
+      if (!this.client.connected) {
+        if (this.botToken) {
+          await this.client.start({
+            botAuthToken: this.botToken
+          });
+        } else {
+          await this.client.start({
+            phoneNumber: async () => await this.prompt("Please enter your phone number: "),
+            password: async () => await this.prompt("Please enter your password: "),
+            phoneCode: async () => await this.prompt("Please enter the verification code: "),
+            onError: (err) => console.error(`[Bot ${this.botId}] [telegram] Login error:`, err)
+          });
+        }
+      }
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Telegram connection error:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect. If using shared client (from User Listener), skip disconnect
+   * to avoid disrupting User Listener's persistent connection.
+   */
+  async disconnect() {
+    if (this._isSharedClient) {
+      if (DEBUG) console.log(`[Bot ${this.botId}] [telegram] Using shared client, skipping disconnect`);
+      return void 0;
+    }
+    if (this.client?.connected) {
+      await this.client.disconnect();
+    }
+    return void 0;
+  }
+  async prompt(question) {
+    return new Promise((resolve) => {
+      const readline = __require("readline").createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      readline.question(question, (answer) => {
+        readline.close();
+        resolve(answer);
+      });
+    });
+  }
+  async getDialogs() {
+    if (!this.client.connected) {
+      await this.client.connect();
+    }
+    await this.refreshDialogsCache();
+    return this.dialogs;
+  }
+  async refreshDialogsCache(force = false) {
+    if (!this.client.connected) {
+      await this.client.connect();
+    }
+    const shouldRefresh = force || this.dialogs.length === 0 || Date.now() - this.dialogsFetchedAt > this.cacheTTL;
+    if (!shouldRefresh) {
+      return;
+    }
+    const dialogs = await this.client.getDialogs({
+      limit: dialogCacheFetchLimit
+    });
+    const nextDialogs = [];
+    for (const dialog of dialogs) {
+      if (!dialog.id || !dialog.entity) {
+        continue;
+      }
+      const idStr = dialog.id.toString();
+      const type = dialog.isUser === true ? "private" : dialog.isChannel || dialog.isGroup ? "group" : "unknown";
+      const resolvedName = dialog.name && dialog.name.trim().length > 0 ? dialog.name : this.getChatName(dialog.entity);
+      const metadata = this.buildMetadataFromEntity(idStr, dialog.entity);
+      nextDialogs.push({
+        id: idStr,
+        name: resolvedName,
+        type,
+        metadata: metadata ?? void 0
+      });
+      this.addDialogEntityToCache(idStr, dialog.entity);
+    }
+    this.dialogs = nextDialogs;
+    this.dialogsFetchedAt = Date.now();
+  }
+  // Cache management methods
+  isCacheValid(cacheEntry) {
+    return Date.now() - cacheEntry.timestamp < this.cacheTTL;
+  }
+  getFromCache(cache, id) {
+    const idStr = id.toString();
+    const entry = cache[idStr];
+    if (entry && this.isCacheValid(entry)) {
+      return entry.entity;
+    }
+    if (entry) {
+      delete cache[idStr];
+    }
+    return null;
+  }
+  addToCache(cache, id, entity) {
+    cache[id.toString()] = {
+      entity,
+      timestamp: Date.now()
+    };
+  }
+  addDialogEntityToCache(id, entity) {
+    this.dialogEntityCache[id] = {
+      entity,
+      timestamp: Date.now()
+    };
+    this.registerMetadataFromEntity(id, entity);
+  }
+  registerMetadataFromEntity(id, entity) {
+    const metadata = this.buildMetadataFromEntity(id, entity);
+    if (metadata) {
+      this.contactMetadata[id] = metadata;
+    }
+  }
+  buildMetadataFromEntity(id, entity) {
+    if (entity instanceof Api.User) {
+      const firstName = entity.firstName ?? null;
+      const lastName = entity.lastName ?? null;
+      const displayName = firstName && lastName ? `${firstName} ${lastName}`.trim() : firstName || lastName || entity.username || null;
+      return {
+        platform: "telegram",
+        peerId: id,
+        peerType: "user",
+        accessHash: entity.accessHash ? entity.accessHash.toString() : void 0,
+        username: entity.username ?? null,
+        firstName,
+        lastName,
+        displayName
+      };
+    }
+    if (entity instanceof Api.Channel) {
+      return {
+        platform: "telegram",
+        peerId: id,
+        peerType: "channel",
+        accessHash: entity.accessHash ? entity.accessHash.toString() : void 0,
+        username: entity.username ?? null,
+        displayName: entity.title || null
+      };
+    }
+    if (entity instanceof Api.Chat) {
+      return {
+        platform: "telegram",
+        peerId: id,
+        peerType: "chat",
+        displayName: entity.title || null
+      };
+    }
+    return null;
+  }
+  // Convert peer to input peer for API calls
+  peerToInputPeer(peer) {
+    if (peer instanceof Api.PeerUser) {
+      return new Api.InputPeerUser({
+        userId: peer.userId,
+        accessHash: bigInt(0)
+      });
+    }
+    if (peer instanceof Api.PeerChat) {
+      return new Api.InputPeerChat({ chatId: peer.chatId });
+    }
+    if (peer instanceof Api.PeerChannel) {
+      return new Api.InputPeerChannel({
+        channelId: peer.channelId,
+        accessHash: bigInt(0)
+        // Use BigInt literal instead
+      });
+    }
+    return new Api.InputPeerEmpty();
+  }
+  // Get entity with caching
+  async getEntityWithCache(cache, entityId) {
+    let inputPeer;
+    let id;
+    if (entityId instanceof Api.PeerUser) {
+      id = entityId.userId;
+      inputPeer = this.peerToInputPeer(entityId);
+    } else if (entityId instanceof Api.PeerChat) {
+      id = entityId.chatId;
+      inputPeer = this.peerToInputPeer(entityId);
+    } else if (entityId instanceof Api.PeerChannel) {
+      id = entityId.channelId;
+      inputPeer = this.peerToInputPeer(entityId);
+    } else if (entityId instanceof Api.InputPeerUser || entityId instanceof Api.InputPeerChat || entityId instanceof Api.InputPeerChannel) {
+      if (entityId instanceof Api.InputPeerUser) {
+        id = entityId.userId;
+      } else if (entityId instanceof Api.InputPeerChat) {
+        id = entityId.chatId;
+      } else {
+        id = entityId.channelId;
+      }
+      inputPeer = entityId;
+    } else {
+      id = entityId;
+      const entity = await this.client.getEntity(entityId);
+      this.addToCache(cache, id, entity);
+      return entity;
+    }
+    const cachedEntity = this.getFromCache(cache, id);
+    if (cachedEntity) {
+      return cachedEntity;
+    }
+    try {
+      const entity = await this.client.getEntity(inputPeer);
+      this.addToCache(cache, id, entity);
+      return entity;
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Error fetching entity ${id}:`, error);
+      return null;
+    }
+  }
+  async sendMessage(target, id, message) {
+    await this.sendMessages(target, id, [message]);
+  }
+  /**
+   * Reply to a message
+   * @param event - Source message event
+   * @param messages - Message chain to send as reply
+   * @param quoteOrigin - Whether to quote the original message (default: false)
+   */
+  async sendMessages(target, id, messages) {
+    await this.runWithAdapterError("sendMessages", async () => {
+      if (!this.client.connected) {
+        await withTimeout(
+          this.client.connect(),
+          CONNECT_TIMEOUT_MS,
+          `[Bot ${this.botId}] Telegram client.connect()`
+        );
+      }
+      if (messages.length === 0) {
+        return;
+      }
+      const { textParts, images, unsupported } = this.partitionMessages(messages);
+      if (unsupported.length > 0) {
+        throw this.createAdapterError(
+          "sendMessages",
+          "invalid_request_error",
+          `Telegram send does not support message content: ${unsupported.join(", ")}`
+        );
+      }
+      await this.dispatchMessages("sendMessages", id, textParts, images);
+    });
+  }
+  async replyMessages(event, messages, quoteOrigin = false) {
+    await this.runWithAdapterError("replyMessages", async () => {
+      if (!this.client.connected) {
+        await withTimeout(
+          this.client.connect(),
+          CONNECT_TIMEOUT_MS,
+          `[Bot ${this.botId}] Telegram client.connect()`
+        );
+      }
+      if (messages.length === 0) {
+        return;
+      }
+      const id = event.targetType === "group" ? event.sender.group.id : event.sender.id;
+      const { textParts, images, unsupported } = this.partitionMessages(messages);
+      if (unsupported.length > 0) {
+        throw this.createAdapterError(
+          "replyMessages",
+          "invalid_request_error",
+          `Telegram reply does not support message content: ${unsupported.join(", ")}`
+        );
+      }
+      await this.dispatchMessages("replyMessages", id.toString(), textParts, images);
+    });
+  }
+  async getChatsByChunk(since, chunkSize) {
+    const maxMessageChunkCount = chunkSize ?? DEFAULT_MAX_MESSAGE_CHUNK_COUNT;
+    if (!this.client.connected) {
+      if (DEBUG) console.log("[Telegram] Client not connected, connecting...");
+      await this.client.connect();
+      await delay(500);
+    }
+    const extractedMessages = [];
+    if (!this.asyncIteratorState.isInitialized) {
+      const allDialogs = await this.client.getDialogs();
+      this.asyncIteratorState.dialogs = allDialogs.filter((dialog) => dialog.entity && dialog.id);
+      this.asyncIteratorState.currentDialogIndex = 0;
+      this.asyncIteratorState.currentMessageIndex = 0;
+      this.asyncIteratorState.isInitialized = true;
+      this.asyncIteratorState.offsetDate = since;
+      if (DEBUG)
+        console.log(
+          `[Bot ${this.botId}] [telegram] Batch fetch initialization complete: ${this.asyncIteratorState.dialogs.length} valid dialogs`
+        );
+      if (this.asyncIteratorState.dialogs.length === 0) {
+        if (DEBUG) console.log(`[Bot ${this.botId}] No valid dialogs to process`);
+        this.asyncIteratorState.isInitialized = false;
+        this.asyncIteratorState.currentDialogIndex = 0;
+        this.asyncIteratorState.currentMessageIndex = 0;
+        return { messages: extractedMessages, hasMore: false };
+      }
+    }
+    let { currentDialogIndex, currentMessageIndex, offsetDate } = this.asyncIteratorState;
+    const targetDialogs = this.asyncIteratorState.dialogs;
+    const MIN_MESSAGES_PER_DIALOG = 5;
+    const REQUEST_DELAY_MS = 150;
+    for (let dialogIdx = currentDialogIndex; dialogIdx < targetDialogs.length; dialogIdx++) {
+      const dialog = targetDialogs[dialogIdx];
+      try {
+        if (!this.client.connected) {
+          if (DEBUG) console.log("[Telegram] Client not connected, connecting...");
+          await this.client.connect();
+          await delay(500);
+        }
+        if (dialogIdx > currentDialogIndex) {
+          await delay(REQUEST_DELAY_MS);
+        }
+        const rawMessages = await this.client.getMessages(dialog.id, {
+          offsetDate,
+          reverse: true
+        });
+        if (DEBUG)
+          console.log(
+            `[Bot ${this.botId}] [telegram] Fetched ${rawMessages.length} messages in the dialog id ${dialog.id}`
+          );
+        if (rawMessages.length === 0 && dialogIdx >= 10) {
+          break;
+        }
+        const startMsgIdx = currentMessageIndex;
+        let dialogMessageCount = 0;
+        for (let msgIdx = startMsgIdx; msgIdx < rawMessages.length; msgIdx++) {
+          const rawMsg = rawMessages[msgIdx];
+          if (!(rawMsg instanceof Api.Message)) continue;
+          const extractedInfo = await this.extractMessageInfo(rawMsg);
+          if (extractedInfo && !isEmptyMessage(extractedInfo)) {
+            extractedMessages.push(extractedInfo);
+            dialogMessageCount++;
+            if (extractedMessages.length >= maxMessageChunkCount) {
+              this.asyncIteratorState.currentDialogIndex = dialogIdx;
+              this.asyncIteratorState.currentMessageIndex = msgIdx + 1;
+              if (DEBUG)
+                console.log(
+                  `[Bot ${this.botId}] Batch full (${maxMessageChunkCount}), continue from dialog ${dialog.id} message ${msgIdx + 1}`
+                );
+              return {
+                messages: extractedMessages,
+                hasMore: true
+              };
+            }
+          }
+        }
+        if (dialogMessageCount < MIN_MESSAGES_PER_DIALOG && rawMessages.length > 0) {
+          const neededCount = MIN_MESSAGES_PER_DIALOG - dialogMessageCount;
+          if (DEBUG)
+            console.log(
+              `[Bot ${this.botId}] [telegram] Dialog ${dialog.id} has only ${dialogMessageCount} messages, fetching ${neededCount} more without time filter`
+            );
+          await delay(REQUEST_DELAY_MS);
+          try {
+            const additionalMessages = await this.client.getMessages(dialog.id, {
+              limit: neededCount
+            });
+            for (const rawMsg of additionalMessages) {
+              if (!(rawMsg instanceof Api.Message)) continue;
+              const extractedInfo = await this.extractMessageInfo(rawMsg);
+              if (extractedInfo && !isEmptyMessage(extractedInfo)) {
+                extractedMessages.push(extractedInfo);
+                dialogMessageCount++;
+                if (extractedMessages.length >= maxMessageChunkCount) {
+                  this.asyncIteratorState.currentDialogIndex = dialogIdx;
+                  this.asyncIteratorState.currentMessageIndex = rawMessages.length;
+                  if (DEBUG)
+                    console.log(
+                      `[Bot ${this.botId}] Batch full (${maxMessageChunkCount}), continue from dialog ${dialog.id}`
+                    );
+                  return {
+                    messages: extractedMessages,
+                    hasMore: true
+                  };
+                }
+              }
+            }
+            if (DEBUG)
+              console.log(
+                `[Bot ${this.botId}] [telegram] Fetched ${additionalMessages.length} additional messages for dialog ${dialog.id}, total: ${dialogMessageCount}`
+              );
+          } catch (error) {
+            console.warn(
+              `[Bot ${this.botId}] [telegram] Failed to fetch additional messages for dialog ${dialog.id}:`,
+              error
+            );
+          }
+        }
+        currentMessageIndex = 0;
+        this.asyncIteratorState.currentMessageIndex = 0;
+        this.asyncIteratorState.currentDialogIndex = dialogIdx + 1;
+      } catch (error) {
+        console.error(`[Bot ${this.botId}] Failed to process dialog ${dialog.id}:`, error);
+        this.asyncIteratorState.currentDialogIndex = dialogIdx + 1;
+        this.asyncIteratorState.currentMessageIndex = 0;
+      }
+    }
+    if (DEBUG)
+      console.log(
+        `[Bot ${this.botId}] All dialogs processed, returning remaining ${extractedMessages.length} messages`
+      );
+    this.asyncIteratorState.isInitialized = false;
+    this.asyncIteratorState.currentDialogIndex = 0;
+    this.asyncIteratorState.currentMessageIndex = 0;
+    return {
+      messages: extractedMessages,
+      hasMore: false
+    };
+  }
+  async getChatsByChunkHours(hours = 8) {
+    return this.getChatsByChunk(timeBeforeHours(hours));
+  }
+  async getChatsByTime(cutoffDate) {
+    if (!this.client.connected) {
+      await this.client.connect();
+    }
+    const extractedMessages = [];
+    const dialogs = await this.client.getDialogs({});
+    if (DEBUG) console.log(`[Bot ${this.botId}] [telegram] Fetched ${dialogs.length} dialogs`);
+    let dialogIndex = 0;
+    const REQUEST_DELAY_MS = 150;
+    for (const dialog of dialogs) {
+      if (!dialog.entity || !dialog.id) {
+        dialogIndex += 1;
+        continue;
+      }
+      this.addToCache(this.chatCache, dialog.id, dialog.entity);
+      if (dialogIndex > 0) {
+        await delay(REQUEST_DELAY_MS);
+      }
+      const messages = await this.client.getMessages(dialog.id, {
+        offsetDate: cutoffDate,
+        reverse: true
+      });
+      if (DEBUG)
+        console.log(
+          `[Bot ${this.botId}] [telegram] Fetched ${messages.length} messages in the dialog id ${dialog.id}`
+        );
+      if (messages.length === 0 && dialogIndex >= 10 || dialogIndex >= maxDialogCount) {
+        break;
+      }
+      dialogIndex += 1;
+      let msgIndex = 0;
+      for (const msg of messages) {
+        if (msgIndex >= maxMessageCount) {
+          break;
+        }
+        if (msg instanceof Api.Message) {
+          msgIndex += 1;
+          const extractedInfo = await this.extractMessageInfo(msg);
+          if (extractedInfo && !isEmptyMessage(extractedInfo)) {
+            extractedMessages.push(extractedInfo);
+          }
+        }
+      }
+    }
+    if (DEBUG)
+      console.log(
+        `[Bot ${this.botId}] [telegram] Fetched ${extractedMessages.length} total messages (capped at ${maxMessageCount})`
+      );
+    return extractedMessages;
+  }
+  async getChatsByDays(days = 1) {
+    const cutoffDate = Math.floor((Date.now() - days * 24 * 60 * 60 * 1e3) / 1e3);
+    return await this.getChatsByTime(cutoffDate);
+  }
+  async getChatsByHours(hours = 1) {
+    const cutoffDate = Math.floor((Date.now() - hours * 60 * 60 * 1e3) / 1e3);
+    return await this.getChatsByTime(cutoffDate);
+  }
+  // Extract detailed information from a message with caching
+  async extractMessageInfo(message, depth = 0, maxDepth = 1) {
+    try {
+      const chat = await this.getEntityWithCache(this.chatCache, message.peerId) ?? await this.client.getEntity(message.peerId);
+      if (!chat) {
+        return null;
+      }
+      const chatType = this.determineChatType(chat);
+      if (chatType === "private" && chat instanceof Api.User) {
+        try {
+          if (!this.ownUserId) {
+            const me = await this.client.getMe();
+            this.ownUserId = me.id;
+          }
+          if (chat.id.equals(this.ownUserId)) {
+            return null;
+          }
+        } catch (error) {
+          console.warn(
+            `[Bot ${this.botId}] [telegram] Failed to get user info for self-message filter:`,
+            error
+          );
+        }
+      }
+      let sender = null;
+      if (chatType === "channel" || chatType === "group") {
+        if (message.fromId) {
+          sender = await this.getEntityWithCache(this.senderCache, message.fromId);
+        }
+      } else {
+        if (message.senderId) {
+          sender = await this.getEntityWithCache(this.senderCache, message.senderId);
+        }
+      }
+      const senderName = this.getSenderName(sender);
+      const chatName = this.getChatName(chat);
+      const chatUserName = "username" in chat ? chat.username : null;
+      const msgInfo = {
+        id: message.id,
+        // Save Telegram original message ID for deduplication
+        sender: chatType === "private" ? senderName ?? chatName : senderName ?? chatUserName ?? `anonymous user ${message.senderId}`,
+        chatName,
+        chatType,
+        text: message.message || "",
+        timestamp: message.date,
+        // Use message.out property to determine message direction: true means sent by me, false means received from others
+        isOutgoing: message.out
+      };
+      if (msgInfo.sender.includes("anonymous user") && message.senderId) {
+        sender = await this.getEntityWithCache(this.senderCache, message.senderId);
+        const senderName2 = this.getSenderName(sender);
+        if (senderName2) {
+          msgInfo.sender = senderName2;
+        }
+      }
+      let quoted = null;
+      if (message.replyToMsgId && depth < maxDepth) {
+        try {
+          const quotedMsgList = await this.client.getMessages(message.peerId, {
+            ids: message.replyToMsgId
+          });
+          if (quotedMsgList.length > 0 && quotedMsgList[0] instanceof Api.Message) {
+            quoted = await this.extractMessageInfo(quotedMsgList[0], depth + 1, maxDepth);
+          }
+        } catch (error) {
+        }
+      }
+      const result = isEmptyMessage(quoted) ? msgInfo : { ...msgInfo, quoted };
+      const attachments = depth === 0 ? await this.extractAttachmentsFromMessage(message) : [];
+      return attachments.length > 0 ? { ...result, attachments } : result;
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Error extracting message info:`, error);
+      return null;
+    }
+  }
+  // Determine the type of chat
+  determineChatType(chat) {
+    if (chat instanceof Api.User) return "private";
+    if (chat instanceof Api.Chat) return "group";
+    if (chat instanceof Api.Channel) return "channel";
+    return "unknown";
+  }
+  // Get appropriate chat name based on entity type
+  getChatName(chat) {
+    if (chat instanceof Api.User) {
+      const name = `${chat.firstName || ""} ${chat.lastName || ""}`.trim();
+      if (name) return name;
+      if (chat.username) return `@${chat.username}`;
+      return "Private Chat";
+    }
+    if (chat instanceof Api.Chat) {
+      if (chat.title) return chat.title;
+      const chatId = chat.id?.toString();
+      if (chatId) {
+        console.warn(`[Bot ${this.botId}] [telegram] Chat ${chatId} missing title, using ID as fallback`);
+        return `Chat ${chatId}`;
+      }
+      return "Unnamed Chat";
+    }
+    if (chat instanceof Api.Channel) {
+      if (chat.title) return chat.title;
+      if (chat.username) return `@${chat.username}`;
+      const channelId = chat.id?.toString();
+      if (channelId) {
+        console.warn(
+          `[Bot ${this.botId}] [telegram] Channel ${channelId} missing title and username, using ID as fallback`
+        );
+        return `Channel ${channelId}`;
+      }
+      return "Unnamed Chat";
+    }
+    console.warn(`[Bot ${this.botId}] [telegram] Unknown entity type in getChatName:`, chat?.className);
+    return "Unknown Chat";
+  }
+  getSenderName(sender) {
+    if (!sender) return null;
+    if (sender instanceof Api.User) {
+      if (sender.firstName || sender.lastName) {
+        return `${sender.firstName || ""} ${sender.lastName || ""}`.trim();
+      }
+      return sender.username ?? "";
+    }
+    if (sender instanceof Api.Channel) {
+      return sender.title;
+    }
+    if (sender instanceof Api.Chat) {
+      return sender.title;
+    }
+    return null;
+  }
+  // Clear cache manually if needed
+  clearCache() {
+    this.senderCache = {};
+    this.chatCache = {};
+  }
+  isImageMessage(message) {
+    return typeof message === "object" && message !== null && "url" in message && !("length" in message) && !("name" in message) && typeof message.url === "string" && message.url.length > 0;
+  }
+  partitionMessages(messages) {
+    const textParts = [];
+    const images = [];
+    const unsupported = [];
+    for (const message of messages) {
+      if (this.isImageMessage(message)) {
+        images.push(message);
+        continue;
+      }
+      const text = opencontextMessageToTgText(message);
+      if (text.trim().length > 0) {
+        textParts.push(text);
+      } else if (typeof message !== "string") {
+        unsupported.push(describeUnsupportedMessage(message));
+      }
+    }
+    return { textParts, images, unsupported };
+  }
+  inferFileName(image) {
+    if (image.id && image.id.trim().length > 0) {
+      return image.id;
+    }
+    if (image.path) {
+      const segments = image.path.split("/");
+      const candidate = segments[segments.length - 1];
+      if (candidate) return candidate;
+    }
+    if (image.url) {
+      try {
+        const url = new URL(image.url);
+        const filename = url.pathname.split("/").pop();
+        if (filename && filename.trim().length > 0) {
+          return filename;
+        }
+      } catch (error) {
+        console.warn(`[Bot ${this.botId}] [telegram] Failed to parse filename from URL`, error);
+      }
+    }
+    return `image-${Date.now()}.jpg`;
+  }
+  decodeBase64Payload(image) {
+    if (!image.base64) {
+      return null;
+    }
+    const base64String = image.base64.includes(",") ? image.base64.split(",").pop() : image.base64;
+    if (!base64String) {
+      return null;
+    }
+    try {
+      return Buffer.from(base64String, "base64");
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Failed to decode base64 image payload`, error);
+      return null;
+    }
+  }
+  async downloadMediaBuffer(message) {
+    try {
+      const result = await this.client.downloadMedia(message);
+      if (!result) return null;
+      if (Buffer.isBuffer(result)) {
+        return result;
+      }
+      if (typeof result === "string") {
+        const fs = await import('fs/promises');
+        return await fs.readFile(result);
+      }
+      return null;
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Failed to download media buffer`, error);
+      return null;
+    }
+  }
+  async extractAttachmentsFromMessage(message) {
+    if (!this.ownerUserId || !this.ownerUserType) {
+      return [];
+    }
+    if (!message.media) {
+      return [];
+    }
+    const attachments = [];
+    const pushAttachment = async (buffer, fileName, mimeType) => {
+      if (!this.ownerUserId || !this.ownerUserType) {
+        return;
+      }
+      const downloadPayload = async () => ({
+        data: buffer,
+        contentType: mimeType,
+        sizeBytes: buffer.length
+      });
+      if (this.fileIngester) {
+        const result = await this.fileIngester.ingestExternal({
+          source: "telegram",
+          userId: this.ownerUserId,
+          maxSizeBytes: TELEGRAM_MAX_ATTACHMENT_BYTES,
+          mimeTypeHint: mimeType,
+          originalFileName: fileName,
+          downloadAttachment: downloadPayload
+        });
+        if (!result.success) {
+          console.warn(
+            `[Bot ${this.botId}] [telegram] Skipped attachment due to ${result.reason} mimeType=${mimeType} fileName=${fileName}`
+          );
+          return;
+        }
+        if (!result.attachment) {
+          return;
+        }
+        const ingested = result.attachment;
+        attachments.push({
+          name: ingested.name,
+          url: ingested.url,
+          downloadUrl: ingested.downloadUrl,
+          contentType: ingested.contentType,
+          sizeBytes: ingested.sizeBytes,
+          blobPath: ingested.blobPath,
+          source: "telegram"
+        });
+      }
+    };
+    if (message.media instanceof Api.MessageMediaPhoto) {
+      const buffer = await this.downloadMediaBuffer(message);
+      if (buffer) {
+        const fileName = `telegram-photo-${message.id ?? Date.now()}.jpg`;
+        await pushAttachment(buffer, fileName, "image/jpeg");
+      }
+      return attachments;
+    }
+    if (message.media instanceof Api.MessageMediaDocument) {
+      const document = message.media.document;
+      if (!document || !(document instanceof Api.Document)) {
+        return attachments;
+      }
+      const buffer = await this.downloadMediaBuffer(message);
+      if (!buffer) {
+        return attachments;
+      }
+      const mimeType = document.mimeType ?? "application/octet-stream";
+      let fileName = `telegram-file-${document.id ?? message.id ?? Date.now()}`;
+      for (const attr of document.attributes ?? []) {
+        if (attr instanceof Api.DocumentAttributeFilename) {
+          fileName = attr.fileName;
+          break;
+        }
+      }
+      await pushAttachment(buffer, fileName, mimeType);
+      return attachments;
+    }
+    return attachments;
+  }
+  async resolveTelegramFile(image) {
+    if (image.base64) {
+      const buffer = this.decodeBase64Payload(image);
+      if (buffer) {
+        const name = this.inferFileName(image);
+        return new CustomFile(name, buffer.length, "", buffer);
+      }
+    }
+    if (image.path) {
+      return image.path;
+    }
+    if (image.url) {
+      return image.url;
+    }
+    throw new Error("Unable to resolve Telegram file source from image payload");
+  }
+  /**
+   * Build InputPeer based on contactId and metadata
+   * If metadata lacks accessHash, will try to resolve entity from Telegram API
+   */
+  async buildInputPeerFromMetadata(contactId) {
+    const metadata = this.contactMetadata[contactId];
+    if (!metadata) {
+      return await this.resolveEntityToInputPeer(contactId);
+    }
+    const peerId = bigInt(metadata.peerId);
+    if (metadata.peerType === "user") {
+      if (metadata.accessHash) {
+        return new Api.InputPeerUser({
+          userId: peerId,
+          accessHash: bigInt(metadata.accessHash)
+        });
+      }
+      return await this.resolveEntityToInputPeer(contactId, peerId, "user");
+    }
+    if (metadata.peerType === "channel") {
+      if (metadata.accessHash) {
+        return new Api.InputPeerChannel({
+          channelId: peerId,
+          accessHash: bigInt(metadata.accessHash)
+        });
+      }
+      return await this.resolveEntityToInputPeer(contactId, peerId, "channel");
+    }
+    if (metadata.peerType === "chat") {
+      if (peerId.isNegative()) {
+        return await this.resolveEntityToInputPeer(contactId, peerId, "channel");
+      }
+      return new Api.InputPeerChat({
+        chatId: peerId
+      });
+    }
+    return await this.resolveEntityToInputPeer(contactId);
+  }
+  /**
+   * Try to resolve entity from Telegram API and build InputPeer
+   * Updates contactMetadata cache after successful resolution
+   */
+  async resolveEntityToInputPeer(contactId, fallbackPeerId, fallbackType) {
+    try {
+      if (!this.client.connected) {
+        await this.client.connect();
+      }
+      const entity = await this.client.getEntity(contactId);
+      if (!entity) {
+        throw new Error(`Entity not found for contactId: ${contactId}`);
+      }
+      const metadata = this.buildMetadataFromEntity(contactId, entity);
+      if (metadata) {
+        this.contactMetadata[contactId] = metadata;
+      }
+      if (entity instanceof Api.User) {
+        const userId = entity.id.valueOf();
+        const accessHash = entity.accessHash ? bigInt(entity.accessHash) : bigInt(0);
+        const inputPeer = new Api.InputPeerUser({
+          userId: bigInt(userId),
+          accessHash
+        });
+        return inputPeer;
+      }
+      if (entity instanceof Api.Channel) {
+        const channelId = entity.id.valueOf();
+        const accessHash = entity.accessHash ? bigInt(entity.accessHash) : bigInt(0);
+        const inputPeer = new Api.InputPeerChannel({
+          channelId: bigInt(channelId),
+          accessHash
+        });
+        return inputPeer;
+      }
+      if (entity instanceof Api.Chat) {
+        const chatId = entity.id.valueOf();
+        const inputPeer = new Api.InputPeerChat({
+          chatId: bigInt(chatId)
+        });
+        return inputPeer;
+      }
+      throw new Error(`Unsupported entity type for contactId: ${contactId}`);
+    } catch (error) {
+      console.error(`[Bot ${this.botId}] [telegram] Failed to resolve entity for ${contactId}:`, error);
+      throw new Error(
+        `Cannot resolve Telegram peer for ${contactId}. The contact may not exist or may not be accessible.`
+      );
+    }
+  }
+  async dispatchMessages(operation, peer, textParts, images) {
+    const text = textParts.join("\n").trim();
+    const inputPeer = await this.buildInputPeerFromMetadata(peer);
+    if (images.length === 0) {
+      if (text.length === 0) {
+        return;
+      }
+      await withTimeout(
+        this.client.sendMessage(inputPeer, {
+          message: markdownToTelegramHtml(text),
+          parseMode: "html"
+        }),
+        SEND_MESSAGE_TIMEOUT_MS,
+        `[Bot ${this.botId}] Telegram client.sendMessage()`
+      );
+      if (DEBUG) {
+        console.log(`[Bot ${this.botId}] [telegram] Message sent successfully to ${peer}`);
+      }
+      return;
+    }
+    const caption = text.length > 0 ? text : void 0;
+    let captionDelivered = false;
+    for (let index = 0; index < images.length; index++) {
+      const image = images[index];
+      let fileLike;
+      try {
+        fileLike = await this.resolveTelegramFile(image);
+      } catch (error) {
+        console.error(`[Bot ${this.botId}] [telegram] Failed to resolve file for upload`, error);
+        throw this.toAdapterError(operation, error, {
+          fallbackCode: "invalid_request_error"
+        });
+      }
+      const options = {
+        file: fileLike
+      };
+      if (index === 0 && caption) {
+        options.caption = caption;
+      }
+      await withTimeout(
+        this.client.sendFile(inputPeer, options),
+        SEND_MESSAGE_TIMEOUT_MS,
+        `[Bot ${this.botId}] Telegram client.sendFile()`
+      );
+      if (index === 0 && caption) {
+        captionDelivered = true;
+      }
+      if (DEBUG) {
+        console.log(`[Bot ${this.botId}] [telegram] File sent successfully to ${peer}`);
+      }
+    }
+    if (caption && !captionDelivered) {
+      await withTimeout(
+        this.client.sendMessage(inputPeer, {
+          message: markdownToTelegramHtml(text),
+          parseMode: "html"
+        }),
+        SEND_MESSAGE_TIMEOUT_MS,
+        `[Bot ${this.botId}] Telegram client.sendMessage()`
+      );
+      if (DEBUG) {
+        console.log(`[Bot ${this.botId}] [telegram] Caption message sent successfully to ${peer}`);
+      }
+    }
+  }
+};
+function opencontextMessageToTgText(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if ("text" in message) {
+    return message.text;
+  }
+  if ("target" in message) {
+    return `@${message.target}`;
+  }
+  if ("nodes" in message) {
+    return message.nodes.map((node) => opencontextMessageToTgText(node)).join("");
+  }
+  return "";
+}
+function describeUnsupportedMessage(message) {
+  if (!message || typeof message !== "object") return typeof message;
+  if ("name" in message && "url" in message) return "file";
+  if ("length" in message && "url" in message) return "voice";
+  if ("origin" in message) return "quote";
+  if ("time" in message && "id" in message) return "source";
+  if ("display" in message && "nodes" in message) return "forward";
+  if ("type" in message && "name" in message) return "emoji";
+  return "content";
+}
+function tgMessageToopencontextMessage(message) {
+  const messages = [];
+  if (!message.message) {
+    if (message.media) {
+      messages.push("[Media content]");
+    }
+    return messages;
+  }
+  messages.push(message.message);
+  if (message.entities) {
+    for (const entity of message.entities) {
+      if (entity instanceof Api.MessageEntityMention) {
+        const mentionText = message.message.substr(entity.offset, entity.length);
+        messages.push({ target: mentionText.replace("@", "") });
+      }
+    }
+  }
+  return messages;
+}
+function getAppMemoryDir(userId) {
+  const base = join(homedir(), ".opencontext", "data", "memory");
+  return userId ? join(base, userId) : base;
+}
+var TelegramConversationStore = class {
+  cache = /* @__PURE__ */ new Map();
+  loadedPairs = /* @__PURE__ */ new Set();
+  DEFAULT_MAX_MESSAGES = 50;
+  EXPIRY_HOURS = 24;
+  PREFIX = "telegram";
+  memoryDir;
+  cleanupInterval = null;
+  constructor(userId, memoryDir) {
+    this.memoryDir = memoryDir ?? getAppMemoryDir(userId);
+    this.startCleanupInterval();
+  }
+  pairKey(userId, accountId) {
+    return `${userId}::${accountId}`;
+  }
+  ensureLoaded(userId, accountId) {
+    const pk = this.pairKey(userId, accountId);
+    if (this.loadedPairs.has(pk)) return;
+    const key = this.buildKey(userId, accountId);
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const rawMsgs = loadChannelDay(this.memoryDir, this.PREFIX, today, key, "");
+    this.cache.set(key, {
+      userId,
+      accountId,
+      messages: rawMsgs.map(({ timestamp: _t, ...rest }) => rest),
+      maxMessages: this.DEFAULT_MAX_MESSAGES,
+      lastUpdated: /* @__PURE__ */ new Date()
+    });
+    this.loadedPairs.add(pk);
+  }
+  getConversation(userId, accountId) {
+    const key = this.buildKey(userId, accountId);
+    if (!this.cache.has(key)) {
+      this.cache.set(key, {
+        userId,
+        accountId,
+        messages: [],
+        maxMessages: this.DEFAULT_MAX_MESSAGES,
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+      console.log(`[TelegramConversationStore] Created new conversation for ${key}`);
+    }
+    this.ensureLoaded(userId, accountId);
+    return this.cache.get(key);
+  }
+  addMessage(userId, accountId, role, content) {
+    const key = this.buildKey(userId, accountId);
+    const conversation = this.getConversation(userId, accountId);
+    const msg = { role, content };
+    conversation.messages.push(msg);
+    conversation.lastUpdated = /* @__PURE__ */ new Date();
+    saveChannelMessage(this.memoryDir, this.PREFIX, key, "", {
+      ...msg,
+      timestamp: Date.now()
+    });
+    console.log(`[TelegramConversationStore] Added ${role} message for ${key}`);
+  }
+  getConversationHistory(userId, accountId) {
+    const conversation = this.getConversation(userId, accountId);
+    return [...conversation.messages];
+  }
+  clearConversation(userId, accountId) {
+    const key = this.buildKey(userId, accountId);
+    const pk = this.pairKey(userId, accountId);
+    this.cache.delete(key);
+    this.loadedPairs.delete(pk);
+    clearChannelConversationFromAllDays(this.memoryDir, this.PREFIX, key, "");
+    console.log(`[TelegramConversationStore] Cleared conversation: ${key}`);
+  }
+  clearUserConversations(userId) {
+    const prefix = `telegram:self-chat:${userId}:`;
+    let clearedCount = 0;
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+        clearedCount++;
+      }
+    }
+    for (const pk of [...this.loadedPairs]) {
+      if (pk.startsWith(`${userId}::`)) {
+        this.loadedPairs.delete(pk);
+      }
+    }
+    clearChannelForUserPrefix(this.memoryDir, this.PREFIX, prefix);
+    console.log(`[TelegramConversationStore] Cleared ${clearedCount} conversation(s) for user ${userId}`);
+  }
+  clearExpiredConversations() {
+    const now = /* @__PURE__ */ new Date();
+    let clearedCount = 0;
+    for (const [key, conversation] of this.cache.entries()) {
+      const hoursSinceLastUpdate = (now.getTime() - conversation.lastUpdated.getTime()) / (1e3 * 60 * 60);
+      if (hoursSinceLastUpdate > this.EXPIRY_HOURS) {
+        this.cache.delete(key);
+        clearedCount++;
+        clearChannelConversationFromAllDays(this.memoryDir, this.PREFIX, key, "");
+        console.log(
+          `[TelegramConversationStore] Cleared expired conversation: ${key} (${hoursSinceLastUpdate.toFixed(1)}h old)`
+        );
+      }
+    }
+    if (clearedCount > 0) {
+      console.log(`[TelegramConversationStore] Cleanup: ${clearedCount} expired conversation(s) cleared`);
+    }
+  }
+  getStats() {
+    let totalMessages = 0;
+    let oldest = null;
+    let newest = null;
+    for (const conversation of this.cache.values()) {
+      totalMessages += conversation.messages.length;
+      if (!oldest || conversation.lastUpdated < oldest) oldest = conversation.lastUpdated;
+      if (!newest || conversation.lastUpdated > newest) newest = conversation.lastUpdated;
+    }
+    return {
+      totalConversations: this.cache.size,
+      totalMessages,
+      oldestConversation: oldest,
+      newestConversation: newest
+    };
+  }
+  startCleanupInterval() {
+    if (this.cleanupInterval) return;
+    this.cleanupInterval = setInterval(() => this.clearExpiredConversations(), 60 * 60 * 1e3);
+  }
+  stopCleanupInterval() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  buildKey(userId, accountId) {
+    return `telegram:self-chat:${userId}:${accountId}`;
+  }
+};
+
+export { CONNECT_TIMEOUT_MS, TelegramAdapter, TelegramConversationStore, markdownToTelegramHtml, opencontextMessageToTgText, tgMessageToopencontextMessage, withTimeout };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map