@elizaos/plugin-telegram 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/index.d.ts

@@ -1 +1,622 @@
-export * from "@elizaos/core";
+import { MessagePayload, WorldPayload, EventPayload, EntityPayload, Content, IAgentRuntime, Media, Service, MessageConnectorQueryContext, MessageConnectorTarget, TargetInfo, Memory, MessageConnectorChatContext, UUID, MessageConnectorUserContext, ConnectorAccountProvider, Plugin } from '@elizaos/core';
+import { Message, ReactionType, Chat, Update } from '@telegraf/types';
+import { Context, Telegraf, NarrowedContext } from 'telegraf';
+export { TelegramAccountApiCredentials, TelegramAccountAuthAccount, TelegramAccountAuthSession, TelegramAccountAuthSessionLike, TelegramAccountAuthSnapshot, TelegramAccountAuthStatus, TelegramAccountConnectorConfig, clearTelegramAccountAuthState, clearTelegramAccountSession, defaultTelegramAccountDeviceModel, defaultTelegramAccountSystemVersion, loadTelegramAccountSessionString, resolveTelegramAccountSessionFile, saveTelegramAccountSessionString, telegramAccountAuthStateExists, telegramAccountSessionExists } from './account-auth-service.js';
+import 'telegram';
+import 'telegram/sessions/index.js';
+
+/**
+ * Telegram account (user-account) auth HTTP routes.
+ *
+ * Provides a multi-step login flow for linking a personal Telegram account
+ * (as opposed to a bot token) using the `telegram` library (GramJS):
+ *
+ *   GET  /api/telegram-account/status        current auth/connection status
+ *   POST /api/telegram-account/auth/start    begin login (phone + optional app creds)
+ *   POST /api/telegram-account/auth/submit   submit provisioning code, telegram code, or 2FA password
+ *   POST /api/telegram-account/disconnect    tear down session + clear saved credentials
+ *
+ * These routes are registered with `rawPath: true` so they mount at their
+ * legacy paths without the plugin-name prefix.
+ */
+
+/** Called on plugin shutdown to clean up the auth session. */
+declare function stopTelegramAccountAuthSession(): Promise<void>;
+
+/**
+ * Extention of the core Content type just for Telegram
+ */
+interface TelegramContent extends Content {
+    /** Array of buttons */
+    buttons?: Button[];
+}
+/**
+ * Represents a flexible button configuration
+ */
+type Button = {
+    /** The type of button */
+    kind: "login" | "url";
+    /** The text to display on the button */
+    text: string;
+    /** The URL or endpoint the button should link to */
+    url: string;
+};
+/**
+ * Telegram-specific event types
+ */
+declare enum TelegramEventTypes {
+    WORLD_JOINED = "TELEGRAM_WORLD_JOINED",
+    WORLD_CONNECTED = "TELEGRAM_WORLD_CONNECTED",
+    WORLD_LEFT = "TELEGRAM_WORLD_LEFT",
+    ENTITY_JOINED = "TELEGRAM_ENTITY_JOINED",
+    ENTITY_LEFT = "TELEGRAM_ENTITY_LEFT",
+    ENTITY_UPDATED = "TELEGRAM_ENTITY_UPDATED",
+    MESSAGE_RECEIVED = "TELEGRAM_MESSAGE_RECEIVED",
+    MESSAGE_SENT = "TELEGRAM_MESSAGE_SENT",
+    REACTION_RECEIVED = "TELEGRAM_REACTION_RECEIVED",
+    INTERACTION_RECEIVED = "TELEGRAM_INTERACTION_RECEIVED",
+    SLASH_START = "TELEGRAM_SLASH_START"
+}
+/**
+ * Telegram-specific event payload map
+ */
+interface TelegramEventPayloadMap {
+    [TelegramEventTypes.MESSAGE_RECEIVED]: TelegramMessageReceivedPayload;
+    [TelegramEventTypes.MESSAGE_SENT]: TelegramMessageSentPayload;
+    [TelegramEventTypes.REACTION_RECEIVED]: TelegramReactionReceivedPayload;
+    [TelegramEventTypes.WORLD_JOINED]: TelegramWorldPayload;
+    [TelegramEventTypes.WORLD_CONNECTED]: TelegramWorldPayload;
+    [TelegramEventTypes.WORLD_LEFT]: TelegramWorldPayload;
+    [TelegramEventTypes.SLASH_START]: TelegramSlashStartPayload;
+    [TelegramEventTypes.ENTITY_JOINED]: TelegramEntityPayload;
+    [TelegramEventTypes.ENTITY_LEFT]: TelegramEntityPayload;
+    [TelegramEventTypes.ENTITY_UPDATED]: TelegramEntityPayload;
+    [TelegramEventTypes.INTERACTION_RECEIVED]: TelegramReactionReceivedPayload;
+}
+declare module "@elizaos/core" {
+    interface EventPayloadMap extends TelegramEventPayloadMap {
+    }
+}
+interface TelegramSlashStartPayload extends EventPayload {
+    ctx: Context;
+}
+/**
+ * Telegram-specific message received payload
+ */
+interface TelegramMessageReceivedPayload extends MessagePayload {
+    /** The original Telegram context */
+    ctx: Context;
+    /** The original Telegram message */
+    originalMessage: Message;
+}
+/**
+ * Telegram-specific message sent payload
+ */
+interface TelegramMessageSentPayload extends MessagePayload {
+    /** The original Telegram messages */
+    originalMessages: Message[];
+    /** The chat ID where the message was sent */
+    chatId: number | string;
+}
+/**
+ * Telegram-specific reaction received payload
+ */
+interface TelegramReactionReceivedPayload extends TelegramMessageReceivedPayload {
+    /** The reaction type as a string */
+    reactionString: string;
+    /** The original reaction object */
+    originalReaction: ReactionType;
+}
+/**
+ * Telegram-specific world payload
+ */
+interface TelegramWorldPayload extends WorldPayload {
+    chat: Chat;
+    botUsername?: string;
+}
+/**
+ * Telegram-specific entity payload
+ */
+interface TelegramEntityPayload extends EntityPayload {
+    telegramUser: {
+        id: number;
+        username?: string;
+        first_name?: string;
+    };
+}
+
+/**
+ * Interface for structured document processing results.
+ */
+interface DocumentProcessingResult {
+    title: string;
+    fullText: string;
+    formattedDescription: string;
+    fileName: string;
+    mimeType: string | undefined;
+    fileSize: number | undefined;
+    error?: string;
+}
+/**
+ * Enum representing different types of media.
+ * @enum { string }
+ * @readonly
+ */
+declare enum MediaType {
+    PHOTO = "photo",
+    VIDEO = "video",
+    DOCUMENT = "document",
+    AUDIO = "audio",
+    ANIMATION = "animation"
+}
+/**
+ * Class representing a message manager.
+ * @class
+ */
+declare class MessageManager {
+    bot: Telegraf<Context>;
+    protected runtime: IAgentRuntime;
+    protected accountId: string;
+    /**
+     * Constructor for creating a new instance of a BotAgent.
+     *
+     * @param {Telegraf<Context>} bot - The Telegraf instance used for interacting with the bot platform.
+     * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+     */
+    constructor(bot: Telegraf<Context>, runtime: IAgentRuntime, accountId?: string);
+    private scopedTelegramKey;
+    /**
+     * Process an image from a Telegram message to extract the image URL and description.
+     *
+     * @param {Message} message - The Telegram message object containing the image.
+     * @returns {Promise<{ description: string } | null>} The description of the processed image or null if no image found.
+     */
+    processImage(message: Message): Promise<{
+        description: string;
+    } | null>;
+    /**
+     * Process a document from a Telegram message to extract the document URL and description.
+     * Handles PDFs and other document types by converting them to text when possible.
+     *
+     * @param {Message} message - The Telegram message object containing the document.
+     * @returns {Promise<{ description: string } | null>} The description of the processed document or null if no document found.
+     */
+    processDocument(message: Message): Promise<DocumentProcessingResult | null>;
+    /**
+     * Get the appropriate document processor based on MIME type.
+     */
+    private getDocumentProcessor;
+    /**
+     * Process PDF documents by converting them to text.
+     */
+    private processPdfDocument;
+    /**
+     * Process text documents by fetching their content.
+     */
+    private processTextDocument;
+    /**
+     * Processes the message content, documents, and images to generate
+     * processed content and media attachments.
+     *
+     * @param {Message} message The message to process
+     * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
+     */
+    processMessage(message: Message): Promise<{
+        processedContent: string;
+        attachments: Media[];
+    }>;
+    /**
+     * Sends a message in chunks, handling attachments and splitting the message if necessary
+     *
+     * @param {Context} ctx - The context object representing the current state of the bot
+     * @param {TelegramContent} content - The content of the message to be sent
+     * @param {number} [replyToMessageId] - The ID of the message to reply to, if any
+     * @returns {Promise<Message.TextMessage[]>} - An array of TextMessage objects representing the messages sent
+     */
+    sendMessageInChunks(ctx: Context, content: TelegramContent, replyToMessageId?: number, messageThreadId?: number): Promise<Message.TextMessage[]>;
+    /**
+     * Sends media to a chat using the Telegram API.
+     *
+     * @param {Context} ctx - The context object containing information about the current chat.
+     * @param {string} mediaPath - The path to the media to be sent, either a URL or a local file path.
+     * @param {MediaType} type - The type of media being sent (PHOTO, VIDEO, DOCUMENT, AUDIO, or ANIMATION).
+     * @param {string} [caption] - Optional caption for the media being sent.
+     *
+     * @returns {Promise<void>} A Promise that resolves when the media is successfully sent.
+     */
+    sendMedia(ctx: Context, mediaPath: string, type: MediaType, caption?: string): Promise<void>;
+    /**
+     * Splits a given text into an array of strings based on the maximum message length.
+     *
+     * @param {string} text - The text to split into chunks.
+     * @returns {string[]} An array of strings with each element representing a chunk of the original text.
+     */
+    private splitMessage;
+    /**
+     * Handle incoming messages from Telegram and process them accordingly.
+     * @param {Context} ctx - The context object containing information about the message.
+     * @returns {Promise<void>}
+     */
+    handleMessage(ctx: Context): Promise<void>;
+    /**
+     * Handles the reaction event triggered by a user reacting to a message.
+     * @param {NarrowedContext<Context<Update>, Update.MessageReactionUpdate>} ctx The context of the message reaction update
+     * @returns {Promise<void>} A Promise that resolves when the reaction handling is complete
+     */
+    handleReaction(ctx: NarrowedContext<Context<Update>, Update.MessageReactionUpdate>): Promise<void>;
+    /**
+     * Sends a message to a Telegram chat and emits appropriate events
+     * @param {number | string} chatId - The Telegram chat ID to send the message to
+     * @param {Content} content - The content to send
+     * @param {number} [replyToMessageId] - Optional message ID to reply to
+     * @returns {Promise<Message.TextMessage[]>} The sent messages
+     */
+    sendMessage(chatId: number | string, content: Content, replyToMessageId?: number, messageThreadId?: number): Promise<Message.TextMessage[]>;
+}
+
+/**
+ * TelegramOwnerPairingService
+ *
+ * Implements the connector side of the owner-pairing flow for Telegram:
+ *   - `/eliza_pair <code>` bot command: relays a 6-digit pair code to the
+ *     backend `verifyOwnerBindFromConnector` service and reports the result.
+ *   - `sendOwnerLoginDmLink({ externalId, link })`: called by the backend's
+ *     `/api/auth/login/owner/dm-link/request` handler to DM a login link to
+ *     the Telegram user identified by their numeric user ID.
+ *
+ * Hard rules:
+ *   - Backend is the authority. The connector only relays; it never decides
+ *     whether a binding succeeds.
+ *   - Fail closed: if the backend service is unreachable, we reply with an
+ *     explicit error message and do NOT silently succeed.
+ *   - Per-user rate limit on `/eliza_pair` invocations: 5 attempts per minute.
+ *   - DM-link sender never pre-fetches or auto-redeems the link.
+ *
+ * Telegram command naming: underscores instead of hyphens, per Telegram bot
+ * command conventions (commands must match [a-z0-9_]{1,32}).
+ */
+
+/** Service type string used by the backend to look up this service. */
+declare const TELEGRAM_OWNER_PAIRING_SERVICE_TYPE = "OWNER_PAIRING_TELEGRAM";
+/**
+ * Public service interface exposed via the runtime service registry.
+ * The backend's `owner-binding.ts` calls `sendOwnerLoginDmLink` when the
+ * user requests a DM login link via the dashboard.
+ */
+interface TelegramOwnerPairingService {
+    /**
+     * DMs the Telegram user identified by `externalId` (a numeric Telegram user
+     * ID as a string) with a login link. The link is presented as-is; this
+     * method never pre-fetches or auto-redeems it.
+     *
+     * Throws if the DM cannot be delivered (Telegram API error, bot blocked by
+     * user, etc.). The caller is responsible for surfacing the error.
+     */
+    sendOwnerLoginDmLink(params: {
+        externalId: string;
+        link: string;
+    }): Promise<void>;
+}
+declare class TelegramOwnerPairingServiceImpl extends Service implements TelegramOwnerPairingService {
+    static serviceType: string;
+    capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    /**
+     * Registers the /eliza_pair command with the active Telegraf bot instance
+     * by looking up the TelegramService from the runtime service registry.
+     * Called during `start`; it is safe to call this before or after the bot
+     * has finished initialising because Telegraf accepts handler registration
+     * at any point before `launch()`.
+     *
+     * If the TelegramService is unavailable, the command is not registered.
+     */
+    private registerPairCommand;
+    sendOwnerLoginDmLink(params: {
+        externalId: string;
+        link: string;
+    }): Promise<void>;
+}
+
+type TelegramConnectorReadParams = {
+    target?: TargetInfo;
+    limit?: number;
+    query?: string;
+};
+/**
+ * Class representing a Telegram service that allows the agent to send and receive messages on Telegram.
+ * This service handles all Telegram-specific functionality including:
+ * - Initializing and managing the Telegram bot
+ * - Setting up middleware for preprocessing messages
+ * - Handling message and reaction events
+ * - Synchronizing Telegram chats, users, and entities with the agent runtime
+ * - Managing forum topics as separate rooms
+ *
+ * @extends Service
+ */
+declare class TelegramService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    private bot;
+    messageManager: MessageManager | null;
+    private knownChats;
+    private syncedEntityIds;
+    private botToken;
+    private defaultAccountId;
+    private accountStates;
+    /**
+     * Constructor for TelegramService class.
+     * @param {IAgentRuntime} runtime - The runtime object for the agent.
+     */
+    constructor(runtime?: IAgentRuntime);
+    private createAccountRuntime;
+    private setDefaultAccountState;
+    private getDefaultAccountState;
+    private getAccountState;
+    private getAccountIds;
+    private resolveAccountIdFromContext;
+    private resolveAccountIdForTarget;
+    private scopedTelegramKey;
+    private knownChatKeyMatchesAccount;
+    /**
+     * Starts the Telegram service for the given runtime.
+     *
+     * @param {IAgentRuntime} runtime - The agent runtime to start the Telegram service for.
+     * @returns {Promise<TelegramService>} A promise that resolves with the initialized TelegramService.
+     */
+    static start(runtime: IAgentRuntime): Promise<TelegramService>;
+    /**
+     * Stops the agent runtime.
+     * @param {IAgentRuntime} runtime - The agent runtime to stop
+     */
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously stops the bot.
+     *
+     * @returns A Promise that resolves once the bot has stopped.
+     */
+    stop(): Promise<void>;
+    /**
+     * Initializes the Telegram bot by launching it, getting bot info, and setting up message manager.
+     * @returns {Promise<void>} A Promise that resolves when the initialization is complete.
+     */
+    private initializeBot;
+    /**
+     * Sets up the middleware chain for preprocessing messages before they reach handlers.
+     * This critical method establishes a sequential processing pipeline that:
+     *
+     * 1. Authorization - Verifies if a chat is allowed to interact with the bot based on configured settings
+     * 2. Chat Discovery - Ensures chat entities and worlds exist in the runtime, creating them if needed
+     * 3. Forum Topics - Handles Telegram forum topics as separate rooms for better conversation management
+     * 4. Entity Synchronization - Ensures message senders are properly synchronized as entities
+     *
+     * The middleware chain runs in sequence for each message, with each step potentially
+     * enriching the context or stopping processing if conditions aren't met.
+     * This preprocessing is essential for maintaining consistent state before message handlers execute.
+     *
+     * @private
+     */
+    private setupMiddlewares;
+    /**
+     * Authorization middleware - checks if chat is allowed to interact with the bot
+     * based on the TELEGRAM_ALLOWED_CHATS configuration.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @param {Function} next - The function to call to proceed to the next middleware
+     * @returns {Promise<void>}
+     * @private
+     */
+    private authorizationMiddleware;
+    /**
+     * Chat and entity management middleware - handles new chats, forum topics, and entity synchronization.
+     * This middleware implements decision logic to determine which operations are needed based on
+     * the chat type and whether we've seen this chat before.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @param {Function} next - The function to call to proceed to the next middleware
+     * @returns {Promise<void>}
+     * @private
+     */
+    private chatAndEntityMiddleware;
+    /**
+     * Process an existing chat based on chat type and message properties.
+     * Different chat types require different processing steps.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @returns {Promise<void>}
+     * @private
+     */
+    private processExistingChat;
+    /**
+     * Sets up message and reaction handlers for the bot.
+     * Configures event handlers to process incoming messages and reactions.
+     *
+     * @private
+     */
+    private setupMessageHandlers;
+    /**
+     * Checks if a group is authorized, based on the TELEGRAM_ALLOWED_CHATS setting.
+     * @param {Context} ctx - The context of the incoming update.
+     * @returns {Promise<boolean>} A Promise that resolves with a boolean indicating if the group is authorized.
+     */
+    private isGroupAuthorized;
+    /**
+     * Synchronizes an entity from a message context with the runtime system.
+     * This method handles three cases:
+     * 1. Message sender - most common case
+     * 2. New chat member - when a user joins the chat
+     * 3. Left chat member - when a user leaves the chat
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @returns {Promise<void>}
+     * @private
+     */
+    private syncEntity;
+    /**
+     * Synchronizes the message sender entity with the runtime system.
+     * This is the most common entity sync case.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @param {UUID} worldId - The ID of the world
+     * @param {UUID} roomId - The ID of the room
+     * @param {string} chatId - The ID of the chat
+     * @returns {Promise<void>}
+     * @private
+     */
+    private syncMessageSender;
+    /**
+     * Synchronizes a new chat member entity with the runtime system.
+     * Triggered when a user joins the chat.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @param {UUID} worldId - The ID of the world
+     * @param {UUID} roomId - The ID of the room
+     * @param {string} chatId - The ID of the chat
+     * @returns {Promise<void>}
+     * @private
+     */
+    private syncNewChatMember;
+    /**
+     * Updates entity status when a user leaves the chat.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @returns {Promise<void>}
+     * @private
+     */
+    private syncLeftChatMember;
+    /**
+     * Handles forum topics by creating appropriate rooms in the runtime system.
+     * This enables proper conversation management for Telegram's forum feature.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @returns {Promise<void>}
+     * @private
+     */
+    private handleForumTopic;
+    /**
+     * Builds entity for message sender
+     */
+    private buildMsgSenderEntity;
+    /**
+     * Handles new chat discovery and emits WORLD_JOINED event.
+     * This is a critical function that ensures new chats are properly
+     * registered in the runtime system and appropriate events are emitted.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @returns {Promise<void>}
+     * @private
+     */
+    private handleNewChat;
+    /**
+     * Processes entities in batches to prevent overwhelming the system.
+     *
+     * @param {Entity[]} entities - The entities to process
+     * @param {UUID} roomId - The ID of the room to connect entities to
+     * @param {string} channelId - The channel ID
+     * @param {ChannelType} roomType - The type of the room
+     * @param {UUID} worldId - The ID of the world
+     * @returns {Promise<void>}
+     * @private
+     */
+    private batchProcessEntities;
+    /**
+     * Gets chat title and channel type based on Telegram chat type.
+     * Maps Telegram-specific chat types to standardized system types.
+     *
+     * @param {any} chat - The Telegram chat object
+     * @returns {Object} Object containing chatTitle and channelType
+     * @private
+     */
+    private getChatTypeInfo;
+    /**
+     * Builds standardized entity representations from Telegram chat data.
+     * Transforms Telegram-specific user data into system-standard Entity objects.
+     *
+     * @param {any} chat - The Telegram chat object
+     * @returns {Promise<Entity[]>} Array of standardized Entity objects
+     * @private
+     */
+    private buildStandardizedEntities;
+    /**
+     * Extracts and builds the room object for a forum topic from a message context.
+     * This refactored method can be used both in middleware and when handling new chats.
+     *
+     * @param {Context} ctx - The context of the incoming update
+     * @param {UUID} worldId - The ID of the world the topic belongs to
+     * @returns {Promise<Room | null>} A Promise that resolves with the room or null if not a topic
+     * @private
+     */
+    private buildForumTopicRoom;
+    private buildConnectorChatTarget;
+    private buildConnectorRoomTarget;
+    private dedupeConnectorTargets;
+    private getTelegramChatForTarget;
+    resolveConnectorTargets(query: string, context: MessageConnectorQueryContext): Promise<MessageConnectorTarget[]>;
+    listConnectorRooms(context: MessageConnectorQueryContext): Promise<MessageConnectorTarget[]>;
+    listRecentConnectorTargets(context: MessageConnectorQueryContext): Promise<MessageConnectorTarget[]>;
+    fetchConnectorMessages(context: MessageConnectorQueryContext, params?: TelegramConnectorReadParams): Promise<Memory[]>;
+    searchConnectorMessages(context: MessageConnectorQueryContext, params: TelegramConnectorReadParams & {
+        query: string;
+    }): Promise<Memory[]>;
+    getConnectorChatContext(target: TargetInfo, context: MessageConnectorQueryContext): Promise<MessageConnectorChatContext | null>;
+    getConnectorUserContext(entityId: UUID | string, context: MessageConnectorQueryContext): Promise<MessageConnectorUserContext | null>;
+    static registerSendHandlers(runtime: IAgentRuntime, serviceInstance: TelegramService): void;
+    handleSendMessage(runtime: IAgentRuntime, target: TargetInfo, content: Content): Promise<void>;
+}
+
+declare const DEFAULT_ACCOUNT_ID = "default";
+interface TelegramAccountConfig {
+    name?: string;
+    enabled?: boolean;
+    botToken?: string;
+    apiRoot?: string;
+    allowedChats?: string[];
+    autoReply?: boolean;
+    personal?: {
+        phone?: string;
+        appId?: string;
+        appHash?: string;
+        session?: string;
+        enabled?: boolean;
+    };
+}
+interface TelegramMultiAccountConfig {
+    enabled?: boolean;
+    botToken?: string;
+    apiRoot?: string;
+    accounts?: Record<string, TelegramAccountConfig>;
+}
+interface ResolvedTelegramAccount {
+    accountId: string;
+    enabled: boolean;
+    name?: string;
+    botToken?: string;
+    apiRoot: string;
+    config: TelegramAccountConfig;
+}
+declare function normalizeTelegramAccountId(accountId?: string | null): string;
+declare function getTelegramMultiAccountConfig(runtime: IAgentRuntime): TelegramMultiAccountConfig;
+declare function listTelegramAccountIds(runtime: IAgentRuntime): string[];
+declare function resolveDefaultTelegramAccountId(runtime: IAgentRuntime): string;
+declare function resolveTelegramAccount(runtime: IAgentRuntime, accountId?: string | null): ResolvedTelegramAccount;
+declare function listEnabledTelegramAccounts(runtime: IAgentRuntime): ResolvedTelegramAccount[];
+
+/**
+ * Telegram ConnectorAccountManager provider.
+ *
+ * Bridges plugin-telegram to the @elizaos/core ConnectorAccountManager so the
+ * generic HTTP CRUD surface can list, create, patch, and delete Telegram
+ * accounts. Telegram bots authenticate via a long-lived bot token (no OAuth);
+ * `startOAuth` / `completeOAuth` are intentionally not implemented.
+ *
+ * Single-account env-only configurations (TELEGRAM_BOT_TOKEN) are surfaced as
+ * a synthesized 'default' account with role 'AGENT' so downstream consumers
+ * see a uniform list. Multi-account configs declared on character.settings.telegram
+ * are surfaced verbatim from manager-owned storage.
+ */
+
+declare function createTelegramConnectorAccountProvider(runtime: IAgentRuntime): ConnectorAccountProvider;
+
+declare const telegramPlugin: Plugin;
+
+export { DEFAULT_ACCOUNT_ID, MessageManager, type ResolvedTelegramAccount, TELEGRAM_OWNER_PAIRING_SERVICE_TYPE, type TelegramAccountConfig, type TelegramMultiAccountConfig, type TelegramOwnerPairingService, TelegramOwnerPairingServiceImpl, TelegramService, createTelegramConnectorAccountProvider, telegramPlugin as default, getTelegramMultiAccountConfig, listEnabledTelegramAccounts, listTelegramAccountIds, normalizeTelegramAccountId, resolveDefaultTelegramAccountId, resolveTelegramAccount, stopTelegramAccountAuthSession };