@elizaos/plugin-telegram 1.6.4 → 2.0.0-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/plugin-telegram",
-  "version": "1.6.4",
+  "version": "2.0.0-alpha.2",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -18,39 +18,35 @@
     "dist"
   ],
   "dependencies": {
-    "@elizaos/core": "^1.7.2",
+    "@elizaos/core": "2.0.0-alpha.2",
     "@telegraf/types": "7.1.0",
-    "@types/node": "^24.0.10",
+    "@types/node": "^25.0.3",
     "strip-literal": "^3.0.0",
     "telegraf": "4.16.3",
     "type-detect": "^4.1.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@elizaos/config": "^1.7.2",
-    "@eslint/js": "^9.17.0",
-    "@typescript-eslint/eslint-plugin": "^8.22.0",
-    "@typescript-eslint/parser": "^8.22.0",
-    "eslint": "^9.17.0",
-    "prettier": "3.5.3",
-    "tsup": "8.4.0",
-    "vitest": "1.6.1"
+    "@biomejs/biome": "^2.3.11",
+    "vitest": "^4.0.0"
   },
   "scripts": {
-    "build": "tsup && tsc",
-    "dev": "tsup --watch",
+    "build": "bun run build.ts",
+    "dev": "bun --hot build.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint ./src --fix && prettier --write ./src",
-    "lint:check": "eslint ./src",
+    "lint": "bunx @biomejs/biome check --write --unsafe .",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json tsconfig.tsbuildinfo",
-    "format": "prettier --write ./src",
-    "format:check": "prettier --check ./src"
+    "format": "bunx @biomejs/biome format --write .",
+    "format:check": "bunx @biomejs/biome format .",
+    "lint:check": "bunx @biomejs/biome check .",
+    "build:ts": "bun run build",
+    "typecheck": "tsc --noEmit"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "646c632924826e2b75c2304a75ee56959fe4a460",
+  "gitHead": "bc6cac8d36845d7cbde51a64307c6a57c16378ad",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/elizaos-plugins/plugin-telegram.git"

package/README.md

@@ -1,143 +0,0 @@
-# Telegram Client Plugin for ElizaOS
-
-This plugin integrates a Telegram client with ElizaOS, allowing characters in ElizaOS to interact via Telegram. It provides an easy setup for starting the Telegram client using the provided bot token and includes basic lifecycle management.
-
-## Features
-
-- **Seamless Telegram Integration**: Connects ElizaOS characters to Telegram through the bot API.
-- **Configuration Validation**: Ensures required settings are properly configured before starting.
-- **Startup Logging**: Logs successful initialization of the Telegram client for better debugging.
-- **Future-proof Design**: Provides a basic structure for stopping the client (currently unsupported).
-
-## Configuration Options
-
-Here are the available configuration options for the `character.json` file:
-
-| Key                             | Type    | Default  | Description                                                                                         |
-| ------------------------------- | ------- | -------- | --------------------------------------------------------------------------------------------------- |
-| `clients`                       | Array   | Required | Specifies the client type (e.g., `["telegram"]`).                                                   |
-| `allowDirectMessages`           | Boolean | `false`  | Determines whether the bot should respond to direct messages (DMs).                                 |
-| `shouldOnlyJoinInAllowedGroups` | Boolean | `false`  | Ensures the bot only joins and responds in specified groups.                                        |
-| `allowedGroupIds`               | Array   | `[]`     | Lists the group IDs the bot is allowed to interact with (requires `shouldOnlyJoinInAllowedGroups`). |
-| `messageTrackingLimit`          | Integer | `100`    | Sets the maximum number of messages to track in memory for each chat.                               |
-| `templates`                     | Object  | `{}`     | Allows customization of response templates for different message scenarios.                         |
-
-## Error 409: Conflict in Multiple Agents Environment
-
-When you encounter this error in your logs:
-
-```
-error: 409: Conflict: terminated by other getUpdates request; make sure that only one bot instance is running
-```
-
-This indicates a fundamental architectural limitation with the Telegram Bot API. The Telegram API strictly enforces that only one active connection can exist per bot token at any given time. This is by design to ensure reliable message delivery and prevent message duplication or loss.
-
-In ElizaOS multi-agent environments, this error commonly occurs when:
-
-1. **Multiple Agents Using Same Token**: Two or more agents (such as "Eliza" and another character) each have the `@elizaos/plugin-telegram` plugin enabled in their configuration
-2. **Simultaneous Initialization**: Each agent independently attempts to initialize its own Telegram service during startup
-3. **Token Collision**: All agents use the same `TELEGRAM_BOT_TOKEN` from your environment configuration
-4. **Connection Rejection**: When a second agent tries to establish a connection while another is already active, Telegram rejects it with a 409 error
-
-This is not a bug in ElizaOS or the Telegram plugin, but rather a result of using a shared resource (the bot token) that can only accept one connection at a time.
-
-## Example `<charactername>.character.json`
-
-Below is an example configuration file with all options:
-
-```json
-{
-  "clients": ["telegram"],
-  "allowDirectMessages": true,
-  "shouldOnlyJoinInAllowedGroups": true,
-  "allowedGroupIds": ["-123456789", "-987654321"],
-  "messageTrackingLimit": 100,
-  "templates": {
-    "telegramMessageHandlerTemplate": "Your custom template here"
-  },
-  "secrets": {
-    "key": "<your-bot-token>"
-  }
-}
-```
-
-## How to Modify Settings
-
-1. Locate the `character.json` file in your project directory.
-2. Update the file with the desired configuration options as shown in the example above.
-3. Save the file and restart the bot for the changes to take effect.
-
-## Best Practices
-
-- **Production**: Restrict bot access with `shouldOnlyJoinInAllowedGroups: true` and specify `allowedGroupIds` to ensure security.
-- **Token Management**: Always keep your bot token and backend tokens secure and never expose them in public repositories.
-
-## Pre-Requisites
-
-1. Add the bot token to the `.env` file in the project root:
-
-```env
-TELEGRAM_BOT_TOKEN=your-bot-token
-```
-
-2. Add the same token to your character configuration file:
-
-Create or modify `characters/your-character.json`:
-
-```json
-{
-  "clients": ["telegram"],
-  "secrets": {
-    "key": "<your-bot-token>"
-  }
-}
-```
-
-## From the project root:
-
-```bash
-npm run dev
-```
-
-## Or using bun:
-
-```bash
-bun start --character="characters/your-character.json"
-```
-
-## Utilizing Telegram Buttons
-
-To send a message with native Telegram buttons, include an array of buttons in the message content. The following action demonstrates how to initiate a login flow using a Telegram button.
-
-```typescript
-export const initAuthHandshakeAction: Action = {
-  name: 'INIT_AUTH_HANDSHAKE',
-  description: 'Initiates the identity linking and authentication flow for new users.',
-  validate: async (_runtime, _message, _state) => {
-    return _message.content.source === 'telegram';
-  },
-  handler: async (runtime, message, _state, _options, callback): Promise<boolean> => {
-    try {
-      const user = await getUser(message.userId);
-      if (user) return false;
-
-      callback({
-        text: "Let's get you set up with a new account",
-        buttons: [
-          {
-            text: '🔑 Authenticate with Telegram',
-            url: `${FRONTEND_URL}/integrations/telegram`,
-            kind: 'login',
-          },
-        ],
-      }).catch((error) => {
-        console.error('Error sending callback:', error);
-      });
-
-      return true;
-    } catch (error) {
-      ...
-    }
-  },
-};
-```

package/dist/constants.d.ts

@@ -1,10 +0,0 @@
-export declare const MESSAGE_CONSTANTS: {
-    readonly MAX_MESSAGES: 50;
-    readonly RECENT_MESSAGE_COUNT: 5;
-    readonly CHAT_HISTORY_COUNT: 10;
-    readonly DEFAULT_SIMILARITY_THRESHOLD: 0.6;
-    readonly DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.4;
-    readonly INTEREST_DECAY_TIME: number;
-    readonly PARTIAL_INTEREST_DECAY: number;
-};
-export declare const TELEGRAM_SERVICE_NAME = "telegram";

package/dist/environment.d.ts

@@ -1,17 +0,0 @@
-import { type IAgentRuntime } from '@elizaos/core';
-import { z } from 'zod';
-export declare const telegramEnvSchema: z.ZodObject<{
-    TELEGRAM_BOT_TOKEN: z.ZodString;
-}, z.core.$strip>;
-/**
- * Represents the type definition for configuring a Telegram bot based on the inferred schema.
- */
-export type TelegramConfig = z.infer<typeof telegramEnvSchema>;
-/**
- * Validates the Telegram configuration by retrieving the Telegram bot token from the runtime settings or environment variables.
- * Returns null if validation fails instead of throwing an error.
- *
- * @param {IAgentRuntime} runtime - The agent runtime used to get the setting.
- * @returns {Promise<TelegramConfig | null>} A promise that resolves with the validated Telegram configuration or null if invalid.
- */
-export declare function validateTelegramConfig(runtime: IAgentRuntime): Promise<TelegramConfig | null>;

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-import type { Plugin } from '@elizaos/core';
-import { TelegramService } from './service';
-import { MessageManager } from './messageManager';
-declare const telegramPlugin: Plugin;
-export { TelegramService, MessageManager };
-export default telegramPlugin;

package/dist/messageManager.d.ts

@@ -1,131 +0,0 @@
-import { type Content, type IAgentRuntime, type Media } from '@elizaos/core';
-import type { Message, Update } from '@telegraf/types';
-import type { Context, NarrowedContext, Telegraf } from 'telegraf';
-import { type TelegramContent } from './types';
-/**
- * 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
- */
-export declare enum MediaType {
-    PHOTO = "photo",
-    VIDEO = "video",
-    DOCUMENT = "document",
-    AUDIO = "audio",
-    ANIMATION = "animation"
-}
-/**
- * Class representing a message manager.
- * @class
- */
-export declare class MessageManager {
-    bot: Telegraf<Context>;
-    protected runtime: IAgentRuntime;
-    /**
-     * 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);
-    /**
-     * 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): 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): Promise<Message.TextMessage[]>;
-}
-export {};

package/dist/service.d.ts

@@ -1,218 +0,0 @@
-import { type Content, type IAgentRuntime, Service, type TargetInfo } from '@elizaos/core';
-import { MessageManager } from './messageManager';
-/**
- * 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
- */
-export declare class TelegramService extends Service {
-    static serviceType: string;
-    capabilityDescription: string;
-    private bot;
-    messageManager: MessageManager | null;
-    private options;
-    private knownChats;
-    private syncedEntityIds;
-    /**
-     * Constructor for TelegramService class.
-     * @param {IAgentRuntime} runtime - The runtime object for the agent.
-     */
-    constructor(runtime: IAgentRuntime);
-    /**
-     * 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;
-    static registerSendHandlers(runtime: IAgentRuntime, serviceInstance: TelegramService): void;
-    handleSendMessage(runtime: IAgentRuntime, target: TargetInfo, content: Content): Promise<void>;
-}

package/dist/tests.d.ts

@@ -1,52 +0,0 @@
-import { type IAgentRuntime, type TestSuite } from '@elizaos/core';
-import type { Context } from 'telegraf';
-/**
- * Represents a test suite for testing Telegram functionality.
- *
- * This test suite includes methods to initialize and validate a Telegram bot connection,
- * send basic text messages to a Telegram chat, send text messages with image attachments,
- * handle and process incoming Telegram messages, and process and validate image attachments
- * in incoming messages.
- *
- * @implements {TestSuite}
- */
-export declare class TelegramTestSuite implements TestSuite {
-    name: string;
-    private telegramClient;
-    private bot;
-    private messageManager;
-    tests: {
-        name: string;
-        fn: (runtime: IAgentRuntime) => Promise<void>;
-    }[];
-    /**
-     * Constructor for initializing a set of test cases for a Telegram bot.
-     *
-     * @constructor
-     * @property {Array<Object>} tests - An array of test cases with name and corresponding test functions.
-     * @property {string} tests.name - The name of the test case.
-     * @property {function} tests.fn - The test function to be executed.
-     */
-    constructor();
-    /**
-     * Retrieves the Telegram test chat ID from environment variables.
-     *
-     * Reference on getting the Telegram chat ID:
-     * https://stackoverflow.com/a/32572159
-     */
-    /**
-     * Validates the chat ID by checking if it is set in the runtime settings or environment variables.
-     * If not set, an error is thrown with a message instructing to provide a valid chat ID.
-     * @param {IAgentRuntime} runtime - The runtime object that provides access to the settings and environment variables.
-     * @throws {Error} If TELEGRAM_TEST_CHAT_ID is not set in the runtime settings or environment variables.
-     * @returns {string} The validated chat ID.
-     */
-    validateChatId(runtime: IAgentRuntime): string | number;
-    getChatInfo(runtime: IAgentRuntime): Promise<Context['chat']>;
-    testCreatingTelegramBot(runtime: IAgentRuntime): Promise<void>;
-    testSendingTextMessage(runtime: IAgentRuntime): Promise<void>;
-    testSendingMessageWithAttachment(runtime: IAgentRuntime): Promise<void>;
-    testHandlingMessage(runtime: IAgentRuntime): Promise<void>;
-    testProcessingImages(runtime: IAgentRuntime): Promise<void>;
-    getFileId(chatId: string, imageUrl: string): Promise<string>;
-}