@mastra/telegram 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,680 @@
+// src/telegram-provider.ts
+import { 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"
+];
+var BOTFATHER_DEEP_LINK = "https://t.me/botfather";
+
+// src/telegram-client.ts
+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;
+}
+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;
+}
+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
+  });
+}
+async function deleteWebhook(botToken, dropPendingUpdates = false, apiBaseUrl = TELEGRAM_API_BASE_URL) {
+  await botApiRequest(botToken, "deleteWebhook", apiBaseUrl, {
+    drop_pending_updates: dropPendingUpdates
+  });
+}
+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
+  });
+}
+function generateSecretToken() {
+  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" }
+];
+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;
+}
+
+// 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";
+function deriveKey(passphrase, salt) {
+  return Buffer.from(hkdfSync("sha256", passphrase, salt, HKDF_INFO, 32));
+}
+function isEncrypted(value) {
+  return value.startsWith(`${ALGO_PREFIX}:`);
+}
+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")}`;
+}
+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");
+}
+
+// src/install-store.ts
+var PLATFORM = "telegram";
+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
+    };
+  }
+};
+function toInstallationInfo(install) {
+  return {
+    id: install.id,
+    platform: PLATFORM,
+    agentId: install.agentId,
+    status: install.status,
+    displayName: install.username,
+    installedAt: install.installedAt
+  };
+}
+
+// src/telegram-provider.ts
+function resolveTelegramAdapterConfig(config) {
+  return {
+    streaming: config.streaming ?? true,
+    typingStatus: config.typingStatus ?? true
+  };
+}
+var SECRET_HEADER = "x-telegram-bot-api-secret-token";
+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}`;
+  }
+};
+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);
+}
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+
+// 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