@easbot/gateway 0.2.25 → 0.2.27

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { IGatewayServer, GatewayConfig as GatewayConfig$1, GatewayServerConfig as GatewayServerConfig$1, PlatformType, GatewayMessage, SubAgentConfig, ChannelInfo, ChannelListResponse, AgentAdapter } from '@easbot/types';
+import { IGatewayServer, GatewayConfig as GatewayConfig$1, GatewayServerConfig as GatewayServerConfig$1, GatewayMessageReceiveInput, GatewayMessage, PlatformType, SubAgentConfig, ChannelInfo, ChannelListResponse, AgentAdapter } from '@easbot/types';
 export { AgentAdapter, AgentInfo, ChannelInfo, GatewayMessage, GatewayMessagePromptPart, IGatewayServer, IGlobal, IHookRegistry, IInstance, ISubAgentRunner, MessageContext, MessageMetadata, MessageStorage, MessageType, PlatformType } from '@easbot/types';
 import z from 'zod';
 import { WSContext } from '@easbot/utils';
@@ -55,6 +55,11 @@ declare const TelegramChannelConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     botToken: z.ZodString;
     webhookUrl: z.ZodOptional<z.ZodString>;
+    polling: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        interval: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, z.core.$strip>;
@@ -125,6 +130,11 @@ declare const ChannelConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         botToken: z.ZodString;
         webhookUrl: z.ZodOptional<z.ZodString>;
+        polling: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            interval: z.ZodOptional<z.ZodNumber>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
@@ -476,6 +486,11 @@ declare const GatewayConfigSchema: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             botToken: z.ZodString;
             webhookUrl: z.ZodOptional<z.ZodString>;
+            polling: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                interval: z.ZodOptional<z.ZodNumber>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
             maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         }, z.core.$strip>>;
@@ -657,7 +672,7 @@ declare function createGatewayMessage(sessionId: string, type: 'input' | 'output
         [key: string]: unknown;
     };
     context?: Record<string, unknown>;
