@easbot/gateway 0.2.23 → 0.2.24

package/dist/index.d.cts

@@ -35,12 +35,12 @@ declare namespace Gateway {
 }
 
 declare const ChannelTypeSchema: z.ZodEnum<{
-    signal: "signal";
     telegram: "telegram";
     slack: "slack";
     feishu: "feishu";
     wechat: "wechat";
     webchat: "webchat";
+    signal: "signal";
     nostr: "nostr";
 }>;
 type ChannelType = z.infer<typeof ChannelTypeSchema>;
@@ -262,8 +262,8 @@ declare const AuthConfigSchema: z.ZodObject<{
 type AuthConfig = z.infer<typeof AuthConfigSchema>;
 declare const AgentSyncConfigSchema: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
-        push: "push";
         pull: "pull";
+        push: "push";
         both: "both";
     }>>;
     interval: z.ZodDefault<z.ZodNumber>;
@@ -297,8 +297,8 @@ declare const GatewayClusterConfigSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     sync: z.ZodOptional<z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
-            push: "push";
             pull: "pull";
+            push: "push";
             both: "both";
         }>>;
         interval: z.ZodDefault<z.ZodNumber>;
@@ -545,8 +545,8 @@ declare const GatewayConfigSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         sync: z.ZodOptional<z.ZodObject<{
             mode: z.ZodDefault<z.ZodEnum<{
-                push: "push";
                 pull: "pull";
+                push: "push";
                 both: "both";
             }>>;
             interval: z.ZodDefault<z.ZodNumber>;
@@ -603,6 +603,10 @@ declare const GatewayConfigSchema: z.ZodObject<{
         maxSessions: z.ZodDefault<z.ZodNumber>;
         persistenceFile: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        channel: z.ZodOptional<z.ZodString>;
+        fallbackChannels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     defaultAgent: z.ZodOptional<z.ZodString>;
     logLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         DEBUG: "DEBUG";
@@ -729,7 +733,7 @@ interface GatewaySession {
     createdAt: number;
     lastActiveAt: number;
 }
-interface SessionChannelInfo {
+interface SessionChannelInfo extends ChannelInfo {
     platform: PlatformType;
     channelId: string;
     chatId?: string;
@@ -756,6 +760,55 @@ interface SessionFilter {
 declare function generateSessionId(channel: SessionChannelInfo): string;
 declare function createDefaultSessionState(): SessionState;
 
+interface ContactProfile {
+    displayName?: string;
+    username?: string;
+    avatar?: string;
+    email?: string;
+    phone?: string;
+    locale?: string;
+    timezone?: string;
+}
+interface PlatformAlias {
+    stableId?: string;
+    username?: string;
+    displayName?: string;
+    chatId?: string;
+}
+interface PlatformAliases {
+    [platform: string]: PlatformAlias | undefined;
+}
+interface Contact {
+    uid: string;
+    platform: PlatformType;
+    stableId: string;
+    aliases: PlatformAliases;
+    profile: ContactProfile;
+    createdAt: number;
+    lastSeenAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface CreateContactParams {
+    platform: PlatformType;
+    stableId: string;
+    profile?: Partial<ContactProfile>;
+    aliases?: PlatformAliases;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateContactParams {
+    profile?: Partial<ContactProfile>;
+    aliases?: Partial<PlatformAliases>;
+    metadata?: Record<string, unknown>;
+}
+interface ContactQuery {
+    platform?: PlatformType;
+    username?: string;
+    email?: string;
+    phone?: string;
+    limit?: number;
+    offset?: number;
+}
+
 interface Subscriber {
     id: string;
     type: SubscriberType;
@@ -809,6 +862,7 @@ interface ClientInitializeMessage extends WebSocketMessageBase {
 interface ClientSubscribeMessage extends WebSocketMessageBase {
     type: 'subscribe';
     sessionId: string;
+    backendSessionId?: string;
     payload?: {
         eventTypes?: string[];
     };
@@ -1001,7 +1055,7 @@ interface CreateSessionRequest {
     };
     context?: Record<string, unknown>;
 }
-interface CreateSessionResponse {
+interface CreateSessionResponse$1 {
     id: string;
     createdAt: number;
 }
@@ -1016,10 +1070,15 @@ interface SendMessageRequest {
     }>;
     [key: string]: unknown;
 }
-interface SendMessageResponse {
+interface SendMessageResponse$1 {
     messageId: string;
     sessionId: string;
     createdAt: number;
+    metadata?: {
+        channel?: string;
+        channelSource?: string;
+        channelInfo?: ChannelInfo;
+    };
 }
 interface SubscriptionsResponse {
     subscriptions: Array<{
@@ -1252,6 +1311,46 @@ interface ConnectionPoolEvent<T = unknown> {
 }
 type ConnectionPoolEventCallback<T = unknown> = (event: ConnectionPoolEvent<T>) => void | Promise<void>;
 
+interface CancelEvent {
+    sessionId: string;
+    messageId: string;
+    processedBy: string;
+    reason: 'completed' | 'failed' | 'timeout';
+    timestamp: number;
+}
+type CancelEventHandler = (event: CancelEvent) => void | Promise<void>;
+declare class MessageRouter {
+    private log;
+    private subscribers;
+    private subscriptions;
+    private sessionSubscriptions;
+    private channelPlugins;
+    private lockManager;
+    private retryManager;
+    private cancelHandlers;
+    constructor();
+    onCancel(handler: CancelEventHandler): void;
+    offCancel(handler: CancelEventHandler): void;
+    private emitCancel;
+    route(message: GatewayMessage): Promise<RouteResult>;
+    completeMessage(sessionId: string, messageId: string, subscriberId: string, reason?: 'completed' | 'failed' | 'timeout'): Promise<void>;
+    scheduleRetry(message: GatewayMessage, error: Error): boolean;
+    subscribe(sessionId: string, subscriber: Subscriber): Promise<Subscription>;
+    unsubscribe(subscriptionId: string): Promise<void>;
+    unsubscribeAll(subscriberId: string): Promise<void>;
+    registerChannel(plugin: ChannelPlugin): void;
+    unregisterChannel(pluginId: string): void;
+    getSubscriber(subscriberId: string): Subscriber | undefined;
+    getSubscription(subscriptionId: string): Subscription | undefined;
+    getSubscriberCount(sessionId: string): number;
+    getStats(): {
+        subscribers: number;
+        subscriptions: number;
+        sessions: number;
+    };
+    shutdown(): Promise<void>;
+}
+
 interface LockState {
     sessionId: string;
     messageId: string;
@@ -1320,44 +1419,6 @@ declare class MessageRetryManager {
     };
 }
 
-interface CancelEvent {
-    sessionId: string;
-    messageId: string;
-    processedBy: string;
-    reason: 'completed' | 'failed' | 'timeout';
-    timestamp: number;
-}
-type CancelEventHandler = (event: CancelEvent) => void | Promise<void>;
-declare class MessageRouter {
-    private log;
-    private subscribers;
-    private subscriptions;
-    private sessionSubscriptions;
-    private channelPlugins;
-    private lockManager;
-    private retryManager;
-    private cancelHandlers;
-    constructor();
-    onCancel(handler: CancelEventHandler): void;
-    offCancel(handler: CancelEventHandler): void;
-    private emitCancel;
-    route(message: GatewayMessage): Promise<RouteResult>;
-    completeMessage(sessionId: string, messageId: string, subscriberId: string, reason?: 'completed' | 'failed' | 'timeout'): Promise<void>;
-    scheduleRetry(message: GatewayMessage, error: Error): boolean;
-    subscribe(sessionId: string, subscriber: Subscriber): Promise<Subscription>;
-    unsubscribe(subscriptionId: string): Promise<void>;
-    unsubscribeAll(subscriberId: string): Promise<void>;
-    registerChannel(plugin: ChannelPlugin): Promise<void>;
-    unregisterChannel(pluginId: string): Promise<void>;
-    getSubscriberCount(sessionId: string): number;
-    getAllSubscribers(): Subscriber[];
-    getChannelPlugin(pluginId: string): ChannelPlugin | undefined;
-    getAllChannelPlugins(): ChannelPlugin[];
-    getLockManager(): MessageLockManager;
-    getRetryManager(): MessageRetryManager;
-    shutdown(): Promise<void>;
-}
-
 interface SessionManagerConfig {
     enablePersistence: boolean;
     storagePath: string;
@@ -1431,15 +1492,11 @@ declare class AgentSyncManager {
     private remoteAgents;
     private syncTimer;
     private running;
-    private httpClient;
     constructor(options: {
         registry: AgentRegistry;
         localNodeId: string;
         localNodeName: string;
         config?: Partial<SyncConfig>;
-        httpClient?: {
-            fetch: typeof fetch;
-        };
     });
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -1513,10 +1570,14 @@ declare abstract class BaseChannelPlugin implements ChannelPlugin {
     protected messageHandler: MessageHandler | null;
     protected _status: ChannelStatusType;
     protected lastActivity: number;
+    private startPromise;
+    private stopPromise;
     constructor();
     protected initLog(): void;
     start(config: ChannelConfig, messageHandler: MessageHandler): Promise<void>;
+    private doStartInternal;
     stop(): Promise<void>;
+    private doStopInternal;
     healthCheck(): Promise<ChannelHealth>;
     getStatus(): ChannelStatus;
     abstract send(message: GatewayMessage): Promise<string>;
@@ -1524,10 +1585,50 @@ declare abstract class BaseChannelPlugin implements ChannelPlugin {
     protected abstract doStop(): Promise<void>;
     protected doHealthCheck(): Promise<boolean>;
     protected updateActivity(): void;
+    protected extractText(message: GatewayMessage): string;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
     protected handleMessage(message: GatewayMessage): Promise<void>;
     protected handleEvent(type: string, data?: unknown): Promise<void>;
 }
 
+interface PluginLoaderConfig {
+    pluginDir?: string;
+    autoDiscover?: boolean;
+    healthCheckInterval?: number;
+    healthCheckTimeout?: number;
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectInitialDelay?: number;
+    reconnectMaxDelay?: number;
+}
+declare class ChannelPluginLoader {
+    private log;
+    private plugins;
+    private messageHandler;
+    private healthCheckTimer;
+    private config;
+    private backoffPolicy;
+    constructor(config?: PluginLoaderConfig);
+    setMessageHandler(handler: MessageHandler): void;
+    register(plugin: ChannelPlugin, config: ChannelConfig): Promise<void>;
+    unregister(pluginId: string): Promise<void>;
+    start(pluginId: string): Promise<void>;
+    stop(pluginId: string): Promise<void>;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    getPlugin(pluginId: string): ChannelPlugin | undefined;
+    getAllPlugins(): ChannelPlugin[];
+    getRunningPlugins(): ChannelPlugin[];
+    isRunning(pluginId: string): boolean;
+    healthCheck(pluginId: string): Promise<ChannelHealth>;
+    healthCheckAll(): Promise<Map<string, ChannelHealth>>;
+    startHealthCheckTimer(): void;
+    stopHealthCheckTimer(): void;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private calculateBackoffDelay;
+}
+
 interface MessageRecord {
     message: GatewayMessage;
     status: MessageStatus;
@@ -1543,13 +1644,21 @@ interface MessageStoreConfig {
     storagePath: string;
     maxRetentionDays: number;
     maxRecords: number;
+    cleanupIntervalMs: number;
+    cleanupBatchSize: number;
+    lruEnabled: boolean;
+    lruMaxMemory?: number;
 }
 declare class MessageStore {
     private log;
     private config;
     private messages;
     private sessionMessages;
+    private cleanupTimer;
+    private accessOrder;
     constructor(config?: Partial<MessageStoreConfig>);
+    private startCleanupTimer;
+    private performCleanup;
     store(message: GatewayMessage): Promise<MessageRecord>;
     get(messageId: string): MessageRecord | undefined;
     updateStatus(messageId: string, status: MessageStatus, options?: {
@@ -1561,7 +1670,10 @@ declare class MessageStore {
     getSessionHistory(sessionId: string, limit?: number): MessageRecord[];
     getPendingMessages(sessionId?: string): MessageRecord[];
     getFailedMessages(maxRetries?: number): MessageRecord[];
-    cleanup(): Promise<number>;
+    cleanup(): number;
+    private evictLRU;
+    private updateAccessOrder;
+    private deleteMessage;
     getStats(): {
         total: number;
         pending: number;
@@ -1569,7 +1681,9 @@ declare class MessageStore {
         completed: number;
         failed: number;
         cancelled: number;
+        sessions: number;
     };
+    close(): Promise<void>;
 }
 
 interface SerializableSession {
@@ -1620,37 +1734,101 @@ declare class SessionStore {
     };
 }
 
-interface PluginLoaderConfig {
-    pluginDir?: string;
-    autoDiscover?: boolean;
-    healthCheckInterval?: number;
-    healthCheckTimeout?: number;
+interface ContactListResult {
+    contacts: Contact[];
+    total: number;
+    hasMore: boolean;
+}
+interface IContactStore {
+    initialize?(): Promise<void>;
+    save(contact: Contact): Promise<Contact>;
+    create(params: CreateContactParams): Promise<Contact>;
+    getOrCreate(platform: PlatformType, stableId: string, profile?: Partial<ContactProfile>): Promise<Contact>;
+    findByUid(uid: string): Promise<Contact | null>;
+    findByPlatformId(platform: PlatformType, stableId: string): Promise<Contact | null>;
+    update(uid: string, params: UpdateContactParams): Promise<Contact | null>;
+    touch(uid: string): Promise<void>;
+    delete(uid: string): Promise<boolean>;
+    listByPlatform(platform: PlatformType, limit?: number, offset?: number): Promise<ContactListResult>;
+    findByUsername(username: string): Promise<Contact | null>;
+    findByEmail(email: string): Promise<Contact | null>;
+    findByPhone(phone: string): Promise<Contact | null>;
+    search(query: ContactQuery): Promise<ContactListResult>;
+    count(platform?: PlatformType): Promise<number>;
+    exists(uid: string): Promise<boolean>;
+    addAlias(uid: string, platform: PlatformType, alias: {
+        stableId?: string;
+        username?: string;
+        displayName?: string;
+        chatId?: string;
+    }): Promise<Contact | null>;
+    close(): Promise<void>;
 }
-declare class ChannelPluginLoader {
-    private log;
-    private plugins;
-    private messageHandler;
-    private healthCheckTimer;
-    private config;
-    constructor(config?: PluginLoaderConfig);
-    setMessageHandler(handler: MessageHandler): void;
-    register(plugin: ChannelPlugin, config: ChannelConfig): Promise<void>;
-    unregister(pluginId: string): Promise<void>;
-    start(pluginId: string): Promise<void>;
-    stop(pluginId: string): Promise<void>;
-    startAll(): Promise<void>;
-    stopAll(): Promise<void>;
-    getPlugin(pluginId: string): ChannelPlugin | undefined;
-    getAllPlugins(): ChannelPlugin[];
-    getRunningPlugins(): ChannelPlugin[];
-    isRunning(pluginId: string): boolean;
-    healthCheck(pluginId: string): Promise<ChannelHealth>;
-    healthCheckAll(): Promise<Map<string, ChannelHealth>>;
-    startHealthCheckTimer(): void;
-    stopHealthCheckTimer(): void;
-    sendToPlugin(pluginId: string, message: GatewayMessage): Promise<string>;
+
+interface ResolveChannelParams {
+    channel?: string | null;
+    sessionId?: string | null;
+    userId?: string | null;
+    defaultChannel?: string | null;
+    fallbackChannels?: string[] | null;
+    sessionManager?: {
+        get(sessionId: string): GatewaySession | undefined;
+        bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
+    };
+    pluginLoader?: {
+        getPlugin(pluginId: string): {
+            id: string;
+            platform: PlatformType;
+        } | undefined;
+        getAllPlugins(): Array<{
+            id: string;
+            platform: PlatformType;
+        }>;
+        isRunning(pluginId: string): boolean;
+    };
+    contactStore?: {
+        findByPlatformId(platform: PlatformType, stableId: string): Promise<{
+            uid: string;
+            platform: PlatformType;
+            stableId: string;
+            profile: {
+                username?: string;
+                displayName?: string;
+            };
+            lastSeenAt: number;
+        } | null>;
+        findByUid(uid: string): Promise<{
+            uid: string;
+            platform: PlatformType;
+            stableId: string;
+            profile: {
+                username?: string;
+                displayName?: string;
+            };
+            aliases?: Record<string, unknown>;
+            lastSeenAt: number;
+            createdAt: number;
+        } | null>;
+        listByPlatform(platform: PlatformType, limit?: number, offset?: number): Promise<{
+            contacts: Array<{
+                uid: string;
+                platform: PlatformType;
+                stableId: string;
+                profile: {
+                    username?: string;
+                    displayName?: string;
+                };
+                lastSeenAt: number;
+                createdAt: number;
+            }>;
+            total: number;
+            hasMore: boolean;
+        }>;
+        count(platform?: PlatformType): Promise<number>;
+    };
 }
 
+type MessageSender = (pluginId: string, message: GatewayMessage) => Promise<string>;
 declare class GatewayWebSocketServer {
     private config;
     private server;
@@ -1665,7 +1843,16 @@ declare class GatewayWebSocketServer {
     private heartbeatInterval;
     private startTime;
     private running;
+    private channelResolveParams;
     constructor(config?: Partial<GatewayServerConfig>);
+    setChannelResolveDeps(params: ResolveChannelParams): void;
+    setMessageSender(sender: MessageSender): void;
+    private messageSender;
+    private pluginLoaderRef;
+    setPluginLoader(loader: {
+        send(pluginId: string, message: GatewayMessage): Promise<string>;
+    }): void;
+    private getChannelResolveParams;
     start(): Promise<void>;
     private startHTTPServer;
     private startHTTPSServer;
@@ -1703,10 +1890,12 @@ declare class GatewayServer implements IGatewayServer {
     private sessionManager;
     private pluginLoader;
     private messageStore;
+    private contactStore;
     private wsServer;
     private running;
     private connections;
     constructor(config: GatewayServerConfig$1);
+    private loadChannelPlugins;
     start(): Promise<void>;
     stop(): Promise<void>;
     getStatus(): {
@@ -1716,6 +1905,9 @@ declare class GatewayServer implements IGatewayServer {
         connections?: number;
     };
     onMessage(message: GatewayMessage): Promise<void>;
+    private saveContactFromMessage;
+    private dispatchToSubAgent;
+    private triggerHook;
     private storeMessage;
     processMessage(sessionId: string, messageId: string, processorId: string, options?: {
         processType?: 'subagent' | 'direct' | 'tool';
@@ -1743,6 +1935,7 @@ declare class GatewayServer implements IGatewayServer {
     getRouter(): MessageRouter;
     getPluginLoader(): ChannelPluginLoader;
     getMessageStore(): MessageStore;
+    getContactStore(): IContactStore | null;
     getMessageHistory(sessionId: string, limit?: number): Promise<MessageRecord[]>;
 }
 
@@ -1762,6 +1955,58 @@ interface GatewayClientConfig {
 }
 type MessageCallback = (message: GatewayMessage) => void | Promise<void>;
 type AgentListChangeCallback = (agents: AgentSyncInfo[]) => void | Promise<void>;
+interface HealthResponse {
+    status: string;
+    timestamp: number;
+    version: string;
+}
+interface StatusResponse {
+    status: string;
+    connections: number;
+    sessions: number;
+    subscriptions: number;
+    uptime: number;
+    version: string;
+}
+interface ContactInfo {
+    uid: string;
+    platform: string;
+    stableId: string;
+    profile: {
+        displayName?: string;
+        username?: string;
+    };
+    lastSeenAt: number;
+    createdAt: number;
+}
+interface ContactListResponse {
+    contacts: ContactInfo[];
+    total: number;
+    hasMore: boolean;
+}
+interface SessionInfo {
+    id: string;
+    platform?: string;
+    channelId?: string;
+    userId?: string;
+    chatId?: string;
+    state: string;
+    createdAt: number;
+    lastActiveAt: number;
+}
+interface SessionListResponse {
+    sessions: SessionInfo[];
+    total: number;
+    hasMore: boolean;
+}
+interface CreateSessionResponse {
+    id: string;
+    createdAt: number;
+}
+interface SendMessageResponse {
+    success: boolean;
+    messageId?: string;
+}
 type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
 interface AgentListMergeOptions {
     localAgents?: AgentSyncInfo[];
@@ -1786,7 +2031,7 @@ declare class GatewayClient {
     constructor(config: GatewayClientConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    subscribe(sessionId: string): Promise<void>;
+    subscribe(sessionId: string, backendSessionId?: string): Promise<void>;
     unsubscribe(sessionId: string): Promise<void>;
     send(message: GatewayMessage): Promise<void>;
     onMessage(callback: MessageCallback): void;
@@ -1812,6 +2057,38 @@ declare class GatewayClient {
     private startHeartbeat;
     private stopHeartbeat;
     private resubscribeAll;
+    private getHttpUrl;
+    private httpRequest;
+    healthCheck(): Promise<HealthResponse>;
+    getStatus(): Promise<StatusResponse>;
+    listContacts(platform: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ContactListResponse>;
+    getContact(uid: string): Promise<ContactInfo & {
+        aliases?: Record<string, unknown>;
+    }>;
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<SessionListResponse>;
+    getSession(sessionId: string): Promise<SessionInfo & {
+        subscriberCount?: number;
+    }>;
+    createSession(params?: {
+        channel?: string;
+    }): Promise<CreateSessionResponse>;
+    sendMessage(sessionId: string, message: {
+        content: Array<{
+            type: string;
+            text?: string;
+            image?: string;
+            data?: string;
+        }>;
+        channel?: string;
+        userId?: string;
+        messageType?: string;
+    }): Promise<SendMessageResponse>;
 }
 
 interface TelegramBotConfig {
@@ -1820,35 +2097,91 @@ interface TelegramBotConfig {
         enabled: boolean;
         url: string;
         port?: number;
+        secret?: string;
     };
     polling?: {
         enabled: boolean;
         interval?: number;
+        timeout?: number;
+    };
+    retry?: {
+        maxAttempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
     };
+    commands?: TelegramBotCommand[];
+}
+interface TelegramBotCommand {
+    command: string;
+    description: string;
+    handler: (ctx: TelegramCommandContext) => Promise<void>;
+}
+interface TelegramCommandContext {
+    chatId: string;
+    userId?: string;
+    args: string[];
+    messageId: number;
+    reply?: (text: string, options?: SendMessageOptions) => Promise<string>;
+}
+interface SendMessageOptions {
+    parseMode?: 'Markdown' | 'HTML' | 'None';
+    replyTo?: number;
+    replyMarkup?: ReplyMarkup;
+}
+type ReplyMarkup = InlineKeyboardMarkup | ReplyKeyboardMarkup;
+interface InlineKeyboardMarkup {
+    inline_keyboard: InlineKeyboardButton[][];
+}
+interface InlineKeyboardButton {
+    text: string;
+    url?: string;
+    callback_data?: string;
+}
+interface ReplyKeyboardMarkup {
+    keyboard: KeyboardButton[][];
+    resize_keyboard?: boolean;
+    one_time_keyboard?: boolean;
+    selective?: boolean;
+}
+interface KeyboardButton {
+    text: string;
+    request_contact?: boolean;
+    request_location?: boolean;
 }
 declare class TelegramPlugin extends BaseChannelPlugin {
     readonly id: string;
     readonly platform: "telegram";
     readonly name = "Telegram Bot";
     private botConfig;
-    private pollingInterval;
-    private lastUpdateId;
     private baseUrl;
+    private abortController;
+    private lastUpdateId;
+    private typingTimers;
+    private commandRouter;
+    private retryState;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    sendTyping(chatId: string): Promise<void>;
+    sendChatAction(chatId: string, action: 'typing' | 'upload_photo' | 'upload_document' | 'record_video' | 'upload_video' | 'record_audio' | 'upload_audio'): Promise<void>;
+    private scheduleTypingStop;
+    private clearAllTyping;
+    private detectParseMode;
     private startPolling;
-    private stopPolling;
+    private pollLoop;
     private poll;
+    private handlePollingError;
+    private sleep;
     private handleTelegramMessage;
+    private handleCommand;
     private toGatewayMessage;
     private parseContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private getMe;
     private getUpdates;
-    private sendMessage;
+    private sendApiMessage;
     private request;
 }
 
@@ -1875,6 +2208,9 @@ declare class DiscordPlugin extends BaseChannelPlugin {
     private heartbeatInterval;
     private sessionId;
     private sequenceNumber;
+    private abortController;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
@@ -1886,8 +2222,8 @@ declare class DiscordPlugin extends BaseChannelPlugin {
     private handleDiscordMessage;
     private toGatewayMessage;
     private parseContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private getCurrentUser;
     private getGatewayBot;
     private createMessage;
@@ -1912,6 +2248,7 @@ declare class SlackPlugin extends BaseChannelPlugin {
     private botConfig;
     private baseUrl;
     private socketModeClient;
+    private abortController;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
@@ -1921,8 +2258,8 @@ declare class SlackPlugin extends BaseChannelPlugin {
     private handleSlackMessage;
     private toGatewayMessage;
     private parseContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private authTest;
     private postMessage;
     private request;
@@ -1973,6 +2310,7 @@ declare class FeishuPlugin extends BaseChannelPlugin {
     private baseUrl;
     private tenantAccessToken;
     private tokenExpireTime;
+    private abortController;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
@@ -1981,8 +2319,8 @@ declare class FeishuPlugin extends BaseChannelPlugin {
     private toGatewayMessage;
     private parseContent;
     private extractPostContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private refreshTenantAccessToken;
     private ensureTokenValid;
     private sendMessage;
@@ -2008,6 +2346,7 @@ declare class WeChatPlugin extends BaseChannelPlugin {
     private botConfig;
     private accessToken;
     private tokenExpireTime;
+    private abortController;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
@@ -2016,8 +2355,8 @@ declare class WeChatPlugin extends BaseChannelPlugin {
     private parseXmlMessage;
     private toGatewayMessage;
     private parseContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private refreshAccessToken;
     private ensureTokenValid;
     private sendOfficialMessage;
@@ -2042,6 +2381,7 @@ declare class WebChatPlugin extends BaseChannelPlugin {
     private webChatConfig;
     private connections;
     private heartbeatInterval;
+    private abortController;
     private wsServer;
     constructor(id?: string);
     protected doStart(): Promise<void>;
@@ -2075,19 +2415,21 @@ declare class SignalPlugin extends BaseChannelPlugin {
     readonly platform: "signal";
     readonly name = "Signal Bot";
     private botConfig;
-    private pollingInterval;
+    private abortController;
     private lastTimestamp;
+    private pollingIntervalMs;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
     private startPolling;
+    private pollLoop;
     private poll;
     private handleSignalMessage;
     private toGatewayMessage;
     private parseContent;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private getAccountInfo;
     private receiveMessages;
     private sendMessage;
@@ -2108,6 +2450,9 @@ declare class NostrPlugin extends BaseChannelPlugin {
     private relayConnections;
     private subscriptions;
     private eventHandlers;
+    private abortController;
+    private relayReconnectAttempts;
+    private maxReconnectAttempts;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
@@ -2118,8 +2463,8 @@ declare class NostrPlugin extends BaseChannelPlugin {
     private toGatewayMessage;
     private parseContent;
     private findReplyTo;
-    private getSessionId;
-    private extractText;
+    protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
+    private processMessageAndGetSessionId;
     private subscribeToRelay;
     private createEvent;
     private computeEventId;
@@ -2202,4 +2547,4 @@ declare function initLog(options: {
     level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 }): Promise<void>;
 
-export { type AgentDeregisterMessage, type AgentHealthStatus, type AgentHeartbeat, type AgentHeartbeatSyncMessage, type AgentListRequestMessage, type AgentListResponseMessage, type AgentRegisterMessage, type AgentRegistration, type AgentRegistrationRequest, AgentRegistry, type AgentRegistryConfig, AgentRegistryConfigSchema, type AgentRegistryStats, type AgentSelectionOptions, type AgentSelectionRecord, type AgentSelectionStrategy, type AgentStatusChangeMessage, type AgentSyncConfig, AgentSyncConfigSchema, type AgentSyncInfo, AgentSyncManager, type AuthConfig, AuthConfigSchema, type AuthResult, BaseChannelPlugin, type CancelEvent, type CancelEventHandler, type ChannelConfig, ChannelConfigSchema, type ChannelEvent, type ChannelEventType, type ChannelHealth, type ChannelPlugin, ChannelPluginLoader, ChannelPluginRegistry, type SessionConfig as ChannelSessionConfig, type ChannelStatus, type ChannelStatusType, type ChannelType, type CircuitBreakerConfig, CircuitBreakerConfigSchema, type ConnectionState as ClientConnectionState, type ClientInitializeMessage, type ClientInterruptMessage, type ClientMessage, type ClientMessageMessage, type ClientMessageType, type ClientPingMessage, type ClientReleaseSubscriptionMessage, type ClientSubscribeMessage, type ClientSubscription, type ClientUnsubscribeMessage, type ConflictResolutionStrategy, type ConnectionCloser, type ConnectionFactory, type ConnectionHealthChecker, type ConnectionPoolConfig, ConnectionPoolConfigSchema, type ConnectionPoolEvent, type ConnectionPoolEventCallback, type ConnectionPoolEventType, type ConnectionPoolStats, type ConnectionState$1 as ConnectionState, type CreateSessionRequest, type CreateSessionResponse, DEFAULT_AGENT_REGISTRY_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_SYNC_CONFIG, DEFAULT_TOKEN_AUTH_CONFIG, DEFAULT_WEBSOCKET_SERVER_CONFIG, type DiscordBotConfig, DiscordPlugin, type FeishuBotConfig, type FeishuChannelConfig, FeishuChannelConfigSchema, FeishuPlugin, Gateway, GatewayClient, type GatewayClientConfig, type GatewayClusterConfig, GatewayClusterConfigSchema, type GatewayConfig, GatewayConfigSchema, type GatewayNodeConfig, type GatewayNodeInfo, GatewayServer, type GatewayServerConfig, GatewayServerConfigSchema, type GatewaySession, GatewaySessionManager, type HTTPSConfig, HTTPSConfigSchema, type HealthCheckResponse, type IAuthProvider, type MessageCallback, type MessageHandler, MessageLockManager, type MessagePriority, type MessageQueueConfig, MessageQueueConfigSchema, type MessageRecord, MessageRetryManager, MessageRouter, type MessageStatus, MessageStore, type MessageStoreConfig, type NostrBotConfig, type NostrChannelConfig, NostrChannelConfigSchema, NostrPlugin, type OAuth2AuthConfig, type PluginLoaderConfig, type PooledConnection, type PushEventType, type RouteResult, type RoutingConfig, type SendMessageRequest, type SendMessageResponse, type SerializableSession, type ServerConnectedMessage, type ServerErrorMessage, type ServerEventMessage, type ServerInitializeResponseMessage, type ServerInterruptedMessage, type ServerMessage, type ServerMessageType, type ServerPongMessage, type ServerResponseMessage, type ServerSessionClosedMessage, type ServerStatusResponse, type ServerSubscribedMessage, type ServerSubscriptionReleasedMessage, type ServerUnsubscribedMessage, type SessionChannelInfo, type SessionConfig$1 as SessionConfig, SessionConfigSchema, type SessionContext, type SessionEventPayload, type SessionEventType, type SessionFilter, type SessionManagerConfig, type SessionResetPolicy, type SessionState, type SessionStatusType, SessionStore, type SessionStoreConfig, type SignalBotConfig, type SignalChannelConfig, SignalChannelConfigSchema, SignalPlugin, type SlackBotConfig, type SlackChannelConfig, SlackChannelConfigSchema, SlackPlugin, type Subscriber, type SubscriberConnection, type SubscriberType, type Subscription, type SubscriptionOptions, type SubscriptionsResponse, type SyncConfig, type SyncMessage, type SyncMode, type SyncState, type SyncStats, type TelegramBotConfig, type TelegramChannelConfig, TelegramChannelConfigSchema, TelegramPlugin, type TokenAuthConfig, type TokenAuthItem, type TokenConfig, type WeChatBotConfig, type WeChatChannelConfig, WeChatChannelConfigSchema, WeChatPlugin, type WebChatChannelConfig, WebChatChannelConfigSchema, type WebChatConfig, WebChatPlugin, type WebSocketConnectionInfo, type WebSocketConnectionState, type WebSocketMessage, type WebSocketMessageBase, clearConfigCache, createChannelPlugin, createDefaultSessionState, createGatewayMessage, createTextMessage, generateSessionId, generateSubscriptionId, getAgentAdapter, getAgentRegistryConfig, getAuthConfig, getChannelConfig, getCircuitBreakerConfig, getClusterConfig, getConfig, getConfigDirectory, getConnectionPoolConfig, getDefaultAgent, getHTTPSConfig, getLogLevel, getMessageQueueConfig, getServerConfig, getSessionConfig, getSupportedPlatforms, hasAgentAdapter, initLog, isConfigLoaded, loadConfig, parsePartialConfig, requireAgentAdapter, setAgentAdapter, validateConfig };
+export { type AgentDeregisterMessage, type AgentHealthStatus, type AgentHeartbeat, type AgentHeartbeatSyncMessage, type AgentListRequestMessage, type AgentListResponseMessage, type AgentRegisterMessage, type AgentRegistration, type AgentRegistrationRequest, AgentRegistry, type AgentRegistryConfig, AgentRegistryConfigSchema, type AgentRegistryStats, type AgentSelectionOptions, type AgentSelectionRecord, type AgentSelectionStrategy, type AgentStatusChangeMessage, type AgentSyncConfig, AgentSyncConfigSchema, type AgentSyncInfo, AgentSyncManager, type AuthConfig, AuthConfigSchema, type AuthResult, BaseChannelPlugin, type CancelEvent, type CancelEventHandler, type ChannelConfig, ChannelConfigSchema, type ChannelEvent, type ChannelEventType, type ChannelHealth, type ChannelPlugin, ChannelPluginLoader, ChannelPluginRegistry, type SessionConfig as ChannelSessionConfig, type ChannelStatus, type ChannelStatusType, type ChannelType, type CircuitBreakerConfig, CircuitBreakerConfigSchema, type ConnectionState as ClientConnectionState, type ClientInitializeMessage, type ClientInterruptMessage, type ClientMessage, type ClientMessageMessage, type ClientMessageType, type ClientPingMessage, type ClientReleaseSubscriptionMessage, type ClientSubscribeMessage, type ClientSubscription, type ClientUnsubscribeMessage, type ConflictResolutionStrategy, type ConnectionCloser, type ConnectionFactory, type ConnectionHealthChecker, type ConnectionPoolConfig, ConnectionPoolConfigSchema, type ConnectionPoolEvent, type ConnectionPoolEventCallback, type ConnectionPoolEventType, type ConnectionPoolStats, type ConnectionState$1 as ConnectionState, type ContactInfo, type ContactListResponse, type CreateSessionRequest, type CreateSessionResponse$1 as CreateSessionResponse, DEFAULT_AGENT_REGISTRY_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_SYNC_CONFIG, DEFAULT_TOKEN_AUTH_CONFIG, DEFAULT_WEBSOCKET_SERVER_CONFIG, type DiscordBotConfig, DiscordPlugin, type FeishuBotConfig, type FeishuChannelConfig, FeishuChannelConfigSchema, FeishuPlugin, Gateway, GatewayClient, type GatewayClientConfig, type GatewayClusterConfig, GatewayClusterConfigSchema, type GatewayConfig, GatewayConfigSchema, type GatewayNodeConfig, type GatewayNodeInfo, GatewayServer, type GatewayServerConfig, GatewayServerConfigSchema, type GatewaySession, GatewaySessionManager, type HTTPSConfig, HTTPSConfigSchema, type HealthCheckResponse, type HealthResponse, type IAuthProvider, type MessageCallback, type MessageHandler, MessageLockManager, type MessagePriority, type MessageQueueConfig, MessageQueueConfigSchema, type MessageRecord, MessageRetryManager, MessageRouter, type MessageStatus, MessageStore, type MessageStoreConfig, type NostrBotConfig, type NostrChannelConfig, NostrChannelConfigSchema, NostrPlugin, type OAuth2AuthConfig, type PluginLoaderConfig, type PooledConnection, type PushEventType, type RouteResult, type RoutingConfig, type SendMessageRequest, type SendMessageResponse$1 as SendMessageResponse, type SerializableSession, type ServerConnectedMessage, type ServerErrorMessage, type ServerEventMessage, type ServerInitializeResponseMessage, type ServerInterruptedMessage, type ServerMessage, type ServerMessageType, type ServerPongMessage, type ServerResponseMessage, type ServerSessionClosedMessage, type ServerStatusResponse, type ServerSubscribedMessage, type ServerSubscriptionReleasedMessage, type ServerUnsubscribedMessage, type SessionChannelInfo, type SessionConfig$1 as SessionConfig, SessionConfigSchema, type SessionContext, type SessionEventPayload, type SessionEventType, type SessionFilter, type SessionInfo, type SessionListResponse, type SessionManagerConfig, type SessionResetPolicy, type SessionState, type SessionStatusType, SessionStore, type SessionStoreConfig, type SignalBotConfig, type SignalChannelConfig, SignalChannelConfigSchema, SignalPlugin, type SlackBotConfig, type SlackChannelConfig, SlackChannelConfigSchema, SlackPlugin, type StatusResponse, type Subscriber, type SubscriberConnection, type SubscriberType, type Subscription, type SubscriptionOptions, type SubscriptionsResponse, type SyncConfig, type SyncMessage, type SyncMode, type SyncState, type SyncStats, type TelegramBotConfig, type TelegramChannelConfig, TelegramChannelConfigSchema, TelegramPlugin, type TokenAuthConfig, type TokenAuthItem, type TokenConfig, type WeChatBotConfig, type WeChatChannelConfig, WeChatChannelConfigSchema, WeChatPlugin, type WebChatChannelConfig, WebChatChannelConfigSchema, type WebChatConfig, WebChatPlugin, type WebSocketConnectionInfo, type WebSocketConnectionState, type WebSocketMessage, type WebSocketMessageBase, clearConfigCache, createChannelPlugin, createDefaultSessionState, createGatewayMessage, createTextMessage, generateSessionId, generateSubscriptionId, getAgentAdapter, getAgentRegistryConfig, getAuthConfig, getChannelConfig, getCircuitBreakerConfig, getClusterConfig, getConfig, getConfigDirectory, getConnectionPoolConfig, getDefaultAgent, getHTTPSConfig, getLogLevel, getMessageQueueConfig, getServerConfig, getSessionConfig, getSupportedPlatforms, hasAgentAdapter, initLog, isConfigLoaded, loadConfig, parsePartialConfig, requireAgentAdapter, setAgentAdapter, validateConfig };