abtars 0.1.0-alpha.2 → 0.1.0-alpha.21

package/bundle/telegram-adapter-QCD7AG5D.js

@@ -0,0 +1,1062 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  BOT_COMMANDS,
+  ResponseFormatter,
+  SecurityGate,
+  emojiToScore
+} from "./chunk-R36WIOYX.js";
+import {
+  cleanResponse,
+  formatReactionSignal,
+  handleInboundMessage,
+  resetAndPrepare,
+  routeReaction
+} from "./chunk-DY3R7LDW.js";
+import "./chunk-NIRYBWUW.js";
+import "./chunk-3MO2MDXJ.js";
+import "./chunk-WX7GHGFX.js";
+import "./chunk-RWUINZUQ.js";
+import "./chunk-P56PLAIC.js";
+import {
+  loadUsers
+} from "./chunk-J5YIMCLT.js";
+import "./chunk-JAJ3DUQ2.js";
+import "./chunk-G6IXMYIO.js";
+import "./chunk-UDZIZB5F.js";
+import "./chunk-XLLSPBBT.js";
+import "./chunk-MZWMYN4O.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-EX2SRTUE.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-AQVOAQQI.js";
+import {
+  init_logger,
+  logDebug,
+  logError,
+  logInfo,
+  logWarn
+} from "./chunk-2BY6I4P5.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-MJ6PHMOK.js";
+import "./chunk-7K2YZTLD.js";
+
+// src/platforms/telegram/telegram-adapter.ts
+init_paths();
+
+// src/platforms/telegram/telegram-api.ts
+init_env_schema();
+init_logger();
+init_log_and_swallow();
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+var TAG = "telegram-api";
+var TelegramApi = class _TelegramApi {
+  baseUrl;
+  token;
+  constructor(botToken) {
+    this.token = botToken;
+    this.baseUrl = `https://api.telegram.org/bot${botToken}`;
+  }
+  /** Get bot info. */
+  async getMe() {
+    const res = await this.call("getMe", {});
+    return res;
+  }
+  async getChat(chatId) {
+    const res = await this.call("getChat", { chat_id: chatId });
+    return res;
+  }
+  /** Get file path for downloading. */
+  async getFile(fileId) {
+    const res = await this.call("getFile", { file_id: fileId });
+    return res;
+  }
+  /** Download a file by its file_path (from getFile). Returns the raw buffer. */
+  async downloadFile(filePath) {
+    const url = `https://api.telegram.org/file/bot${this.token}/${filePath}`;
+    const response = await this.fetchWithRetry(
+      (signal) => fetch(url, { signal }),
+      { method: "downloadFile", timeoutMs: getEnv().telegramFileTimeoutMs, retryable4xx: false }
+    );
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  /** Send a text message. Returns the sent message_id. */
+  async sendMessage(chatId, text, options) {
+    const body = { chat_id: chatId, text, ...options };
+    const res = await this.call("sendMessage", body);
+    return res.message_id;
+  }
+  /** Edit an existing message's text. */
+  async editMessageText(chatId, messageId, text, options) {
+    await this.call("editMessageText", { chat_id: chatId, message_id: messageId, text, ...options });
+  }
+  /** Acknowledge a callback query (inline keyboard press). */
+  async answerCallbackQuery(callbackQueryId) {
+    await this.call("answerCallbackQuery", { callback_query_id: callbackQueryId });
+  }
+  /** Send a chat action (typing indicator, etc.). */
+  async sendChatAction(chatId, action = "typing", messageThreadId) {
+    const body = { chat_id: chatId, action };
+    if (messageThreadId) body.message_thread_id = messageThreadId;
+    await this.call("sendChatAction", body);
+  }
+  /** Set an emoji reaction on a message. Pass empty array to remove. */
+  async setMessageReaction(chatId, messageId, reaction) {
+    await this.call("setMessageReaction", {
+      chat_id: chatId,
+      message_id: messageId,
+      reaction
+    });
+  }
+  /** Send a voice note (OGG Opus). Returns the sent message_id. */
+  async sendVoice(chatId, audioBuffer, options) {
+    const makeForm = () => {
+      const form = new FormData();
+      form.append("chat_id", String(chatId));
+      const blob = new Blob([audioBuffer], { type: "audio/webm" });
+      form.append("voice", blob, "voice.webm");
+      if (options?.message_thread_id) form.append("message_thread_id", String(options.message_thread_id));
+      return form;
+    };
+    const response = await this.fetchWithRetry(
+      (signal) => fetch(`${this.baseUrl}/sendVoice`, { method: "POST", body: makeForm(), signal }),
+      { method: "sendVoice" }
+    );
+    const json = await response.json();
+    if (!json.ok) throw new Error("Telegram API sendVoice returned ok=false");
+    return json.result.message_id;
+  }
+  /** Send a file from disk as a Telegram document. Returns the sent message_id. */
+  async sendDocument(chatId, filePath, caption, options) {
+    const buf = readFileSync(filePath);
+    const fileName = basename(filePath);
+    const makeForm = () => {
+      const form = new FormData();
+      form.append("chat_id", String(chatId));
+      const blob = new Blob([buf], { type: "text/markdown" });
+      form.append("document", blob, fileName);
+      if (caption) form.append("caption", caption.slice(0, 1024));
+      if (options?.message_thread_id) form.append("message_thread_id", String(options.message_thread_id));
+      return form;
+    };
+    const response = await this.fetchWithRetry(
+      (signal) => fetch(`${this.baseUrl}/sendDocument`, { method: "POST", body: makeForm(), signal }),
+      { method: "sendDocument", timeoutMs: getEnv().telegramFileTimeoutMs }
+    );
+    const json = await response.json();
+    if (!json.ok) throw new Error("Telegram API sendDocument returned ok=false");
+    return json.result.message_id;
+  }
+  /** Register bot command menu (shown when user types /). */
+  async setMyCommands(commands) {
+    await this.call("setMyCommands", { commands });
+  }
+  /** Long-poll for updates. */
+  async getUpdates(offset, timeout, signal) {
+    const body = {
+      offset,
+      timeout,
+      allowed_updates: [
+        "message",
+        "callback_query",
+        "message_reaction"
+      ]
+    };
+    return await this.call("getUpdates", body, signal, (timeout + 10) * 1e3);
+  }
+  static MAX_ATTEMPTS = 3;
+  static BACKOFF = [1e3, 3e3, 9e3];
+  static PERMANENT_ERRORS = [
+    /chat not found/i,
+    /bot was blocked/i,
+    /user is deactivated/i,
+    /chat_id is empty/i,
+    /forbidden/i,
+    /not enough rights/i,
+    /CHAT_WRITE_FORBIDDEN/i,
+    /have no rights/i,
+    /wrong file_path/i,
+    /file is temporarily unavailable/i
+  ];
+  static isPermanent(msg) {
+    return this.PERMANENT_ERRORS.some((re) => re.test(msg));
+  }
+  static isTransient(msg) {
+    return /429|5\d\d|bad gateway|service unavailable|timeout|timed out|ETIMEDOUT|ECONNRESET|ECONNREFUSED|socket hang up|network/i.test(msg);
+  }
+  /**
+   * Retry + timeout wrapper for any Telegram fetch. Returns the Response on 2xx,
+   * throws on non-OK or transient-exhaustion. Factory MUST build a fresh request
+   * per attempt (required for FormData; single-use in some runtimes).
+   */
+  async fetchWithRetry(requestFn, opts) {
+    const timeoutMs = opts.timeoutMs ?? getEnv().telegramTimeoutMs;
+    for (let attempt = 0; attempt < _TelegramApi.MAX_ATTEMPTS; attempt++) {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(new Error("telegram timeout")), timeoutMs);
+      const composed = opts.outerSignal ? AbortSignal.any([opts.outerSignal, ctrl.signal]) : ctrl.signal;
+      try {
+        const response = await requestFn(composed);
+        if (!response.ok) {
+          const text = await response.text().catch((err2) => {
+            logAndSwallow(TAG, "read TG API error body", err2);
+            return "";
+          });
+          const err = new Error(`Telegram API ${opts.method} failed (${response.status}): ${text}`);
+          if (response.status >= 400 && response.status < 500 && !opts.retryable4xx) throw err;
+          throw err;
+        }
+        return response;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (_TelegramApi.isPermanent(msg) || opts.outerSignal?.aborted) throw err;
+        if (!opts.retryable4xx && /failed \([4]\d\d\)/.test(msg)) throw err;
+        if (attempt < _TelegramApi.MAX_ATTEMPTS - 1 && _TelegramApi.isTransient(msg)) {
+          logDebug(TAG, `${opts.method} attempt ${attempt + 1}/${_TelegramApi.MAX_ATTEMPTS} \u2014 ${msg.slice(0, 80)}`);
+          await new Promise((r) => setTimeout(r, _TelegramApi.BACKOFF[attempt]));
+          continue;
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw new Error(`Telegram API ${opts.method}: unreachable`);
+  }
+  async call(method, body, signal, timeoutMs) {
+    const response = await this.fetchWithRetry(
+      (composed) => fetch(`${this.baseUrl}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: composed
+      }),
+      { method, timeoutMs, outerSignal: signal }
+    );
+    const json = await response.json();
+    if (!json.ok) throw new Error(`Telegram API ${method} returned ok=false`);
+    return json.result;
+  }
+};
+
+// src/platforms/telegram/telegram-poller.ts
+init_logger();
+var TelegramPoller = class {
+  api;
+  pollTimeout;
+  onUpdate;
+  offsetStore;
+  offset = 0;
+  running = false;
+  abortController = null;
+  /** Timestamp of last successful poll cycle. */
+  lastPollAt = Date.now();
+  constructor(api, pollTimeoutS, onUpdate, offsetStore) {
+    this.api = api;
+    this.pollTimeout = pollTimeoutS;
+    this.onUpdate = onUpdate;
+    this.offsetStore = offsetStore ?? { read: async () => 0, write: async () => {
+    } };
+  }
+  /** Start the long-poll loop. Non-blocking — runs in background. */
+  async start() {
+    if (this.running) return;
+    this.offset = await this.offsetStore.read();
+    this.running = true;
+    this.poll().catch((err) => {
+      logError("poller", "Fatal error in poll loop", err);
+    });
+  }
+  /** Stop polling. Cancels any in-flight request. */
+  stop() {
+    this.running = false;
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  /** Inject a synthetic update into the handler (used for queued messages after sleep). */
+  injectUpdate(update) {
+    void this.onUpdate(update);
+  }
+  async poll() {
+    let failures = 0;
+    while (this.running) {
+      try {
+        this.abortController = new AbortController();
+        const updates = await this.api.getUpdates(
+          this.offset,
+          this.pollTimeout,
+          this.abortController.signal
+        );
+        failures = 0;
+        this.lastPollAt = Date.now();
+        if (updates.length > 0) {
+          const sorted = [...updates].sort((a, b) => a.update_id - b.update_id);
+          for (const update of sorted) {
+            try {
+              const result = this.onUpdate(update);
+              if (result instanceof Promise) {
+                result.catch((err) => logError("poller", "Error in update handler", err));
+              }
+            } catch (err) {
+              logError("poller", "Error in update handler (sync)", err);
+            }
+          }
+          this.offset = sorted[sorted.length - 1].update_id + 1;
+          await this.offsetStore.write(this.offset);
+        }
+      } catch (err) {
+        if (!this.running) break;
+        failures++;
+        const baseDelay = Math.min(2 ** failures * 1e3, 6e4);
+        const jitter = Math.random() * baseDelay;
+        const delay = baseDelay + jitter;
+        const is409 = String(err).includes("409") || String(err).includes("terminated by other getUpdates");
+        const log = is409 ? failures >= 50 ? logError : logWarn : failures < 3 ? logWarn : logError;
+        if (is409 && failures < 50) {
+          log("poller", `409 conflict (attempt ${failures}) \u2014 another instance running, backing off`);
+        } else {
+          log("poller", `Error (attempt ${failures}), retrying in ${Math.round(delay)}ms`, err);
+        }
+        await sleep(delay);
+      }
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/platforms/telegram/offset-store.ts
+init_log_and_swallow();
+import { readFile, writeFile, rename, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+var TAG2 = "offset_store";
+function createFileOffsetStore(filePath) {
+  let pending = Promise.resolve();
+  return {
+    async read() {
+      try {
+        const raw = await readFile(filePath, "utf-8");
+        const val = parseInt(raw.trim(), 10);
+        return Number.isFinite(val) ? val : 0;
+      } catch (err) {
+        logAndSwallow(TAG2, "read offset file", err);
+        return 0;
+      }
+    },
+    write(offset) {
+      pending = pending.then(async () => {
+        const tmp = filePath + ".tmp";
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(tmp, String(offset), "utf-8");
+        await rename(tmp, filePath);
+      }).catch((err) => logAndSwallow(TAG2, "write offset file", err));
+      return pending;
+    }
+  };
+}
+
+// src/platforms/telegram/telegram-adapter.ts
+init_logger();
+init_log_and_swallow();
+
+// src/platforms/telegram/telegram-model-picker.ts
+init_env_schema();
+init_log_and_swallow();
+var TAG3 = "telegram";
+var MODEL_PREFIXES = ["mb:", "mslot:", "mprov:", "mpos:", "mprov2:", "mset:", "model:"];
+function isModelPickerCallback(data) {
+  return MODEL_PREFIXES.some((p) => data.startsWith(p));
+}
+async function handleModelPickerCallback(data, chatId, api, state, deps) {
+  if (data.startsWith("mb:")) {
+    const target = data.slice(3);
+    if (!target) {
+      await api.sendMessage(chatId, "\u{1F44C} Cancelled.");
+      return;
+    }
+    if (target === "a") {
+      const AGENT_LABELS = [
+        { key: "professor", label: "Professor" },
+        { key: "dreamy", label: "Dreamy (sleep)" },
+        { key: "browsie", label: "Browsie (browse)" },
+        { key: "coding", label: "Cody (coding)" }
+      ];
+      const buttons = AGENT_LABELS.map((a) => [{ text: a.label, callback_data: `mslot:${a.key}` }]);
+      buttons.push([{ text: "\u2190 Cancel", callback_data: "mb:" }]);
+      await api.sendMessage(chatId, "\u{1F916} Which agent to change?", { reply_markup: { inline_keyboard: buttons } });
+      return;
+    }
+    if (target.startsWith("p:")) {
+      const agent = target.slice(2);
+      const { loadTransport, resolveAgent, getAvailableProviders, getModelsForProvider } = await import("./transport-config-ANPS2RYT.js");
+      const tc = loadTransport();
+      if (!tc) {
+        await api.sendMessage(chatId, "\u274C transport.json not loaded");
+        return;
+      }
+      let providers = getAvailableProviders(tc).filter((p) => p.config.transport !== "tmux");
+      if (providers.length === 0) {
+        await api.sendMessage(chatId, "\u274C No compatible providers");
+        return;
+      }
+      const currentProvider = resolveAgent(agent, tc)?.providerName;
+      const prefix = agent === "professor" ? "mprov2:professor" : `mprov:${agent}`;
+      const buttons = providers.map((p) => {
+        const count = getModelsForProvider(p.name).length;
+        const label = p.name === currentProvider ? `\u2705 ${p.name} (${count})` : `${p.name} (${count})`;
+        return [{ text: label, callback_data: `${prefix}:${p.name}` }];
+      });
+      buttons.push([{ text: "\u2190 Back", callback_data: "mb:a" }]);
+      await api.sendMessage(chatId, `\u{1F50C} Pick provider:`, { reply_markup: { inline_keyboard: buttons } });
+      return;
+    }
+    if (target.startsWith("s:")) {
+      const slot = target.slice(2);
+      state._pendingSlot = slot;
+      const { loadTransport, resolveAgent, getAvailableProviders, getModelsForProvider } = await import("./transport-config-ANPS2RYT.js");
+      const tc = loadTransport();
+      if (!tc) {
+        await api.sendMessage(chatId, "\u274C transport.json not loaded");
+        return;
+      }
+      let providers = getAvailableProviders(tc).filter((p) => p.config.transport !== "tmux");
+      const currentProvider = resolveAgent("professor", tc)?.providerName;
+      const slotLabel = slot === "professor" ? "Main" : slot.replace("professor_fb", "Fb");
+      const buttons = providers.map((p) => {
+        const count = getModelsForProvider(p.name).length;
+        const label = p.name === currentProvider ? `\u2705 ${p.name} (${count})` : `${p.name} (${count})`;
+        return [{ text: label, callback_data: `mprov2:${slot}:${p.name}` }];
+      });
+      buttons.push([{ text: "\u2190 Back", callback_data: "mslot:professor" }]);
+      await api.sendMessage(chatId, `\u{1F50C} Provider for ${slotLabel}:`, { reply_markup: { inline_keyboard: buttons } });
+      return;
+    }
+  } else if (data.startsWith("mslot:")) {
+    const agent = data.slice(6);
+    const { loadTransport, resolveAgent, getAvailableProviders, getModelsForProvider } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    if (!tc) {
+      await api.sendMessage(chatId, "\u274C transport.json not loaded");
+      return;
+    }
+    if (agent === "professor") {
+      const profResolved = resolveAgent("professor", tc);
+      const fallbacks = tc.agents["professor"]?.fallbacks ?? [];
+      const slots = [
+        { label: `\u2605 Main: ${profResolved?.model ?? "?"}`, key: `mpos:professor::professor` }
+      ];
+      for (let i = 0; i < fallbacks.length; i++) {
+        slots.push({ label: `\u21B3 Fb${i + 1}: ${fallbacks[i].model}`, key: `mpos:professor::professor_fb${i + 1}` });
+      }
+      if (fallbacks.length < 3) {
+        slots.push({ label: `\u21B3 Fb${fallbacks.length + 1}: (add)`, key: `mpos:professor::professor_fb${fallbacks.length + 1}` });
+      }
+      const buttons2 = slots.map((s) => [{ text: s.label, callback_data: s.key }]);
+      buttons2.push([{ text: "\u2190 Back", callback_data: "mb:a" }]);
+      await api.sendMessage(chatId, `\u{1F3AF} Which slot?`, { reply_markup: { inline_keyboard: buttons2 } });
+      return;
+    }
+    let providers = getAvailableProviders(tc).filter((p) => p.config.transport !== "tmux");
+    if (providers.length === 0) {
+      await api.sendMessage(chatId, "\u274C No compatible providers");
+      return;
+    }
+    const currentProvider = resolveAgent(agent, tc)?.providerName;
+    const buttons = providers.map((p) => {
+      const count = getModelsForProvider(p.name).length;
+      const label = p.name === currentProvider ? `\u2705 ${p.name} (${count})` : `${p.name} (${count})`;
+      return [{ text: label, callback_data: `mprov:${agent}:${p.name}` }];
+    });
+    buttons.push([{ text: "\u2190 Back", callback_data: "mb:a" }]);
+    await api.sendMessage(chatId, `\u{1F50C} Pick provider:`, { reply_markup: { inline_keyboard: buttons } });
+  } else if (data.startsWith("mprov:")) {
+    const [, agent, providerName] = data.split(":");
+    const { loadTransport, getModelsForProvider, formatRank, formatCost } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    let models = getModelsForProvider(providerName);
+    const providerConfig = tc?.providers[providerName];
+    if (providerConfig?.transport === "api") models = models.filter((m) => !m.entry.status || m.entry.status === "alive");
+    if (models.length === 0) {
+      await api.sendMessage(chatId, `\u274C No alive models for ${providerName}`);
+      return;
+    }
+    state._pendingSlot = agent;
+    state._modelPickerCache = models.map((m) => m.id);
+    const buttons = models.map((m, i) => [{ text: `${m.id} (${formatRank(m.entry.rank)}, ${formatCost(m.entry.cost)})`, callback_data: `mset:${providerName}:${i}` }]);
+    buttons.push([{ text: "\u2190 Back", callback_data: `mb:p:${agent}` }]);
+    await api.sendMessage(chatId, `\u{1F4CB} Models on ${providerName}:`, { reply_markup: { inline_keyboard: buttons } });
+  } else if (data.startsWith("mpos:")) {
+    const [, , , slot] = data.split(":");
+    const { loadTransport, resolveAgent, getAvailableProviders, getModelsForProvider } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    if (!tc) {
+      await api.sendMessage(chatId, "\u274C transport.json not loaded");
+      return;
+    }
+    let providers = getAvailableProviders(tc).filter((p) => p.config.transport !== "tmux");
+    const profResolved = resolveAgent("professor", tc);
+    const mainTransport = profResolved?.provider.transport;
+    if (slot && slot.startsWith("professor_fb") && mainTransport) {
+      if (mainTransport === "api") {
+        providers = providers.filter((p) => p.config.transport === "api");
+      } else {
+        providers = providers.filter((p) => p.name === profResolved.providerName);
+      }
+    }
+    if (providers.length === 0) {
+      await api.sendMessage(chatId, "\u274C No compatible providers for this slot");
+      return;
+    }
+    const currentProvider = profResolved?.providerName;
+    const slotLabel = slot === "professor" ? "Main" : slot.replace("professor_fb", "Fb");
+    const buttons = providers.map((p) => {
+      const count = getModelsForProvider(p.name).length;
+      const label = p.name === currentProvider ? `\u2705 ${p.name} (${count})` : `${p.name} (${count})`;
+      return [{ text: label, callback_data: `mprov2:${slot}:${p.name}` }];
+    });
+    buttons.push([{ text: "\u2190 Back", callback_data: "mslot:professor" }]);
+    await api.sendMessage(chatId, `\u{1F50C} Provider for ${slotLabel}:`, { reply_markup: { inline_keyboard: buttons } });
+  } else if (data.startsWith("mprov2:")) {
+    const [, slot, providerName] = data.split(":");
+    const { getModelsForProvider, formatRank, formatCost, loadTransport } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    const providerConfig = tc?.providers[providerName];
+    let models = getModelsForProvider(providerName);
+    if (providerConfig?.transport === "api") models = models.filter((m) => !m.entry.status || m.entry.status === "alive");
+    if (models.length === 0) {
+      await api.sendMessage(chatId, `\u274C No alive models for ${providerName}`);
+      return;
+    }
+    state._pendingSlot = slot;
+    const slotLabel = slot === "professor" ? "Main" : slot.replace("professor_fb", "Fb");
+    state._modelPickerCache = models.map((m) => m.id);
+    const buttons = models.map((m, i) => [{ text: `${m.id} (${formatRank(m.entry.rank)}, ${formatCost(m.entry.cost)})`, callback_data: `mset:${providerName}:${i}` }]);
+    buttons.push([{ text: "\u2190 Back", callback_data: `mb:s:${slot}` }]);
+    await api.sendMessage(chatId, `\u{1F4CB} Pick model for ${slotLabel}:`, { reply_markup: { inline_keyboard: buttons } });
+  } else if (data.startsWith("mset:")) {
+    const parts = data.split(":");
+    const providerName = parts[1];
+    const modelIdx = parseInt(parts[2], 10);
+    const model = Number.isFinite(modelIdx) && state._modelPickerCache[modelIdx] ? state._modelPickerCache[modelIdx] : parts.slice(2).join(":");
+    const slot = state._pendingSlot ?? "professor";
+    state._pendingSlot = void 0;
+    state._modelPickerCache = [];
+    const { loadTransport, writeTransportConfig, resolveAgent, getModelsForProvider, validateProviderReady, formatValidationError } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    if (!tc) {
+      await api.sendMessage(chatId, "\u274C transport.json not loaded");
+      return;
+    }
+    const validModels = getModelsForProvider(providerName);
+    if (!validModels.some((m) => m.id === model)) {
+      await api.sendMessage(chatId, `\u274C ${model} is not available on ${providerName}. Pick another.`);
+      return;
+    }
+    const providerConfig = tc.providers[providerName];
+    if (!providerConfig) {
+      await api.sendMessage(chatId, `\u274C Provider ${providerName} not found`);
+      return;
+    }
+    const validation = validateProviderReady(providerName, providerConfig, getEnv());
+    if (!validation.ok) {
+      await api.sendMessage(chatId, formatValidationError(providerName, validation));
+      return;
+    }
+    if (providerConfig?.transport === "api") {
+      try {
+        const endpoint = providerConfig.endpoint ?? "";
+        const apiKey = getEnv().getApiKey(providerConfig.apiKeyEnv ?? "API_KEY");
+        const headers = {};
+        if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+        const res = await fetch(`${endpoint}/models`, { headers, signal: AbortSignal.timeout(5e3) });
+        if (!res.ok) {
+          await api.sendMessage(chatId, `\u26A0\uFE0F ${providerName} unreachable (${res.status}). Try another?`);
+          return;
+        }
+      } catch (err) {
+        logAndSwallow(TAG3, "provider reachability check", err);
+        await api.sendMessage(chatId, `\u26A0\uFE0F ${providerName} unreachable. Try another?`);
+        return;
+      }
+    }
+    const agentKey = slot.startsWith("professor_fb") ? "professor" : slot;
+    const fbIndex = slot === "professor_fb1" ? 0 : slot === "professor_fb2" ? 1 : slot === "professor_fb3" ? 2 : -1;
+    if (fbIndex >= 0) {
+      if (!tc.agents["professor"]) tc.agents["professor"] = { model: "", provider: "" };
+      if (!tc.agents["professor"].fallbacks) tc.agents["professor"].fallbacks = [];
+      tc.agents["professor"].fallbacks[fbIndex] = { model, provider: providerName };
+      const { cleanDemotedModels } = await import("./transport-config-ANPS2RYT.js");
+      cleanDemotedModels(tc, model);
+      writeTransportConfig(tc, `professor fallback ${fbIndex + 1} \u2192 ${model} (${providerName})`);
+      await api.sendMessage(chatId, `\u2705 Fallback ${fbIndex + 1} \u2192 ${model} (${providerName})`);
+    } else {
+      const oldProvider = tc.agents[agentKey]?.provider;
+      tc.agents[agentKey] = { ...tc.agents[agentKey], model, provider: providerName };
+      const { cleanDemotedModels } = await import("./transport-config-ANPS2RYT.js");
+      cleanDemotedModels(tc, model);
+      writeTransportConfig(tc, `${agentKey} \u2192 ${model} (${providerName})`);
+      const providerChanged = oldProvider !== providerName;
+      const isProfessor = agentKey === "professor";
+      let oldType;
+      let newType;
+      let newResolved;
+      if (isProfessor && providerChanged) {
+        const oldResolved = resolveAgent("_old", { ...tc, agents: { ...tc.agents, _old: { model: "", provider: oldProvider } } });
+        newResolved = resolveAgent("_new", { ...tc, agents: { ...tc.agents, _new: { model, provider: providerName } } });
+        oldType = oldResolved?.provider.transport ?? "api";
+        newType = newResolved?.provider.transport ?? "api";
+        if (oldType !== newType) {
+          const resetAgents = [];
+          for (const [a, assignment] of Object.entries(tc.agents)) {
+            if (a === "professor") continue;
+            const ap = tc.providers[assignment.provider];
+            if (ap && ap.transport !== newType) {
+              tc.agents[a] = { model, provider: providerName };
+              resetAgents.push(a);
+            }
+          }
+          if (resetAgents.length > 0) writeTransportConfig(tc, `cascade: ${resetAgents.join(", ")} \u2192 ${providerName}`);
+        }
+      }
+      if (isProfessor && !providerChanged && "setModel" in deps.transport) {
+        await deps.transport.setModel(model);
+        await api.sendMessage(chatId, `\u2705 Switched to ${model}`);
+      } else if (isProfessor && providerChanged && oldType === newType && "switchProvider" in deps.transport) {
+        try {
+          const { FallbackPolicy } = await import("./fallback-policy-SR6ED5I3.js");
+          const { ModelHealthRegistry } = await import("./model-health-registry-7ECZFCW4.js");
+          const apiKey = getEnv().getApiKey(newResolved?.provider.apiKeyEnv ?? "API_KEY");
+          const candidates = [{ endpoint: newResolved.provider.endpoint, apiKey, model, maxContext: newResolved.contextWindow }];
+          for (const fb of tc.agents["professor"]?.fallbacks ?? []) {
+            const fbRes = resolveAgent("_fb", { ...tc, agents: { ...tc.agents, _fb: { model: fb.model, provider: fb.provider } } });
+            if (fbRes) candidates.push({ endpoint: fbRes.provider.endpoint, apiKey: fbRes.provider.apiKeyEnv ? getEnv().getApiKey(fbRes.provider.apiKeyEnv) : apiKey, model: fb.model, maxContext: fbRes.contextWindow });
+          }
+          const registry = deps.transport.policy?.registry ?? new ModelHealthRegistry();
+          const policy = new FallbackPolicy(candidates, registry);
+          deps.transport.switchProvider({ endpoint: newResolved.provider.endpoint, apiKey, model, maxContext: newResolved.contextWindow, policy });
+        } catch (err) {
+          await api.sendMessage(chatId, `\u26A0\uFE0F Hot swap failed: ${err instanceof Error ? err.message : String(err)}. Use /reset to apply.`);
+          return;
+        }
+        try {
+          await api.sendMessage(chatId, `\u2705 Switched to ${model} (${providerName})`);
+        } catch (err) {
+          logAndSwallow(TAG3, "sendMessage model switch confirm", err);
+        }
+      } else if (isProfessor && providerChanged) {
+        const cascadeNote = oldType !== newType ? " Subagents also reset." : "";
+        try {
+          if (deps.pipeline.rebuildTransport) await deps.pipeline.rebuildTransport();
+          await deps.resetSessionForModelSwitch(chatId, "cross-transport-switch");
+          await api.sendMessage(chatId, `\u{1F504} Switched to ${model} (${providerName}). Transport rebuilt.${cascadeNote}`);
+        } catch (err) {
+          await api.sendMessage(chatId, `\u26A0\uFE0F Transport rebuild failed: ${err instanceof Error ? err.message : String(err)}. Try /reset manually.`);
+        }
+      } else {
+        await api.sendMessage(chatId, `\u2705 ${agentKey} \u2192 ${model} (${providerName})`);
+      }
+    }
+  } else if (data.startsWith("model:")) {
+    const newModel = data.slice(6);
+    if ("setModel" in deps.transport && typeof deps.transport.setModel === "function") {
+      try {
+        await deps.transport.setModel(newModel);
+        await deps.resetSessionForModelSwitch(chatId);
+        await api.sendMessage(chatId, `\u{1F916} Model switched \u2192 ${newModel}`);
+      } catch (err) {
+        await api.sendMessage(chatId, `\u274C Model switch failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+}
+
+// src/platforms/telegram/telegram-adapter.ts
+var TELEGRAM_CAPABILITIES = { voice: true, reactions: true, typing: true, threads: true };
+var TAG4 = "telegram";
+var TelegramAdapter = class {
+  name = "telegram";
+  capabilities = TELEGRAM_CAPABILITIES;
+  api;
+  securityGate;
+  formatter = new ResponseFormatter();
+  config;
+  deps;
+  poller = null;
+  botUsername = "";
+  _pendingSlot;
+  _modelPickerCache = [];
+  constructor(config, deps) {
+    this.api = new TelegramApi(config.botToken);
+    this.securityGate = new SecurityGate(loadUsers());
+    this.config = config;
+    this.deps = deps;
+  }
+  /** Send a system notification to a chat (fire-and-forget). */
+  sendNotification(chatId, text) {
+    this.api.sendMessage(parseInt(chatId, 10), text).catch((err) => logAndSwallow(TAG4, "sendNotification", err));
+  }
+  /** Reset session after model switch — saves idle state, clears buffer, marks pendingStart. */
+  async resetSessionForModelSwitch(chatId, reason = "model-switch") {
+    await this.api.sendMessage(chatId, "Resetting session\u2026");
+    const p = this.deps.pipeline;
+    const sessionKey = `telegram:${chatId}`;
+    const bufKey = `telegram:${chatId}`;
+    await p.idleSave.save(sessionKey, chatId);
+    await resetAndPrepare({
+      transport: this.deps.transport,
+      sessionKey,
+      reason,
+      sessions: p.sessions,
+      conversationBuffer: this.deps.conversationBuffer,
+      bufKey
+    });
+    if (p.memoryConfig.memoryEnabled) {
+      const reg = loadUsers();
+      const user = reg.byPlatformId.get(String(chatId));
+      if (user) p.updateCtxStart(p.memoryConfig.memoryDir, user.userId);
+    }
+  }
+  async start() {
+    const botInfo = await this.api.getMe();
+    this.botUsername = botInfo.username?.toLowerCase() ?? "";
+    logInfo(TAG4, `\u{1F916} Bot: @${botInfo.username}`);
+    await this.api.setMyCommands(BOT_COMMANDS.map((c) => ({ command: c.name, description: c.description }))).catch((err) => logWarn(TAG4, `setMyCommands failed: ${err instanceof Error ? err.message : String(err)}`));
+    const home = abtarsHome();
+    const offsetStore = createFileOffsetStore(`${home}/state/telegram-offset`);
+    this.poller = new TelegramPoller(this.api, this.config.pollTimeoutS, (u) => this.handleUpdate(u), offsetStore);
+    await this.poller.start();
+  }
+  stop() {
+    this.poller?.stop();
+    this.poller = null;
+  }
+  authorize(msg) {
+    return this.securityGate.authorizeById(msg.senderId);
+  }
+  async sendMessage(channelId, text, opts) {
+    const chatId = parseInt(channelId, 10);
+    const sendOpts = {};
+    if (opts?.threadId) sendOpts.message_thread_id = parseInt(opts.threadId, 10);
+    if (opts?.parseMode) sendOpts.parse_mode = opts.parseMode;
+    if (opts?.reply_markup) sendOpts.reply_markup = opts.reply_markup;
+    return this.api.sendMessage(chatId, text, sendOpts);
+  }
+  async editMessage(channelId, messageId, text) {
+    const chatId = parseInt(channelId, 10);
+    await this.api.editMessageText(chatId, messageId, text);
+  }
+  chunkResponse(text) {
+    return this.formatter.chunkText(text);
+  }
+  async sendTyping(channelId, threadId) {
+    await this.api.sendChatAction(parseInt(channelId, 10), "typing", threadId ? parseInt(threadId, 10) : void 0);
+  }
+  async setReaction(channelId, messageId, emoji) {
+    if (messageId <= 0) return;
+    try {
+      const reaction = emoji ? [{ type: "emoji", emoji }] : [];
+      await this.api.setMessageReaction(parseInt(channelId, 10), messageId, reaction);
+    } catch (err) {
+      logDebug(TAG4, `React failed (${emoji || "remove"}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async downloadVoice(fileId) {
+    const fileInfo = await this.api.getFile(fileId);
+    if (!fileInfo.file_path) throw new Error("No file_path returned");
+    return this.api.downloadFile(fileInfo.file_path);
+  }
+  async sendVoice(channelId, audio, opts) {
+    const sendOpts = {};
+    if (opts?.threadId) sendOpts.message_thread_id = parseInt(opts.threadId, 10);
+    await this.api.sendVoice(parseInt(channelId, 10), audio, sendOpts);
+  }
+  /** Send a file from disk as a Telegram document. */
+  async sendDocument(channelId, filePath, caption, opts) {
+    const sendOpts = {};
+    if (opts?.threadId) sendOpts.message_thread_id = parseInt(opts.threadId, 10);
+    return this.api.sendDocument(parseInt(channelId, 10), filePath, caption, sendOpts);
+  }
+  injectMessage(msg) {
+    if (!this.poller) return;
+    this.poller.injectUpdate({
+      update_id: 0,
+      message: {
+        message_id: 0,
+        from: { id: parseInt(msg.channelId, 10), is_bot: false, first_name: "queued" },
+        chat: { id: parseInt(msg.channelId, 10), type: "private" },
+        date: Math.floor(Date.now() / 1e3),
+        text: msg.text,
+        ...msg.threadId ? { message_thread_id: parseInt(msg.threadId, 10) } : {}
+      }
+    });
+  }
+  // --- Internal: Telegram update handler ---
+  async handleUpdate(update) {
+    logDebug(TAG4, `Update: ${JSON.stringify(update).slice(0, 200)}`);
+    if (update.callback_query) {
+      const data = update.callback_query.data ?? "";
+      const chatId2 = update.callback_query.message?.chat?.id;
+      this.api.answerCallbackQuery(update.callback_query.id).catch((err) => logAndSwallow(TAG4, "answerCallbackQuery", err));
+      if (!chatId2) return;
+      try {
+        if (isModelPickerCallback(data)) {
+          await handleModelPickerCallback(data, chatId2, this.api, this, {
+            transport: this.deps.transport,
+            pipeline: this.deps.pipeline,
+            resetSessionForModelSwitch: (cid, reason) => this.resetSessionForModelSwitch(cid, reason)
+          });
+        } else if (data.startsWith("model:")) {
+          const newModel = data.slice(6);
+          const transport = this.deps.transport;
+          if ("setModel" in transport && typeof transport.setModel === "function") {
+            try {
+              await transport.setModel(newModel);
+              await this.resetSessionForModelSwitch(chatId2);
+              if (chatId2) await this.api.sendMessage(chatId2, `\u{1F916} Model switched \u2192 ${newModel}`);
+            } catch (err) {
+              if (chatId2) await this.api.sendMessage(chatId2, `\u274C Model switch failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+        }
+      } catch (err) {
+        logWarn(TAG4, `Callback handler error: ${err instanceof Error ? err.message : String(err)}`);
+        this.api.sendMessage(chatId2, `\u26A0\uFE0F Action failed \u2014 try again.`).catch((err2) => logAndSwallow(TAG4, "sendMessage action failed", err2));
+      }
+      return;
+    }
+    if (update.message_reaction) {
+      await this.handleReaction(update);
+      return;
+    }
+    const message = update.message;
+    if (!message?.from) return;
+    const hasText = Boolean(message.text);
+    const hasVoice = Boolean(message.voice || message.audio);
+    const hasPhoto = Boolean(message.photo?.length);
+    const hasDocument = Boolean(message.document);
+    if (!hasText && !hasVoice && !hasPhoto && !hasDocument) return;
+    const chatId = message.chat.id;
+    const isGroup = message.chat.type === "group" || message.chat.type === "supergroup";
+    const threadId = isGroup ? message.message_thread_id : void 0;
+    const messageId = message.message_id;
+    const senderName = message.from.first_name || message.from.username || `id:${message.from.id}`;
+    const bufKey = threadId != null ? `tg:${chatId}:${threadId}` : `tg:${chatId}`;
+    let text = message.text ?? "";
+    let isVoiceNote = false;
+    let voiceFileId;
+    if (hasVoice && !hasText) {
+      if (!this.deps.pipeline.sttConfig) {
+        if (isGroup) {
+          this.deps.conversationBuffer.push(bufKey, senderName, "[voice note - STT disabled]");
+        } else if (this.securityGate.authorizeById(String(message.from?.id))) {
+          await this.api.sendMessage(chatId, "\u{1F3A4} Voice notes require STT (set GROQ_API_KEY).", { message_thread_id: threadId });
+        }
+        return;
+      }
+      if (!this.securityGate.authorizeById(String(message.from?.id))) {
+        if (isGroup) this.deps.conversationBuffer.push(bufKey, senderName, "[voice note]");
+        return;
+      }
+      if (isGroup) {
+        try {
+          await this.setReaction(String(chatId), messageId, "\u{1F440}");
+          const voiceFile = message.voice || message.audio;
+          const audioBuffer = await this.downloadVoice(voiceFile.file_id);
+          const { transcribeAudio } = await import("./stt-CF3CPFDC.js");
+          const result = await transcribeAudio(audioBuffer, "voice.ogg", this.deps.pipeline.sttConfig);
+          const transcript = result.text;
+          if (!transcript) {
+            await this.setReaction(String(chatId), messageId, "");
+            this.deps.conversationBuffer.push(bufKey, senderName, "[voice note - empty]");
+            return;
+          }
+          const mentionRe = new RegExp(`@?${this.botUsername}\\b`, "i");
+          if (!mentionRe.test(transcript) && !transcript.startsWith("/")) {
+            await this.setReaction(String(chatId), messageId, "");
+            this.deps.conversationBuffer.push(bufKey, senderName, `[voice] ${transcript}`);
+            logDebug(TAG4, `Buffered voice transcript: "${transcript.slice(0, 60)}"`);
+            return;
+          }
+          text = transcript.replace(mentionRe, "").trim();
+          isVoiceNote = true;
+          if (!text) {
+            await this.setReaction(String(chatId), messageId, "");
+            return;
+          }
+        } catch (err) {
+          logError(TAG4, "Voice transcription failed", err);
+          await this.setReaction(String(chatId), messageId, "");
+          return;
+        }
+      } else {
+        isVoiceNote = true;
+        voiceFileId = (message.voice || message.audio).file_id;
+      }
+    }
+    if (!isVoiceNote && isGroup) {
+      const mentionRe = new RegExp(`@${this.botUsername}\\b`, "i");
+      const isMention = mentionRe.test(text);
+      const isCommand = text.startsWith("/");
+      if (!isMention && !isCommand) {
+        this.deps.conversationBuffer.push(bufKey, senderName, text);
+        logDebug(TAG4, `Buffered group msg from ${senderName}: "${text.slice(0, 60)}"`);
+        return;
+      }
+      if (isMention) {
+        text = text.replace(mentionRe, "").trim();
+        if (!text) return;
+      }
+    }
+    if (!isVoiceNote && !this.securityGate.authorizeById(String(message.from?.id))) {
+      if (isGroup) this.deps.conversationBuffer.push(bufKey, senderName, text);
+      logWarn(TAG4, `Unauthorized user ${message.from.id}`);
+      return;
+    }
+    let mediaPath;
+    if ((hasPhoto || hasDocument) && this.securityGate.authorizeById(String(message.from?.id))) {
+      try {
+        const { saveInboundMedia } = await import("./media-utils-QBY5WBF3.js");
+        let fileId;
+        let extHint;
+        let claimedMime;
+        if (hasPhoto) {
+          const photo = message.photo[message.photo.length - 1];
+          fileId = photo.file_id;
+          extHint = ".jpg";
+        } else {
+          fileId = message.document.file_id;
+          extHint = message.document.file_name ? "." + (message.document.file_name.split(".").pop() ?? "") : void 0;
+          claimedMime = message.document.mime_type;
+        }
+        const buf = await this.downloadVoice(fileId);
+        const saved = await saveInboundMedia(buf, chatId, { extHint, claimedMime });
+        if (saved) {
+          mediaPath = saved.path;
+          if (!text) text = message.caption ?? `User sent a ${saved.isImage ? "photo" : "file"}.`;
+        } else {
+          if (!text) text = "\u26A0\uFE0F File too large (max 16MB).";
+        }
+      } catch (err) {
+        logWarn(TAG4, `Media download failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (!text) text = "\u26A0\uFE0F Failed to download media.";
+      }
+    }
+    const reply = message.reply_to_message;
+    if (reply?.text) {
+      const replyFrom = reply.from?.first_name ?? "someone";
+      text = `[Replying to ${replyFrom}: "${reply.text.slice(0, 500)}"]
+${text}`;
+    }
+    if (reply?.photo?.length && !mediaPath && this.securityGate.authorizeById(String(message.from?.id))) {
+      try {
+        const { saveInboundMedia } = await import("./media-utils-QBY5WBF3.js");
+        const photo = reply.photo[reply.photo.length - 1];
+        const buf = await this.downloadVoice(photo.file_id);
+        const saved = await saveInboundMedia(buf, chatId, { extHint: ".jpg" });
+        if (saved) mediaPath = saved.path;
+      } catch (err) {
+        logWarn(TAG4, `Reply-to-photo download failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const resolvedUser = loadUsers().byPlatformId.get("telegram:" + message.from.id)?.userId ?? "unknown";
+    const inbound = {
+      platform: "telegram",
+      channelId: String(chatId),
+      userId: resolvedUser,
+      senderId: String(message.from.id),
+      senderName,
+      text,
+      timestamp: message.date * 1e3,
+      threadId: threadId != null ? String(threadId) : void 0,
+      messageId,
+      isGroup,
+      isVoice: isVoiceNote,
+      voiceFileId,
+      mediaPath,
+      rawPlatformData: message
+    };
+    if (text.startsWith("/") && !text.startsWith("//")) {
+      handleInboundMessage(inbound, this, this.deps.pipeline).catch((err) => {
+        logError(TAG4, `Command dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+      return;
+    }
+    await handleInboundMessage(inbound, this, this.deps.pipeline);
+  }
+  async handleReaction(update) {
+    const reaction = update.message_reaction;
+    const user = reaction.user;
+    if (!user) {
+      logDebug(TAG4, "Reaction update missing user field");
+      return;
+    }
+    if (user.is_bot) return;
+    const oldEmojis = new Set(reaction.old_reaction.map((r) => r.emoji));
+    const added = reaction.new_reaction.filter((r) => !oldEmojis.has(r.emoji));
+    if (added.length === 0) return;
+    const senderName = user.first_name || user.username || `id:${user.id}`;
+    const emojis = added.map((r) => r.emoji);
+    logInfo(TAG4, `Reaction ${emojis.join("")} from ${senderName} on msg ${reaction.message_id}`);
+    const isAuthorized = this.securityGate.authorizeById(String(user.id));
+    const signal = formatReactionSignal(senderName, emojis);
+    const chatId = reaction.chat.id;
+    const route = routeReaction(isAuthorized, reaction.chat.type);
+    if (isAuthorized && this.deps.memory) {
+      const score = emojiToScore(emojis[0]);
+      const updated = this.deps.memory.updateEmotionByPlatformId(loadUsers().byPlatformId.get(`telegram:${chatId}`)?.userId ?? "master", reaction.message_id, score);
+      if (updated) logDebug(TAG4, `Emotion score ${score} set on platform msg ${reaction.message_id}`);
+    }
+    if (route === "discard") {
+      logDebug(TAG4, `Unauthorized reaction from user ${user.id}, discarding`);
+      return;
+    }
+    if (route === "buffer") {
+      const bufKey = `tg:${chatId}`;
+      this.deps.conversationBuffer.push(bufKey, senderName, signal);
+      logDebug(TAG4, `Buffered reaction signal for group ${chatId}`);
+    } else {
+      const reactionUser = loadUsers().byPlatformId.get("telegram:" + user.id)?.userId ?? "unknown";
+      const activeId = this.deps.sessionManager.getActiveSessionId(reactionUser, "telegram");
+      const { sessions } = this.deps.pipeline;
+      const entry = sessions.getOrCreate(activeId);
+      if (entry.busy) {
+        entry.queue.push({ msg: { userId: reactionUser, channelId: String(chatId), senderName, senderId: String(user.id), text: signal, messageId: reaction.message_id, platform: "telegram", timestamp: Date.now(), isGroup: false, isVoice: false }, adapter: this });
+        logDebug(TAG4, `Queued reaction signal for busy ${activeId} (${entry.queue.length} pending)`);
+      } else {
+        try {
+          const response = await this.deps.transport.sendPrompt(activeId, signal, void 0, reactionUser);
+          logDebug(TAG4, `Sent reaction signal to transport for chat ${chatId}`);
+          if (response) {
+            const { text, reactionEmoji, noReply } = cleanResponse(response);
+            if (noReply) {
+            } else if (reactionEmoji) {
+              try {
+                await this.api.setMessageReaction(chatId, reaction.message_id, [{ type: "emoji", emoji: reactionEmoji }]);
+              } catch {
+                await this.sendMessage(String(chatId), reactionEmoji);
+              }
+            } else if (text.trim()) {
+              await this.sendMessage(String(chatId), text.trim());
+            }
+          }
+        } catch (err) {
+          logError(TAG4, `Failed to send reaction signal for chat ${chatId}`, err);
+        }
+      }
+    }
+  }
+};
+export {
+  TELEGRAM_CAPABILITIES,
+  TelegramAdapter
+};
+//# sourceMappingURL=telegram-adapter-QCD7AG5D.js.map