-    agent?: Record<string, unknown>;
+    agent?: string;
 }): GatewayMessage;
 declare function createTextMessage(sessionId: string, type: 'input' | 'output' | 'system' | 'control', text: string, metadata?: {
     channel?: {
@@ -668,9 +683,32 @@ declare function createTextMessage(sessionId: string, type: 'input' | 'output' |
         [key: string]: unknown;
     };
     context?: Record<string, unknown>;
-    agent?: Record<string, unknown>;
+    agent?: string;
+}): GatewayMessage;
+
+declare function convertToGatewayMessage(input: GatewayMessageReceiveInput & {
+    processorId?: string;
+    agent?: string;
+    proactive?: boolean;
 }): GatewayMessage;
 
+interface ChannelCapabilities {
+    supportsText: boolean;
+    supportsMedia: boolean;
+    supportsReply: boolean;
+    supportsThread: boolean;
+    supportsEdit: boolean;
+    supportsDelete: boolean;
+    supportsTyping: boolean;
+    supportsBatchSend: boolean;
+    supportsMarkdown: boolean;
+    supportsHtml: boolean;
+    supportsDeliveryReceipt: boolean;
+    supportsReadReceipt: boolean;
+    maxMessageLength: number;
+    maxMediaCount: number;
+}
+
 interface ChannelConfig {
     enabled: boolean;
     platform: Record<string, unknown>;
@@ -698,6 +736,7 @@ interface ChannelPlugin {
     send(message: GatewayMessage): Promise<string>;
     healthCheck(): Promise<ChannelHealth>;
     getStatus(): ChannelStatus;
+    getCapabilities(): ChannelCapabilities;
 }
 interface MessageHandler {
     onMessage(message: GatewayMessage): Promise<void>;
@@ -716,13 +755,13 @@ interface ChannelStatus {
     error?: string;
 }
 type ChannelStatusType = 'starting' | 'running' | 'stopping' | 'stopped' | 'error' | 'reconnecting';
-interface ChannelEvent {
+interface ChannelEvent<T = unknown> {
     type: ChannelEventType;
     channelId: string;
-    data?: unknown;
+    data?: T;
     timestamp: number;
 }
-type ChannelEventType = 'connected' | 'disconnected' | 'reconnecting' | 'error' | 'message_received' | 'message_sent' | 'user_joined' | 'user_left';
+type ChannelEventType = 'connected' | 'disconnected' | 'reconnecting' | 'error' | 'message_received' | 'message_sent' | 'message_delivered' | 'message_read' | 'user_joined' | 'user_left';
 
 interface GatewaySession {
     id: string;
@@ -838,7 +877,7 @@ interface SubscriptionOptions {
 }
 interface RouteResult {
     success: boolean;
-    broadcastCount: number;
+    dispatched: boolean;
     dispatchedToSubAgent: boolean;
     error?: string;
 }
@@ -1325,16 +1364,17 @@ declare class MessageRouter {
     private subscriptions;
     private sessionSubscriptions;
     private channelPlugins;
-    private lockManager;
-    private retryManager;
     private cancelHandlers;
-    constructor();
+    private processingMessages;
+    private hookRegistry;
+    constructor(hookRegistry?: typeof this.hookRegistry);
+    private triggerHook;
+    private triggerBeforeSend;
     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>;
@@ -1351,74 +1391,6 @@ declare class MessageRouter {
     shutdown(): Promise<void>;
 }
 
-interface LockState {
-    sessionId: string;
-    messageId: string;
-    holderId: string;
-    acquiredAt: number;
-    timeout: number;
-}
-interface LockManagerConfig {
-    defaultTimeout: number;
-    checkInterval: number;
-}
-declare class MessageLockManager {
-    private log;
-    private config;
-    private locks;
-    private cleanupTimer;
-    constructor(config?: Partial<LockManagerConfig>);
-    tryAcquire(sessionId: string, messageId: string, subscriberId: string, timeout?: number): boolean;
-    release(sessionId: string, subscriberId: string): boolean;
-    forceRelease(sessionId: string): boolean;
-    private isLockExpired;
-    getLock(sessionId: string): LockState | undefined;
-    isLocked(sessionId: string): boolean;
-    getHolder(sessionId: string): string | undefined;
-    startCleanup(): void;
-    stopCleanup(): void;
-    cleanupExpired(): number;
-    getAllLocks(): LockState[];
-    getLockCount(): number;
-}
-
-interface RetryPolicy {
-    maxRetries: number;
-    initialDelay: number;
-    maxDelay: number;
-    backoffMultiplier: number;
-}
-interface RetryRecord {
-    messageId: string;
-    retryCount: number;
-    nextRetryAt: number;
-    errors: Array<{
-        error: string;
-        timestamp: number;
-    }>;
-}
-type RetryHandler = (message: GatewayMessage) => Promise<void>;
-declare class MessageRetryManager {
-    private log;
-    private policy;
-    private retryQueue;
-    private retryTimer;
-    private handlers;
-    constructor(policy?: Partial<RetryPolicy>);
-    registerHandler(messageId: string, handler: RetryHandler): void;
-    unregisterHandler(messageId: string): void;
-    scheduleRetry(message: GatewayMessage, error: Error): boolean;
-    getPendingRetries(): RetryRecord[];
-    executeRetry(record: RetryRecord): Promise<boolean>;
-    clearRetry(messageId: string): void;
-    startProcessing(): void;
-    stopProcessing(): void;
-    getStats(): {
-        pendingCount: number;
-        totalErrors: number;
-    };
-}
-
 interface SessionManagerConfig {
     enablePersistence: boolean;
     storagePath: string;
@@ -1581,6 +1553,7 @@ declare abstract class BaseChannelPlugin implements ChannelPlugin {
     healthCheck(): Promise<ChannelHealth>;
     getStatus(): ChannelStatus;
     abstract send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): ChannelCapabilities;
     protected abstract doStart(): Promise<void>;
     protected abstract doStop(): Promise<void>;
     protected doHealthCheck(): Promise<boolean>;
@@ -1638,8 +1611,10 @@ interface MessageRecord {
     error: string | null;
     createdAt: number;
     updatedAt: number;
+    deliveredAt: number | null;
+    readAt: number | null;
 }
-type MessageStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+type MessageStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'delivered' | 'read';
 interface MessageStoreConfig {
     storagePath: string;
     maxRetentionDays: number;
@@ -1656,20 +1631,29 @@ declare class MessageStore {
     private sessionMessages;
     private cleanupTimer;
     private accessOrder;
+    private storagePath;
+    private dirty;
     constructor(config?: Partial<MessageStoreConfig>);
+    private ensureDir;
+    private getMessageFilePath;
+    private getSessionDir;
+    private sanitizeFileName;
     private startCleanupTimer;
     private performCleanup;
-    store(message: GatewayMessage): Promise<MessageRecord>;
+    store(message: GatewayMessage, initialStatus?: MessageStatus): Promise<MessageRecord>;
+    private saveMessageToFile;
     get(messageId: string): MessageRecord | undefined;
     updateStatus(messageId: string, status: MessageStatus, options?: {
         processedBy?: string;
         error?: string;
+        deliveredAt?: number;
+        readAt?: number;
     }): Promise<void>;
-    incrementRetry(messageId: string): number;
+    incrementRetry(messageId: string): Promise<number>;
     isProcessed(messageId: string): boolean;
     getSessionHistory(sessionId: string, limit?: number): MessageRecord[];
-    getPendingMessages(sessionId?: string): MessageRecord[];
-    getFailedMessages(maxRetries?: number): MessageRecord[];
+    getPendingMessages(sessionId?: string, type?: string): MessageRecord[];
+    getFailedMessages(maxRetries?: number, type?: string): MessageRecord[];
     cleanup(): number;
     private evictLRU;
     private updateAccessOrder;
@@ -1681,6 +1665,8 @@ declare class MessageStore {
         completed: number;
         failed: number;
         cancelled: number;
+        delivered: number;
+        read: number;
         sessions: number;
     };
     close(): Promise<void>;
@@ -1773,7 +1759,9 @@ interface ResolveChannelParams {
     fallbackChannels?: string[] | null;
     sessionManager?: {
         get(sessionId: string): GatewaySession | undefined;
+        getOrCreate(channelInfo: SessionChannelInfo, context?: Record<string, unknown>): Promise<GatewaySession>;
         bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
+        getAll?(): GatewaySession[];
     };
     pluginLoader?: {
         getPlugin(pluginId: string): ChannelPlugin | undefined;
@@ -1822,7 +1810,9 @@ interface ResolveChannelParams {
     };
 }
 
-type MessageSender = (pluginId: string, message: GatewayMessage) => Promise<string>;
+type MessageSender = (pluginId: string, message: GatewayMessage, options?: SendOptions) => Promise<string>;
+interface SendOptions extends Record<string, unknown> {
+}
 declare class GatewayWebSocketServer {
     private config;
     private server;
@@ -1840,12 +1830,8 @@ declare class GatewayWebSocketServer {
     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;
+    setPluginLoader(sender: MessageSender): void;
     private getChannelResolveParams;
     start(): Promise<void>;
     private startHTTPServer;
@@ -1878,6 +1864,8 @@ declare class GatewayWebSocketServer {
 }
 
 declare class GatewayServer implements IGatewayServer {
+    private static readonly MAX_RETRY_COUNT;
+    private static readonly SEVEN_DAYS_MS;
     private log;
     private config;
     private router;
@@ -1902,29 +1890,18 @@ declare class GatewayServer implements IGatewayServer {
     private saveContactFromMessage;
     private dispatchToSubAgent;
     private triggerHook;
+    private retryPendingMessages;
     private storeMessage;
-    processMessage(sessionId: string, messageId: string, processorId: string, options?: {
-        processType?: 'subagent' | 'direct' | 'tool';
-        agent?: string;
-    }): Promise<void>;
-    completeMessage(sessionId: string, messageId: string, processorId: string, options?: {
-        success?: boolean;
-        error?: string;
-        responseMessageId?: string;
-        tokens?: number;
-        duration?: number;
-    }): Promise<void>;
     onEvent(event: ChannelEvent): Promise<void>;
     registerChannel(plugin: ChannelPlugin, config?: ChannelConfig): Promise<void>;
     unregisterChannel(pluginId: string): Promise<void>;
     subscribe(sessionId: string, subscriber: Subscriber): Promise<void>;
     unsubscribe(subscriptionId: string): Promise<void>;
-    send(message: GatewayMessage): Promise<void>;
-    sendToChannel(pluginId: string, message: GatewayMessage, options?: {
-        proactive?: boolean;
-        replyToMessageId?: string;
+    sendToChannel(pluginId: string, message: GatewayMessage, options?: Record<string, unknown>): Promise<string>;
+    sendProactiveMessage(pluginId: string, sessionId: string, content: GatewayMessage['content'], channel: ChannelInfo, options?: {
+        processorId?: string;
+        agent?: string;
     }): Promise<string>;
-    sendProactiveMessage(pluginId: string, sessionId: string, content: GatewayMessage['content'], channel: ChannelInfo): Promise<string>;
     getSessionManager(): GatewaySessionManager;
     getRouter(): MessageRouter;
     getPluginLoader(): ChannelPluginLoader;
@@ -1984,6 +1961,8 @@ interface SessionInfo {
     channelId?: string;
     userId?: string;
     chatId?: string;
+    chatType?: string;
+    chatTitle?: string;
     state: string;
     createdAt: number;
     lastActiveAt: number;
@@ -2063,16 +2042,30 @@ declare class GatewayClient {
     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;
+        userId?: string;
+        platform?: string;
     }): Promise<CreateSessionResponse>;
+    getOrCreateSession(options: {
+        sessionId?: string;
+        channel?: string;
+        userId?: string;
+        platform?: string;
+    }): Promise<{
+        sessionId: string;
+        created: boolean;
+    }>;
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+        platform?: string;
+        channelId?: string;
+        userId?: string;
+    }): Promise<SessionListResponse>;
     sendMessage(sessionId: string, message: {
         content: Array<{
             type: string;
@@ -2082,7 +2075,10 @@ declare class GatewayClient {
         }>;
         channel?: string;
         userId?: string;
+        chatId?: string;
         messageType?: string;
+        processorId?: string;
+        agent?: string;
     }): Promise<SendMessageResponse>;
 }
 
@@ -2152,12 +2148,33 @@ declare class TelegramPlugin extends BaseChannelPlugin {
     private abortController;
     private lastUpdateId;
     private typingTimers;
+    private sentMessages;
+    private sessionIdMap;
     private commandRouter;
     private retryState;
     constructor(id?: string);
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    private sendPhoto;
+    private sendDocument;
+    private isParseError;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     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;
@@ -2166,11 +2183,16 @@ declare class TelegramPlugin extends BaseChannelPlugin {
     private startPolling;
     private pollLoop;
     private poll;
+    private handleMessageReaction;
+    private handleMessageReactionCount;
+    private findSentMessageEntry;
     private handlePollingError;
     private sleep;
     private handleTelegramMessage;
     private handleCommand;
     private toGatewayMessage;
+    private parseFileContent;
+    private downloadBinaryFile;
     private parseContent;
     protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
     private processMessageAndGetSessionId;
@@ -2210,6 +2232,22 @@ declare class DiscordPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     private startGateway;
     private handleGatewayMessage;
     private handleHello;
@@ -2248,6 +2286,22 @@ declare class SlackPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     private startSocketMode;
     private handleSocketModeEvent;
     private handleSlackMessage;
@@ -2310,6 +2364,22 @@ declare class FeishuPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     handleWebhookEvent(event: FeishuMessageEvent): Promise<void>;
     private toGatewayMessage;
     private parseContent;
@@ -2346,6 +2416,22 @@ declare class WeChatPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     handleWebhookMessage(xmlData: string): Promise<void>;
     private parseXmlMessage;
     private toGatewayMessage;
@@ -2383,10 +2469,27 @@ declare class WebChatPlugin extends BaseChannelPlugin {
     private startWebSocketServer;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     pushEvent(sessionId: string, event: SessionEventPayload): void;
     getWebSocketServer(): GatewayWebSocketServer | null;
     handleConnection(ws: WebSocket, userId: string): Promise<void>;
     private handleWebSocketMessage;
+    private handleMessageAcknowledgment;
     private handleChatMessage;
     private startHeartbeat;
     private findConnectionByUser;
@@ -2417,6 +2520,22 @@ declare class SignalPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     private startPolling;
     private pollLoop;
     private poll;
@@ -2452,6 +2571,22 @@ declare class NostrPlugin extends BaseChannelPlugin {
     protected doStart(): Promise<void>;
     protected doStop(): Promise<void>;
     send(message: GatewayMessage): Promise<string>;
+    getCapabilities(): {
+        supportsText: boolean;
+        supportsMedia: boolean;
+        supportsReply: boolean;
+        supportsThread: boolean;
+        supportsEdit: boolean;
+        supportsDelete: boolean;
+        supportsTyping: boolean;
+        supportsBatchSend: boolean;
+        supportsMarkdown: boolean;
+        supportsHtml: boolean;
+        supportsDeliveryReceipt: boolean;
+        supportsReadReceipt: boolean;
+        maxMessageLength: number;
+        maxMediaCount: number;
+    };
     private connectToRelay;
     private handleRelayMessage;
     private handleNostrEvent;
@@ -2542,4 +2677,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 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 };
+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, type MessagePriority, type MessageQueueConfig, MessageQueueConfigSchema, type MessageRecord, 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, convertToGatewayMessage, 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 };