@mastra/telegram 0.1.0 → 0.1.1-alpha.0

package/dist/index.js

@@ -1,680 +1,727 @@
-// src/telegram-provider.ts
-import { randomUUID, timingSafeEqual } from "crypto";
+import { createCipheriv, createDecipheriv, hkdfSync, randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { AgentChannels, resolveWaitUntil } from "@mastra/core/channels";
 import { InMemoryChannelsStorage } from "@mastra/core/storage";
-import { createTelegramAdapter } from "@chat-adapter/telegram";
-
-// src/telegram-client.ts
-import { randomBytes } from "crypto";
-
-// src/types.ts
-var TELEGRAM_API_BASE_URL = "https://api.telegram.org";
-var DEFAULT_ALLOWED_UPDATES = [
-  "message",
-  "edited_message",
-  "channel_post",
-  "edited_channel_post",
-  "callback_query",
-  "message_reaction"
+import { TelegramAdapter, createTelegramAdapter, createTelegramAdapter as createTelegramAdapter$1 } from "@chat-adapter/telegram";
+//#region src/types.ts
+/** Default Telegram Bot API origin. */
+const TELEGRAM_API_BASE_URL = "https://api.telegram.org";
+/**
+* Default update types requested from Telegram. `message_reaction` must be
+* listed explicitly (Telegram omits it otherwise).
+*/
+const DEFAULT_ALLOWED_UPDATES = [
+	"message",
+	"edited_message",
+	"channel_post",
+	"edited_channel_post",
+	"callback_query",
+	"message_reaction"
 ];
-var BOTFATHER_DEEP_LINK = "https://t.me/botfather";
-
-// src/telegram-client.ts
+/**
+* Deep link that opens BotFather so an operator can create a new bot with
+* `/newbot`. Telegram has no OAuth: the resulting BotFather token is pasted
+* back into {@link TelegramProvider.connect} to finish the installation.
+*/
+const BOTFATHER_DEEP_LINK = "https://t.me/botfather";
+//#endregion
+//#region src/telegram-client.ts
+/**
+* Call a Bot API method. Sends a `GET` when `payload` is omitted and a JSON
+* `POST` otherwise. Throws when the transport fails or the API returns
+* `ok: false`.
+*/
 async function botApiRequest(botToken, method, apiBaseUrl, payload) {
-  const init = payload === void 0 ? void 0 : { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(payload) };
-  let response;
-  try {
-    response = await fetch(`${apiBaseUrl}/bot${botToken}/${method}`, {
-      ...init,
-      signal: AbortSignal.timeout(1e4)
-    });
-  } catch (cause) {
-    throw Object.assign(new Error(`Telegram ${method} request failed`, { cause }), {
-      isTransportError: true
-    });
-  }
-  const body = await response.json().catch(() => null);
-  if (!response.ok || !body?.ok) {
-    const detail = body?.description ?? `HTTP ${response.status}`;
-    throw new Error(`Telegram ${method} failed: ${detail}`);
-  }
-  return body.result;
+	const init = payload === void 0 ? void 0 : {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(payload)
+	};
+	let response;
+	try {
+		response = await fetch(`${apiBaseUrl}/bot${botToken}/${method}`, {
+			...init,
+			signal: AbortSignal.timeout(1e4)
+		});
+	} catch (cause) {
+		throw Object.assign(new Error(`Telegram ${method} request failed`, { cause }), { isTransportError: true });
+	}
+	const body = await response.json().catch(() => null);
+	if (!response.ok || !body?.ok) {
+		const detail = body?.description ?? `HTTP ${response.status}`;
+		throw new Error(`Telegram ${method} failed: ${detail}`);
+	}
+	return body.result;
 }
+/**
+* Validate a bot token via `getMe` and resolve the bot's identity. Throws if
+* the token is rejected or the returned user is not a bot.
+*
+* @see https://core.telegram.org/bots/api#getme
+*/
 async function getMe(botToken, apiBaseUrl = TELEGRAM_API_BASE_URL) {
-  let result;
-  try {
-    result = await botApiRequest(botToken, "getMe", apiBaseUrl);
-  } catch (cause) {
-    if (cause instanceof Error && cause.isTransportError) {
-      throw cause;
-    }
-    throw new Error(`Telegram rejected the bot token: ${cause instanceof Error ? cause.message : String(cause)}`, {
-      cause
-    });
-  }
-  if (!result?.is_bot) {
-    throw new Error("Telegram getMe returned a non-bot user; expected a BotFather token");
-  }
-  return result;
+	let result;
+	try {
+		result = await botApiRequest(botToken, "getMe", apiBaseUrl);
+	} catch (cause) {
+		if (cause instanceof Error && cause.isTransportError) throw cause;
+		throw new Error(`Telegram rejected the bot token: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+	}
+	if (!result?.is_bot) throw new Error("Telegram getMe returned a non-bot user; expected a BotFather token");
+	return result;
 }
+/**
+* Register a per-bot webhook. Setting a webhook disables `getUpdates`
+* (long-polling) for that bot — the two transports are mutually exclusive.
+*
+* @see https://core.telegram.org/bots/api#setwebhook
+*/
 async function setWebhook(botToken, options, apiBaseUrl = TELEGRAM_API_BASE_URL) {
-  await botApiRequest(botToken, "setWebhook", apiBaseUrl, {
-    url: options.url,
-    secret_token: options.secretToken,
-    allowed_updates: options.allowedUpdates,
-    drop_pending_updates: options.dropPendingUpdates
-  });
+	await botApiRequest(botToken, "setWebhook", apiBaseUrl, {
+		url: options.url,
+		secret_token: options.secretToken,
+		allowed_updates: options.allowedUpdates,
+		drop_pending_updates: options.dropPendingUpdates
+	});
 }
+/**
+* Remove a bot's webhook. Required before switching a bot to long-polling
+* (`getUpdates` fails while a webhook is set).
+*
+* @see https://core.telegram.org/bots/api#deletewebhook
+*/
 async function deleteWebhook(botToken, dropPendingUpdates = false, apiBaseUrl = TELEGRAM_API_BASE_URL) {
-  await botApiRequest(botToken, "deleteWebhook", apiBaseUrl, {
-    drop_pending_updates: dropPendingUpdates
-  });
+	await botApiRequest(botToken, "deleteWebhook", apiBaseUrl, { drop_pending_updates: dropPendingUpdates });
 }
+/**
+* Publish the bot's command list for a scope.
+*
+* @see https://core.telegram.org/bots/api#setmycommands
+*/
 async function setMyCommands(botToken, options, apiBaseUrl = TELEGRAM_API_BASE_URL) {
-  await botApiRequest(botToken, "setMyCommands", apiBaseUrl, {
-    commands: options.commands,
-    scope: options.scope,
-    language_code: options.languageCode
-  });
+	await botApiRequest(botToken, "setMyCommands", apiBaseUrl, {
+		commands: options.commands,
+		scope: options.scope,
+		language_code: options.languageCode
+	});
 }
+/**
+* Generate a webhook secret token within Telegram's `setWebhook` constraint:
+* 1-256 chars from `[A-Za-z0-9_-]`. base64url of 32 random bytes yields 43
+* such chars.
+*
+* @see https://core.telegram.org/bots/api#setwebhook
+*/
 function generateSecretToken() {
-  return randomBytes(32).toString("base64url");
+	return randomBytes(32).toString("base64url");
 }
-
-// src/commands.ts
-var DEFAULT_COMMANDS = [
-  { command: "start", description: "Start a conversation" },
-  { command: "help", description: "Show what this bot can do" },
-  { command: "settings", description: "Manage your preferences" }
+//#endregion
+//#region src/commands.ts
+/**
+* Conventional command seed registered when a connect provides none.
+* @see https://core.telegram.org/bots/features#commands
+*/
+const DEFAULT_COMMANDS = [
+	{
+		command: "start",
+		description: "Start a conversation"
+	},
+	{
+		command: "help",
+		description: "Show what this bot can do"
+	},
+	{
+		command: "settings",
+		description: "Manage your preferences"
+	}
 ];
+/**
+* Map user-supplied commands (agent capabilities) to Telegram `BotCommand[]`,
+* enforcing the Bot API constraints: `command` is lowercased, stripped of a
+* leading slash, reduced to `[a-z0-9_]`, and clamped to 1-32 chars;
+* `description` defaults to `Run /<command>` and is clamped to 256 chars.
+* Empty or duplicate command names are dropped.
+*/
 function normalizeCommands(raw) {
-  if (!raw) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const item of raw) {
-    const input = typeof item === "string" ? { command: item } : item;
-    const command = input.command.replace(/^\//, "").toLowerCase().replace(/[^a-z0-9_]/g, "").slice(0, 32);
-    if (!command || seen.has(command)) continue;
-    seen.add(command);
-    const description = (input.description?.trim() || `Run /${command}`).slice(0, 256);
-    commands.push({ command, description });
-  }
-  return commands;
+	if (!raw) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const commands = [];
+	for (const item of raw) {
+		const input = typeof item === "string" ? { command: item } : item;
+		const command = input.command.replace(/^\//, "").toLowerCase().replace(/[^a-z0-9_]/g, "").slice(0, 32);
+		if (!command || seen.has(command)) continue;
+		seen.add(command);
+		const description = (input.description?.trim() || `Run /${command}`).slice(0, 256);
+		commands.push({
+			command,
+			description
+		});
+	}
+	return commands;
 }
-
-// src/crypto.ts
-import { createCipheriv, createDecipheriv, hkdfSync, randomBytes as randomBytes2 } from "crypto";
-var ALGO_PREFIX = "aes-256-gcm-hkdf";
-var HKDF_INFO = "mastra-telegram-encryption";
+//#endregion
+//#region src/crypto.ts
+/**
+* Opt-in AES-256-GCM encryption for installation secrets at rest, with
+* HKDF-SHA256 key derivation (mirrors `@mastra/slack`'s `crypto.ts`). Each value
+* gets a fresh random 16-byte salt + 12-byte IV; the salt travels in the
+* ciphertext, so the same passphrase never derives the same key twice. The
+* algorithm prefix lets plaintext and encrypted values coexist during migration,
+* so {@link decrypt} can no-op on plaintext.
+*
+* Format: `aes-256-gcm-hkdf:base64(salt):base64(iv):base64(authTag):base64(ciphertext)`
+*/
+const ALGO_PREFIX = "aes-256-gcm-hkdf";
+const HKDF_INFO = "mastra-telegram-encryption";
 function deriveKey(passphrase, salt) {
-  return Buffer.from(hkdfSync("sha256", passphrase, salt, HKDF_INFO, 32));
+	return Buffer.from(hkdfSync("sha256", passphrase, salt, HKDF_INFO, 32));
 }
+/** Whether a stored value was produced by {@link encrypt}. */
 function isEncrypted(value) {
-  return value.startsWith(`${ALGO_PREFIX}:`);
+	return value.startsWith(`${ALGO_PREFIX}:`);
 }
+/** Encrypt a UTF-8 string with a per-value random salt + IV. */
 function encrypt(plaintext, passphrase) {
-  const salt = randomBytes2(16);
-  const iv = randomBytes2(12);
-  const cipher = createCipheriv("aes-256-gcm", deriveKey(passphrase, salt), iv);
-  const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return `${ALGO_PREFIX}:${salt.toString("base64")}:${iv.toString("base64")}:${tag.toString("base64")}:${enc.toString("base64")}`;
+	const salt = randomBytes(16);
+	const iv = randomBytes(12);
+	const cipher = createCipheriv("aes-256-gcm", deriveKey(passphrase, salt), iv);
+	const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+	const tag = cipher.getAuthTag();
+	return `${ALGO_PREFIX}:${salt.toString("base64")}:${iv.toString("base64")}:${tag.toString("base64")}:${enc.toString("base64")}`;
 }
+/** Decrypt a value from {@link encrypt}. Plaintext (unprefixed) is returned unchanged. */
 function decrypt(value, passphrase) {
-  if (!isEncrypted(value)) return value;
-  const [, saltB64, ivB64, tagB64, ctB64] = value.split(":");
-  if (!saltB64 || !ivB64 || !tagB64 || ctB64 === void 0) {
-    throw new Error("Invalid ciphertext payload");
-  }
-  const decipher = createDecipheriv(
-    "aes-256-gcm",
-    deriveKey(passphrase, Buffer.from(saltB64, "base64")),
-    Buffer.from(ivB64, "base64")
-  );
-  decipher.setAuthTag(Buffer.from(tagB64, "base64"));
-  return Buffer.concat([decipher.update(Buffer.from(ctB64, "base64")), decipher.final()]).toString("utf8");
+	if (!isEncrypted(value)) return value;
+	const [, saltB64, ivB64, tagB64, ctB64] = value.split(":");
+	if (!saltB64 || !ivB64 || !tagB64 || ctB64 === void 0) throw new Error("Invalid ciphertext payload");
+	const decipher = createDecipheriv("aes-256-gcm", deriveKey(passphrase, Buffer.from(saltB64, "base64")), Buffer.from(ivB64, "base64"));
+	decipher.setAuthTag(Buffer.from(tagB64, "base64"));
+	return Buffer.concat([decipher.update(Buffer.from(ctB64, "base64")), decipher.final()]).toString("utf8");
 }
-
-// src/install-store.ts
-var PLATFORM = "telegram";
+//#endregion
+//#region src/install-store.ts
+/** Platform identifier used for every stored record and route. */
+const PLATFORM = "telegram";
+/**
+* Persistence for Telegram bot installations, layered over the platform-agnostic
+* `ChannelsStorage` (the same store `@mastra/slack` uses). Installations are
+* keyed by agent — one bot = one agent — and the per-bot secret fields live in
+* the record's `data` blob. When an `encryptionKey` is supplied, `botToken` and
+* `secretToken` are AES-256-GCM encrypted at rest.
+*/
 var TelegramInstallStore = class {
-  constructor(storage, encryptionKey) {
-    this.storage = storage;
-    this.encryptionKey = encryptionKey;
-  }
-  storage;
-  encryptionKey;
-  /** The active or pending installation for an agent, if any. */
-  async getByAgent(agentId) {
-    const record = await this.storage.getInstallationByAgent(PLATFORM, agentId);
-    return record ? this.#fromRecord(record) : null;
-  }
-  /** Look up an installation by the routing id in its webhook path (M1 dispatch). */
-  async getByWebhookId(webhookId) {
-    const record = await this.storage.getInstallationByWebhookId(webhookId);
-    return record && record.platform === PLATFORM ? this.#fromRecord(record) : null;
-  }
-  /** Insert or replace an installation. */
-  async save(installation) {
-    await this.storage.saveInstallation(this.#toRecord(installation));
-  }
-  /** All Telegram installations (active and pending). */
-  async list() {
-    const records = await this.storage.listInstallations(PLATFORM);
-    return records.map((r) => this.#fromRecord(r));
-  }
-  /** Remove an agent's installation, if present. */
-  async deleteByAgent(agentId) {
-    const record = await this.storage.getInstallationByAgent(PLATFORM, agentId);
-    if (record) await this.storage.deleteInstallation(record.id);
-  }
-  #enc(value) {
-    return value && this.encryptionKey ? encrypt(value, this.encryptionKey) : value;
-  }
-  #dec(value) {
-    if (!value) return value;
-    if (!this.encryptionKey) {
-      if (isEncrypted(value)) {
-        throw new Error(
-          "Telegram installation secrets are encrypted at rest, but no encryption key is configured. Set `encryptionKey` on TelegramProvider or MASTRA_ENCRYPTION_KEY."
-        );
-      }
-      return value;
-    }
-    return decrypt(value, this.encryptionKey);
-  }
-  #toRecord(install) {
-    const data = {
-      botToken: this.#enc(install.botToken),
-      secretToken: this.#enc(install.secretToken),
-      username: install.username,
-      webhookUrl: install.webhookUrl,
-      commands: install.commands
-    };
-    return {
-      id: install.id,
-      platform: PLATFORM,
-      agentId: install.agentId,
-      status: install.status,
-      webhookId: install.webhookId,
-      data,
-      createdAt: install.installedAt,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-  }
-  #fromRecord(record) {
-    const data = record.data ?? {};
-    return {
-      id: record.id,
-      agentId: record.agentId,
-      webhookId: record.webhookId ?? "",
-      status: record.status === "active" ? "active" : "pending",
-      botToken: this.#dec(data.botToken),
-      secretToken: this.#dec(data.secretToken),
-      username: data.username,
-      webhookUrl: data.webhookUrl,
-      commands: data.commands,
-      installedAt: record.createdAt
-    };
-  }
+	storage;
+	encryptionKey;
+	constructor(storage, encryptionKey) {
+		this.storage = storage;
+		this.encryptionKey = encryptionKey;
+	}
+	/** The active or pending installation for an agent, if any. */
+	async getByAgent(agentId) {
+		const record = await this.storage.getInstallationByAgent(PLATFORM, agentId);
+		return record ? this.#fromRecord(record) : null;
+	}
+	/** Look up an installation by the routing id in its webhook path (M1 dispatch). */
+	async getByWebhookId(webhookId) {
+		const record = await this.storage.getInstallationByWebhookId(webhookId);
+		return record && record.platform === "telegram" ? this.#fromRecord(record) : null;
+	}
+	/** Insert or replace an installation. */
+	async save(installation) {
+		await this.storage.saveInstallation(this.#toRecord(installation));
+	}
+	/** All Telegram installations (active and pending). */
+	async list() {
+		return (await this.storage.listInstallations(PLATFORM)).map((r) => this.#fromRecord(r));
+	}
+	/** Remove an agent's installation, if present. */
+	async deleteByAgent(agentId) {
+		const record = await this.storage.getInstallationByAgent(PLATFORM, agentId);
+		if (record) await this.storage.deleteInstallation(record.id);
+	}
+	#enc(value) {
+		return value && this.encryptionKey ? encrypt(value, this.encryptionKey) : value;
+	}
+	#dec(value) {
+		if (!value) return value;
+		if (!this.encryptionKey) {
+			if (isEncrypted(value)) throw new Error("Telegram installation secrets are encrypted at rest, but no encryption key is configured. Set `encryptionKey` on TelegramProvider or MASTRA_ENCRYPTION_KEY.");
+			return value;
+		}
+		return decrypt(value, this.encryptionKey);
+	}
+	#toRecord(install) {
+		const data = {
+			botToken: this.#enc(install.botToken),
+			secretToken: this.#enc(install.secretToken),
+			username: install.username,
+			webhookUrl: install.webhookUrl,
+			commands: install.commands
+		};
+		return {
+			id: install.id,
+			platform: PLATFORM,
+			agentId: install.agentId,
+			status: install.status,
+			webhookId: install.webhookId,
+			data,
+			createdAt: install.installedAt,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	#fromRecord(record) {
+		const data = record.data ?? {};
+		return {
+			id: record.id,
+			agentId: record.agentId,
+			webhookId: record.webhookId ?? "",
+			status: record.status === "active" ? "active" : "pending",
+			botToken: this.#dec(data.botToken),
+			secretToken: this.#dec(data.secretToken),
+			username: data.username,
+			webhookUrl: data.webhookUrl,
+			commands: data.commands,
+			installedAt: record.createdAt
+		};
+	}
 };
+/** Project an installation to its public, secret-free info for the editor UI. */
 function toInstallationInfo(install) {
-  return {
-    id: install.id,
-    platform: PLATFORM,
-    agentId: install.agentId,
-    status: install.status,
-    displayName: install.username,
-    installedAt: install.installedAt
-  };
+	return {
+		id: install.id,
+		platform: PLATFORM,
+		agentId: install.agentId,
+		status: install.status,
+		displayName: install.username,
+		installedAt: install.installedAt
+	};
 }
-
-// src/telegram-provider.ts
+//#endregion
+//#region src/telegram-provider.ts
+/**
+* Resolve the per-adapter streaming/typing config the provider applies to the
+* Telegram entry in `AgentChannels.adapters`. This is the wrapper's stream
+* binding: enabling `streaming` runs the adapter's post-and-edit
+* (`editMessageText`) chunking loop, and `typingStatus` keeps a `sendChatAction`
+* indicator alive — both default on.
+*/
 function resolveTelegramAdapterConfig(config) {
-  return {
-    streaming: config.streaming ?? true,
-    typingStatus: config.typingStatus ?? true
-  };
+	return {
+		streaming: config.streaming ?? true,
+		typingStatus: config.typingStatus ?? true
+	};
 }
-var SECRET_HEADER = "x-telegram-bot-api-secret-token";
+/** Header Telegram echoes the per-bot secret on for every webhook POST. */
+const SECRET_HEADER = "x-telegram-bot-api-secret-token";
+/**
+* Telegram channel provider for Mastra — a {@link ChannelProvider} over
+* `@chat-adapter/telegram`. The adapter handles the Bot API transport (webhook
+* parse, send/edit, typing, rich messages); this provider adds the
+* install/lifecycle layer.
+*
+* Implemented:
+* - **`mastra-telegram-i2g.2`** — multi-token install store (one bot = one
+*   agent), `connect()`/`disconnect()`, `getMe` token ingestion.
+* - **`mastra-telegram-i2g.3`** — per-bot `setWebhook` lifecycle,
+*   `X-Telegram-Bot-Api-Secret-Token` verification, webhook⇄polling exclusion,
+*   and a mounted POST route that delegates to `AgentChannels.handleWebhookEvent`.
+*
+* Later: `setMyCommands` + streaming (`mastra-telegram-i2g.4`).
+*
+* @example
+* ```ts
+* const telegram = new TelegramProvider({ baseUrl: 'https://my-app.example.com' })
+* const mastra = new Mastra({ agents: { myAgent }, channels: { telegram } })
+* await telegram.connect('my-agent', { botToken: '123456:ABC-...' }) // → { type: 'immediate' }
+* ```
+*/
 var TelegramProvider = class {
-  id = PLATFORM;
-  #config;
-  #mastra;
-  #store;
-  /** Live adapters, keyed by installation id. */
-  #adapters = /* @__PURE__ */ new Map();
-  /** Cached sync view of whether any active bot is registered (for {@link getInfo}). */
-  #configured = false;
-  #initPromise = null;
-  constructor(config = {}) {
-    this.#config = config;
-  }
-  /**
-   * Called by Mastra when this channel is registered.
-   * @internal
-   */
-  __attach(mastra) {
-    if (this.#mastra && this.#mastra !== mastra) {
-      this.#initPromise = null;
-      this.#store = void 0;
-      this.#adapters.clear();
-      this.#configured = false;
-    }
-    this.#mastra = mastra;
-  }
-  /**
-   * Per-bot webhook route. A single POST endpoint keyed by an opaque
-   * `webhookId`; the per-bot secret is verified from the request header, never
-   * carried in the URL. Auto-initializes on first hit (mirrors `@mastra/slack`).
-   */
-  getRoutes() {
-    const self = this;
-    const withInit = (handler) => {
-      return async ({ mastra }) => {
-        self.#mastra = mastra;
-        await self.#autoInitialize();
-        return handler.bind(self);
-      };
-    };
-    return [
-      {
-        path: `/${PLATFORM}/events/:webhookId`,
-        method: "POST",
-        requiresAuth: false,
-        createHandler: withInit(this.#handleWebhook)
-      }
-    ];
-  }
-  /** Discovery metadata for the editor UI. */
-  getInfo() {
-    return {
-      id: this.id,
-      name: "Telegram",
-      isConfigured: this.#configured,
-      connectOptionsSchema: {
-        type: "object",
-        properties: {
-          botToken: {
-            type: "string",
-            description: "BotFather bot token. Omit to receive a BotFather deep link instead."
-          },
-          name: {
-            type: "string",
-            description: "Display name for the bot (defaults to the bot's @username)."
-          }
-        }
-      }
-    };
-  }
-  /**
-   * Restore installations from storage: rebuild an adapter per active bot and
-   * inject `AgentChannels` so the agent can receive events immediately.
-   * Idempotent. Does not re-register webhooks (they persist server-side across
-   * restarts); reconnect an agent if its `baseUrl` changed.
-   */
-  async initialize() {
-    if (this.#initPromise) return this.#initPromise;
-    this.#initPromise = this.#doInitialize();
-    try {
-      await this.#initPromise;
-    } catch (err) {
-      this.#initPromise = null;
-      throw err;
-    }
-  }
-  async #doInitialize() {
-    const store = await this.#getStore();
-    const active = (await store.list()).filter((i) => i.status === "active");
-    this.#configured = active.length > 0;
-    for (const installation of active) {
-      try {
-        await this.#activateInstallation(installation);
-      } catch (err) {
-        console.error(`[Telegram] Failed to restore installation "${installation.id}":`, err);
-      }
-    }
-  }
-  /**
-   * Update runtime provider settings. Telegram has no global auth credential to
-   * clear (per-bot tokens are managed via {@link connect}/{@link disconnect}),
-   * so `null` is a no-op; an object merges `apiBaseUrl`/`baseUrl` overrides.
-   */
-  async configure(credentials) {
-    if (credentials === null) return;
-    const apiBaseUrlChanged = credentials.apiBaseUrl !== void 0 && credentials.apiBaseUrl !== this.#config.apiBaseUrl;
-    this.#config = { ...this.#config, ...credentials };
-    if (!apiBaseUrlChanged) return;
-    const wasInitialized = this.#initPromise !== null;
-    for (const adapter of this.#adapters.values()) {
-      try {
-        await adapter.stopPolling();
-      } catch (err) {
-        console.warn("[Telegram] Failed to stop polling while reconfiguring:", err);
-      }
-    }
-    this.#adapters.clear();
-    this.#initPromise = null;
-    if (wasInitialized) await this.initialize();
-  }
-  /**
-   * Connect an agent to a Telegram bot.
-   *
-   * - With `options.botToken`: validate via `getMe`, mint a per-bot webhook
-   *   secret, persist the installation, register the transport (webhook or
-   *   polling), and return `{ type: 'immediate' }`.
-   * - Without a token: persist a pending installation and return
-   *   `{ type: 'deep_link' }` pointing at BotFather.
-   */
-  async connect(agentId, options = {}) {
-    const store = await this.#getStore();
-    const existing = await store.getByAgent(agentId);
-    if (existing?.status === "active") {
-      throw new Error(`Agent "${agentId}" is already connected to Telegram. Disconnect first to reconnect.`);
-    }
-    if (!options.botToken) {
-      const installationId2 = existing?.id ?? randomUUID();
-      await store.save({
-        id: installationId2,
-        agentId,
-        webhookId: existing?.webhookId ?? randomUUID(),
-        status: "pending",
-        installedAt: existing?.installedAt ?? /* @__PURE__ */ new Date()
-      });
-      return { type: "deep_link", url: BOTFATHER_DEEP_LINK, installationId: installationId2 };
-    }
-    const me = await getMe(options.botToken, this.#apiBaseUrl());
-    const installationId = existing?.id ?? randomUUID();
-    const webhookId = existing?.webhookId ?? randomUUID();
-    const baseUrl = this.#getBaseUrl();
-    const mode = this.#resolveMode(baseUrl);
-    if (mode === "webhook" && !baseUrl) {
-      throw new Error(
-        'TelegramProvider needs a baseUrl to register a webhook. Set `baseUrl`, configure the Mastra server, or use `mode: "polling"`.'
-      );
-    }
-    const webhookUrl = mode === "webhook" ? `${baseUrl}/${PLATFORM}/events/${webhookId}` : void 0;
-    const commands = normalizeCommands(options.commands ?? this.#config.commands ?? DEFAULT_COMMANDS);
-    const installation = {
-      id: installationId,
-      agentId,
-      webhookId,
-      status: "active",
-      botToken: options.botToken,
-      secretToken: generateSecretToken(),
-      username: options.name ?? me.username ?? me.first_name,
-      webhookUrl,
-      commands: commands.length ? commands : void 0,
-      installedAt: existing?.installedAt ?? /* @__PURE__ */ new Date()
-    };
-    await this.#registerTransport(installation, mode);
-    await this.#registerCommands(installation);
-    await store.save(installation);
-    await this.#activateInstallation(installation);
-    this.#configured = true;
-    await this.#config.onInstall?.(installation);
-    return { type: "immediate", installationId };
-  }
-  /** Disconnect an agent from Telegram, removing its webhook and installation. */
-  async disconnect(agentId) {
-    const store = await this.#getStore();
-    const existing = await store.getByAgent(agentId);
-    if (!existing) {
-      throw new Error(`No Telegram installation found for agent "${agentId}"`);
-    }
-    const adapter = this.#adapters.get(existing.id);
-    if (adapter) {
-      try {
-        await adapter.stopPolling();
-      } catch (err) {
-        console.warn(`[Telegram] Failed to stop polling for agent "${agentId}":`, err);
-      }
-    }
-    if (existing.botToken) {
-      try {
-        await deleteWebhook(existing.botToken, true, this.#apiBaseUrl());
-      } catch (err) {
-        console.warn(`[Telegram] Failed to delete webhook for agent "${agentId}":`, err);
-      }
-    }
-    this.#adapters.delete(existing.id);
-    await store.deleteByAgent(agentId);
-    this.#configured = (await store.list()).some((i) => i.status === "active");
-  }
-  /** List installations (public info only — no tokens or secrets). */
-  async listInstallations() {
-    const store = await this.#getStore();
-    const installations = await store.list();
-    return installations.map(toInstallationInfo);
-  }
-  /**
-   * Get the full installation for an agent (includes the bot token / secret).
-   * Returns `null` if the agent has no Telegram installation. Mirrors
-   * `SlackProvider.getInstallation`.
-   */
-  async getInstallation(agentId) {
-    const store = await this.#getStore();
-    return await store.getByAgent(agentId) ?? null;
-  }
-  /**
-   * Whether at least one bot is actively registered. Mirrors
-   * `SlackProvider.isConfigured` (Telegram has no global credential to check —
-   * "configured" means an active installation exists).
-   */
-  isConfigured() {
-    return this.#configured;
-  }
-  /**
-   * Get the live `TelegramAdapter` for an installation id, if one is active.
-   * Used for message formatting/posting. Mirrors `SlackProvider.getAdapter`.
-   */
-  getAdapter(installationId) {
-    return this.#adapters.get(installationId);
-  }
-  // ===========================================================================
-  // Webhook handling
-  // ===========================================================================
-  async #handleWebhook(c) {
-    const webhookId = c.req.param("webhookId");
-    if (!webhookId) return c.json({ ok: false, error: "Missing webhookId" }, 400);
-    const store = await this.#getStore();
-    const installation = await store.getByWebhookId(webhookId);
-    if (!installation || installation.status !== "active") {
-      return c.json({ ok: false, error: "Unknown webhook" }, 404);
-    }
-    const provided = c.req.header(SECRET_HEADER);
-    if (!secretMatches(provided, installation.secretToken)) {
-      return c.json({ ok: false, error: "Invalid secret token" }, 401);
-    }
-    const agent = this.#resolveAgent(installation.agentId);
-    if (!agent || !this.#mastra) {
-      return c.json({ ok: true });
-    }
-    const adapter = this.#getOrCreateAdapter(installation);
-    let channels = agent.getChannels();
-    if (!channels || channels.adapters[PLATFORM] !== adapter) {
-      channels = this.#createAgentChannels(agent, adapter);
-      await channels.initialize(this.#mastra);
-    }
-    const waitUntil = this.#config.waitUntil ?? resolveWaitUntil(c);
-    try {
-      return await channels.handleWebhookEvent(PLATFORM, c.req.raw, waitUntil ? { waitUntil } : void 0);
-    } catch (err) {
-      console.error("[Telegram] Error delegating to AgentChannels:", err);
-      return c.json({ ok: true });
-    }
-  }
-  // ===========================================================================
-  // Internals
-  // ===========================================================================
-  #apiBaseUrl() {
-    return this.#config.apiBaseUrl ?? TELEGRAM_API_BASE_URL;
-  }
-  #resolveMode(baseUrl) {
-    const mode = this.#config.mode ?? "auto";
-    if (mode === "auto") return baseUrl ? "webhook" : "polling";
-    return mode;
-  }
-  /** Register (or clear) the receive transport for a bot, enforcing the exclusion. */
-  async #registerTransport(installation, mode) {
-    if (!installation.botToken) return;
-    if (mode === "webhook" && installation.webhookUrl && installation.secretToken) {
-      await setWebhook(
-        installation.botToken,
-        {
-          url: installation.webhookUrl,
-          secretToken: installation.secretToken,
-          allowedUpdates: this.#config.allowedUpdates ?? [...DEFAULT_ALLOWED_UPDATES],
-          dropPendingUpdates: true
-        },
-        this.#apiBaseUrl()
-      );
-    } else {
-      await deleteWebhook(installation.botToken, true, this.#apiBaseUrl());
-    }
-  }
-  /** Publish the bot's command list (best-effort — a failure won't block connect). */
-  async #registerCommands(installation) {
-    if (!installation.botToken || !installation.commands?.length) return;
-    try {
-      await setMyCommands(
-        installation.botToken,
-        { commands: installation.commands, scope: this.#config.commandScope },
-        this.#apiBaseUrl()
-      );
-    } catch (err) {
-      console.warn(`[Telegram] Failed to register commands for agent "${installation.agentId}":`, err);
-    }
-  }
-  #getOrCreateAdapter(installation) {
-    const existing = this.#adapters.get(installation.id);
-    if (existing) return existing;
-    const adapter = createTelegramAdapter({
-      botToken: installation.botToken,
-      secretToken: installation.secretToken,
-      userName: installation.username,
-      apiBaseUrl: this.#apiBaseUrl(),
-      mode: installation.webhookUrl ? "webhook" : this.#config.mode ?? "auto",
-      ...this.#config.logger !== void 0 ? { logger: this.#config.logger } : {},
-      ...this.#config.longPolling !== void 0 ? { longPolling: this.#config.longPolling } : {}
-    });
-    this.#adapters.set(installation.id, adapter);
-    return adapter;
-  }
-  /** Rebuild the adapter and inject AgentChannels for an active installation. */
-  async #activateInstallation(installation) {
-    const agent = this.#resolveAgent(installation.agentId);
-    const adapter = this.#getOrCreateAdapter(installation);
-    if (agent && this.#mastra) {
-      const channels = this.#createAgentChannels(agent, adapter);
-      await channels.initialize(this.#mastra);
-    }
-  }
-  /**
-   * Create AgentChannels for an agent with the Telegram adapter, preserving any
-   * adapters/config the agent author already configured (mirrors `@mastra/slack`).
-   */
-  #createAgentChannels(agent, adapter) {
-    const existing = agent.getChannels();
-    const existingConfig = existing?.channelConfig;
-    const cfg = this.#config;
-    const entry = {
-      adapter,
-      ...resolveTelegramAdapterConfig(cfg),
-      // Telegram has no Block Kit; default tool rendering to plain text so
-      // 'cards'/'grouped'/'timeline' don't degrade to fallback text unexpectedly.
-      toolDisplay: cfg.toolDisplay ?? "text",
-      ...cfg.cors !== void 0 ? { cors: cfg.cors } : {},
-      ...cfg.formatError !== void 0 ? { formatError: cfg.formatError } : {}
-    };
-    const channels = new AgentChannels({
-      ...existingConfig,
-      adapters: { ...existingConfig?.adapters, [PLATFORM]: entry },
-      userName: agent.name,
-      handlers: cfg.handlers ?? existingConfig?.handlers,
-      inlineMedia: cfg.inlineMedia ?? existingConfig?.inlineMedia,
-      inlineLinks: cfg.inlineLinks ?? existingConfig?.inlineLinks,
-      state: cfg.state ?? existingConfig?.state,
-      threadContext: cfg.threadContext ?? existingConfig?.threadContext,
-      chatOptions: cfg.chatOptions ?? existingConfig?.chatOptions,
-      tools: cfg.tools ?? existingConfig?.tools,
-      resolveResourceId: cfg.resolveResourceId ?? existingConfig?.resolveResourceId,
-      waitUntil: cfg.waitUntil ?? existingConfig?.waitUntil,
-      resolveWaitUntil: cfg.resolveWaitUntil ?? existingConfig?.resolveWaitUntil
-    });
-    agent.setChannels(channels);
-    return channels;
-  }
-  async #autoInitialize() {
-    if (!this.#mastra) return;
-    await this.initialize();
-  }
-  #resolveAgent(agentId) {
-    try {
-      return this.#mastra?.getAgentById(agentId);
-    } catch {
-      return void 0;
-    }
-  }
-  async #getStore() {
-    if (this.#store) return this.#store;
-    const encryptionKey = this.#config.encryptionKey ?? process.env.MASTRA_ENCRYPTION_KEY;
-    this.#store = new TelegramInstallStore(await this.#resolveStorage(), encryptionKey);
-    return this.#store;
-  }
-  async #resolveStorage() {
-    if (this.#config.storage) return this.#config.storage;
-    const mastraStore = this.#mastra?.getStorage();
-    if (mastraStore) {
-      try {
-        await mastraStore.init();
-        const channels = await mastraStore.getStore("channels");
-        if (channels) return channels;
-      } catch {
-      }
-    }
-    return new InMemoryChannelsStorage();
-  }
-  #getBaseUrl() {
-    if (this.#config.baseUrl) return stripTrailingSlash(this.#config.baseUrl);
-    const server = this.#mastra?.getServer();
-    if (!server) return void 0;
-    const protocol = server.studioProtocol ?? "http";
-    const host = server.studioHost ?? server.host ?? "localhost";
-    const port = server.studioPort ?? server.port ?? (Number(process.env.PORT) || 4111);
-    const includePort = !(protocol === "https" && port === 443 || protocol === "http" && port === 80);
-    return includePort ? `${protocol}://${host}:${port}` : `${protocol}://${host}`;
-  }
+	id = PLATFORM;
+	#config;
+	#mastra;
+	#store;
+	/** Live adapters, keyed by installation id. */
+	#adapters = /* @__PURE__ */ new Map();
+	/** Cached sync view of whether any active bot is registered (for {@link getInfo}). */
+	#configured = false;
+	#initPromise = null;
+	constructor(config = {}) {
+		this.#config = config;
+	}
+	/**
+	* Called by Mastra when this channel is registered.
+	* @internal
+	*/
+	__attach(mastra) {
+		if (this.#mastra && this.#mastra !== mastra) {
+			this.#initPromise = null;
+			this.#store = void 0;
+			this.#adapters.clear();
+			this.#configured = false;
+		}
+		this.#mastra = mastra;
+	}
+	/**
+	* Per-bot webhook route. A single POST endpoint keyed by an opaque
+	* `webhookId`; the per-bot secret is verified from the request header, never
+	* carried in the URL. Auto-initializes on first hit (mirrors `@mastra/slack`).
+	*/
+	getRoutes() {
+		const self = this;
+		const withInit = (handler) => {
+			return async ({ mastra }) => {
+				self.#mastra = mastra;
+				await self.#autoInitialize();
+				return handler.bind(self);
+			};
+		};
+		return [{
+			path: `/${PLATFORM}/events/:webhookId`,
+			method: "POST",
+			requiresAuth: false,
+			createHandler: withInit(this.#handleWebhook)
+		}];
+	}
+	/** Discovery metadata for the editor UI. */
+	getInfo() {
+		return {
+			id: this.id,
+			name: "Telegram",
+			isConfigured: this.#configured,
+			connectOptionsSchema: {
+				type: "object",
+				properties: {
+					botToken: {
+						type: "string",
+						description: "BotFather bot token. Omit to receive a BotFather deep link instead."
+					},
+					name: {
+						type: "string",
+						description: "Display name for the bot (defaults to the bot's @username)."
+					}
+				}
+			}
+		};
+	}
+	/**
+	* Restore installations from storage: rebuild an adapter per active bot and
+	* inject `AgentChannels` so the agent can receive events immediately.
+	* Idempotent. Does not re-register webhooks (they persist server-side across
+	* restarts); reconnect an agent if its `baseUrl` changed.
+	*/
+	async initialize() {
+		if (this.#initPromise) return this.#initPromise;
+		this.#initPromise = this.#doInitialize();
+		try {
+			await this.#initPromise;
+		} catch (err) {
+			this.#initPromise = null;
+			throw err;
+		}
+	}
+	async #doInitialize() {
+		const active = (await (await this.#getStore()).list()).filter((i) => i.status === "active");
+		this.#configured = active.length > 0;
+		for (const installation of active) try {
+			await this.#activateInstallation(installation);
+		} catch (err) {
+			console.error(`[Telegram] Failed to restore installation "${installation.id}":`, err);
+		}
+	}
+	/**
+	* Update runtime provider settings. Telegram has no global auth credential to
+	* clear (per-bot tokens are managed via {@link connect}/{@link disconnect}),
+	* so `null` is a no-op; an object merges `apiBaseUrl`/`baseUrl` overrides.
+	*/
+	async configure(credentials) {
+		if (credentials === null) return;
+		const apiBaseUrlChanged = credentials.apiBaseUrl !== void 0 && credentials.apiBaseUrl !== this.#config.apiBaseUrl;
+		this.#config = {
+			...this.#config,
+			...credentials
+		};
+		if (!apiBaseUrlChanged) return;
+		const wasInitialized = this.#initPromise !== null;
+		for (const adapter of this.#adapters.values()) try {
+			await adapter.stopPolling();
+		} catch (err) {
+			console.warn("[Telegram] Failed to stop polling while reconfiguring:", err);
+		}
+		this.#adapters.clear();
+		this.#initPromise = null;
+		if (wasInitialized) await this.initialize();
+	}
+	/**
+	* Connect an agent to a Telegram bot.
+	*
+	* - With `options.botToken`: validate via `getMe`, mint a per-bot webhook
+	*   secret, persist the installation, register the transport (webhook or
+	*   polling), and return `{ type: 'immediate' }`.
+	* - Without a token: persist a pending installation and return
+	*   `{ type: 'deep_link' }` pointing at BotFather.
+	*/
+	async connect(agentId, options = {}) {
+		const store = await this.#getStore();
+		const existing = await store.getByAgent(agentId);
+		if (existing?.status === "active") throw new Error(`Agent "${agentId}" is already connected to Telegram. Disconnect first to reconnect.`);
+		if (!options.botToken) {
+			const installationId = existing?.id ?? randomUUID();
+			await store.save({
+				id: installationId,
+				agentId,
+				webhookId: existing?.webhookId ?? randomUUID(),
+				status: "pending",
+				installedAt: existing?.installedAt ?? /* @__PURE__ */ new Date()
+			});
+			return {
+				type: "deep_link",
+				url: BOTFATHER_DEEP_LINK,
+				installationId
+			};
+		}
+		const me = await getMe(options.botToken, this.#apiBaseUrl());
+		const installationId = existing?.id ?? randomUUID();
+		const webhookId = existing?.webhookId ?? randomUUID();
+		const baseUrl = this.#getBaseUrl();
+		const mode = this.#resolveMode(baseUrl);
+		if (mode === "webhook" && !baseUrl) throw new Error("TelegramProvider needs a baseUrl to register a webhook. Set `baseUrl`, configure the Mastra server, or use `mode: \"polling\"`.");
+		const webhookUrl = mode === "webhook" ? `${baseUrl}/${PLATFORM}/events/${webhookId}` : void 0;
+		const commands = normalizeCommands(options.commands ?? this.#config.commands ?? DEFAULT_COMMANDS);
+		const installation = {
+			id: installationId,
+			agentId,
+			webhookId,
+			status: "active",
+			botToken: options.botToken,
+			secretToken: generateSecretToken(),
+			username: options.name ?? me.username ?? me.first_name,
+			webhookUrl,
+			commands: commands.length ? commands : void 0,
+			installedAt: existing?.installedAt ?? /* @__PURE__ */ new Date()
+		};
+		await this.#registerTransport(installation, mode);
+		await this.#registerCommands(installation);
+		await store.save(installation);
+		await this.#activateInstallation(installation);
+		this.#configured = true;
+		await this.#config.onInstall?.(installation);
+		return {
+			type: "immediate",
+			installationId
+		};
+	}
+	/** Disconnect an agent from Telegram, removing its webhook and installation. */
+	async disconnect(agentId) {
+		const store = await this.#getStore();
+		const existing = await store.getByAgent(agentId);
+		if (!existing) throw new Error(`No Telegram installation found for agent "${agentId}"`);
+		const adapter = this.#adapters.get(existing.id);
+		if (adapter) try {
+			await adapter.stopPolling();
+		} catch (err) {
+			console.warn(`[Telegram] Failed to stop polling for agent "${agentId}":`, err);
+		}
+		if (existing.botToken) try {
+			await deleteWebhook(existing.botToken, true, this.#apiBaseUrl());
+		} catch (err) {
+			console.warn(`[Telegram] Failed to delete webhook for agent "${agentId}":`, err);
+		}
+		this.#adapters.delete(existing.id);
+		await store.deleteByAgent(agentId);
+		this.#configured = (await store.list()).some((i) => i.status === "active");
+	}
+	/** List installations (public info only — no tokens or secrets). */
+	async listInstallations() {
+		return (await (await this.#getStore()).list()).map(toInstallationInfo);
+	}
+	/**
+	* Get the full installation for an agent (includes the bot token / secret).
+	* Returns `null` if the agent has no Telegram installation. Mirrors
+	* `SlackProvider.getInstallation`.
+	*/
+	async getInstallation(agentId) {
+		return await (await this.#getStore()).getByAgent(agentId) ?? null;
+	}
+	/**
+	* Whether at least one bot is actively registered. Mirrors
+	* `SlackProvider.isConfigured` (Telegram has no global credential to check —
+	* "configured" means an active installation exists).
+	*/
+	isConfigured() {
+		return this.#configured;
+	}
+	/**
+	* Get the live `TelegramAdapter` for an installation id, if one is active.
+	* Used for message formatting/posting. Mirrors `SlackProvider.getAdapter`.
+	*/
+	getAdapter(installationId) {
+		return this.#adapters.get(installationId);
+	}
+	async #handleWebhook(c) {
+		const webhookId = c.req.param("webhookId");
+		if (!webhookId) return c.json({
+			ok: false,
+			error: "Missing webhookId"
+		}, 400);
+		const installation = await (await this.#getStore()).getByWebhookId(webhookId);
+		if (!installation || installation.status !== "active") return c.json({
+			ok: false,
+			error: "Unknown webhook"
+		}, 404);
+		if (!secretMatches(c.req.header(SECRET_HEADER), installation.secretToken)) return c.json({
+			ok: false,
+			error: "Invalid secret token"
+		}, 401);
+		const agent = this.#resolveAgent(installation.agentId);
+		if (!agent || !this.#mastra) return c.json({ ok: true });
+		const adapter = this.#getOrCreateAdapter(installation);
+		let channels = agent.getChannels();
+		if (!channels || channels.adapters["telegram"] !== adapter) {
+			channels = this.#createAgentChannels(agent, adapter);
+			await channels.initialize(this.#mastra);
+		}
+		const waitUntil = this.#config.waitUntil ?? resolveWaitUntil(c);
+		try {
+			return await channels.handleWebhookEvent(PLATFORM, c.req.raw, waitUntil ? { waitUntil } : void 0);
+		} catch (err) {
+			console.error("[Telegram] Error delegating to AgentChannels:", err);
+			return c.json({ ok: true });
+		}
+	}
+	#apiBaseUrl() {
+		return this.#config.apiBaseUrl ?? "https://api.telegram.org";
+	}
+	#resolveMode(baseUrl) {
+		const mode = this.#config.mode ?? "auto";
+		if (mode === "auto") return baseUrl ? "webhook" : "polling";
+		return mode;
+	}
+	/** Register (or clear) the receive transport for a bot, enforcing the exclusion. */
+	async #registerTransport(installation, mode) {
+		if (!installation.botToken) return;
+		if (mode === "webhook" && installation.webhookUrl && installation.secretToken) await setWebhook(installation.botToken, {
+			url: installation.webhookUrl,
+			secretToken: installation.secretToken,
+			allowedUpdates: this.#config.allowedUpdates ?? [...DEFAULT_ALLOWED_UPDATES],
+			dropPendingUpdates: true
+		}, this.#apiBaseUrl());
+		else await deleteWebhook(installation.botToken, true, this.#apiBaseUrl());
+	}
+	/** Publish the bot's command list (best-effort — a failure won't block connect). */
+	async #registerCommands(installation) {
+		if (!installation.botToken || !installation.commands?.length) return;
+		try {
+			await setMyCommands(installation.botToken, {
+				commands: installation.commands,
+				scope: this.#config.commandScope
+			}, this.#apiBaseUrl());
+		} catch (err) {
+			console.warn(`[Telegram] Failed to register commands for agent "${installation.agentId}":`, err);
+		}
+	}
+	#getOrCreateAdapter(installation) {
+		const existing = this.#adapters.get(installation.id);
+		if (existing) return existing;
+		const adapter = createTelegramAdapter$1({
+			botToken: installation.botToken,
+			secretToken: installation.secretToken,
+			userName: installation.username,
+			apiBaseUrl: this.#apiBaseUrl(),
+			mode: installation.webhookUrl ? "webhook" : this.#config.mode ?? "auto",
+			...this.#config.logger !== void 0 ? { logger: this.#config.logger } : {},
+			...this.#config.longPolling !== void 0 ? { longPolling: this.#config.longPolling } : {}
+		});
+		this.#adapters.set(installation.id, adapter);
+		return adapter;
+	}
+	/** Rebuild the adapter and inject AgentChannels for an active installation. */
+	async #activateInstallation(installation) {
+		const agent = this.#resolveAgent(installation.agentId);
+		const adapter = this.#getOrCreateAdapter(installation);
+		if (agent && this.#mastra) await this.#createAgentChannels(agent, adapter).initialize(this.#mastra);
+	}
+	/**
+	* Create AgentChannels for an agent with the Telegram adapter, preserving any
+	* adapters/config the agent author already configured (mirrors `@mastra/slack`).
+	*/
+	#createAgentChannels(agent, adapter) {
+		const existingConfig = agent.getChannels()?.channelConfig;
+		const cfg = this.#config;
+		const entry = {
+			adapter,
+			...resolveTelegramAdapterConfig(cfg),
+			toolDisplay: cfg.toolDisplay ?? "text",
+			...cfg.cors !== void 0 ? { cors: cfg.cors } : {},
+			...cfg.formatError !== void 0 ? { formatError: cfg.formatError } : {}
+		};
+		const channels = new AgentChannels({
+			...existingConfig,
+			adapters: {
+				...existingConfig?.adapters,
+				[PLATFORM]: entry
+			},
+			userName: agent.name,
+			handlers: cfg.handlers ?? existingConfig?.handlers,
+			inlineMedia: cfg.inlineMedia ?? existingConfig?.inlineMedia,
+			inlineLinks: cfg.inlineLinks ?? existingConfig?.inlineLinks,
+			state: cfg.state ?? existingConfig?.state,
+			threadContext: cfg.threadContext ?? existingConfig?.threadContext,
+			chatOptions: cfg.chatOptions ?? existingConfig?.chatOptions,
+			tools: cfg.tools ?? existingConfig?.tools,
+			resolveResourceId: cfg.resolveResourceId ?? existingConfig?.resolveResourceId,
+			waitUntil: cfg.waitUntil ?? existingConfig?.waitUntil,
+			resolveWaitUntil: cfg.resolveWaitUntil ?? existingConfig?.resolveWaitUntil
+		});
+		agent.setChannels(channels);
+		return channels;
+	}
+	async #autoInitialize() {
+		if (!this.#mastra) return;
+		await this.initialize();
+	}
+	#resolveAgent(agentId) {
+		try {
+			return this.#mastra?.getAgentById(agentId);
+		} catch {
+			return;
+		}
+	}
+	async #getStore() {
+		if (this.#store) return this.#store;
+		const encryptionKey = this.#config.encryptionKey ?? process.env.MASTRA_ENCRYPTION_KEY;
+		this.#store = new TelegramInstallStore(await this.#resolveStorage(), encryptionKey);
+		return this.#store;
+	}
+	async #resolveStorage() {
+		if (this.#config.storage) return this.#config.storage;
+		const mastraStore = this.#mastra?.getStorage();
+		if (mastraStore) try {
+			await mastraStore.init();
+			const channels = await mastraStore.getStore("channels");
+			if (channels) return channels;
+		} catch {}
+		return new InMemoryChannelsStorage();
+	}
+	#getBaseUrl() {
+		if (this.#config.baseUrl) return stripTrailingSlash(this.#config.baseUrl);
+		const server = this.#mastra?.getServer();
+		if (!server) return void 0;
+		const protocol = server.studioProtocol ?? "http";
+		const host = server.studioHost ?? server.host ?? "localhost";
+		const port = server.studioPort ?? server.port ?? (Number(process.env.PORT) || 4111);
+		return !(protocol === "https" && port === 443 || protocol === "http" && port === 80) ? `${protocol}://${host}:${port}` : `${protocol}://${host}`;
+	}
 };
+/** Constant-time comparison of the webhook secret header. */
 function secretMatches(provided, expected) {
-  if (!provided || !expected) return false;
-  const a = Buffer.from(provided);
-  const b = Buffer.from(expected);
-  return a.length === b.length && timingSafeEqual(a, b);
+	if (!provided || !expected) return false;
+	const a = Buffer.from(provided);
+	const b = Buffer.from(expected);
+	return a.length === b.length && timingSafeEqual(a, b);
 }
 function stripTrailingSlash(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
+	return url.endsWith("/") ? url.slice(0, -1) : url;
 }
+//#endregion
+export { BOTFATHER_DEEP_LINK, DEFAULT_ALLOWED_UPDATES, DEFAULT_COMMANDS, PLATFORM, TELEGRAM_API_BASE_URL, TelegramAdapter, TelegramInstallStore, TelegramProvider, createTelegramAdapter, deleteWebhook, generateSecretToken, getMe, normalizeCommands, resolveTelegramAdapterConfig, setMyCommands, setWebhook, toInstallationInfo };
 
-// src/index.ts
-import { createTelegramAdapter as createTelegramAdapter2, TelegramAdapter } from "@chat-adapter/telegram";
-export {
-  BOTFATHER_DEEP_LINK,
-  DEFAULT_ALLOWED_UPDATES,
-  DEFAULT_COMMANDS,
-  PLATFORM,
-  TELEGRAM_API_BASE_URL,
-  TelegramAdapter,
-  TelegramInstallStore,
-  TelegramProvider,
-  createTelegramAdapter2 as createTelegramAdapter,
-  deleteWebhook,
-  generateSecretToken,
-  getMe,
-  normalizeCommands,
-  resolveTelegramAdapterConfig,
-  setMyCommands,
-  setWebhook,
-  toInstallationInfo
-};
 //# sourceMappingURL=index.js.map