@easbot/gateway 0.2.41 → 0.2.43

package/dist/index.d.cts

@@ -1,7 +1,8 @@
-import { IGatewayServer, GatewayConfig as GatewayConfig$1, GatewayServerConfig as GatewayServerConfig$1, GatewayMessageReceiveInput, GatewayMessage, GatewayMessagePromptPart, 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 { IGatewayServer, GatewayConfig as GatewayConfig$1, GatewayServerConfig as GatewayServerConfig$1, GatewayMessageReceiveInput, GatewayMessage, GatewayMessagePromptPart, PlatformType, SubAgentConfig, ChannelInfo, AgentPromptPart, AgentAdapter } from '@easbot/types';
+export { AgentAdapter, AgentInfo, ChannelInfo, ChannelListResponse, GatewayMessage, GatewayMessagePromptPart, IGatewayServer, IGlobal, IHookRegistry, IInstance, ISubAgentRunner, MessageContext, MessageMetadata, MessageStorage, MessageType, PlatformType } from '@easbot/types';
+import z, { z as z$1 } from 'zod';
 import { WSContext } from '@easbot/utils';
+import { Command, EasbotClient } from '@easbot/sdk';
 
 declare namespace Gateway {
     export interface BootstrapConfig {
@@ -441,6 +442,14 @@ declare const GatewayServerConfigSchema: z.ZodObject<{
     mdnsDomain: z.ZodDefault<z.ZodOptional<z.ZodString>>;
 }, z.core.$strip>;
 type GatewayServerConfig = z.infer<typeof GatewayServerConfigSchema>;
+declare const GatewayClientConfigSchema: z.ZodObject<{
+    autoRegister: z.ZodDefault<z.ZodBoolean>;
+    heartbeatInterval: z.ZodDefault<z.ZodNumber>;
+    maxReconnectAttempts: z.ZodDefault<z.ZodNumber>;
+    reconnectDelay: z.ZodDefault<z.ZodNumber>;
+    heartbeatTimeout: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type GatewayClientConfig = z.infer<typeof GatewayClientConfigSchema>;
 declare const GatewayConfigSchema: z.ZodObject<{
     server: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -662,6 +671,13 @@ declare const GatewayConfigSchema: z.ZodObject<{
         timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         retryOnFailure: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    client: z.ZodOptional<z.ZodObject<{
+        autoRegister: z.ZodDefault<z.ZodBoolean>;
+        heartbeatInterval: z.ZodDefault<z.ZodNumber>;
+        maxReconnectAttempts: z.ZodDefault<z.ZodNumber>;
+        reconnectDelay: z.ZodDefault<z.ZodNumber>;
+        heartbeatTimeout: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     defaultAgent: z.ZodOptional<z.ZodString>;
     logLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         DEBUG: "DEBUG";
@@ -686,6 +702,8 @@ declare function getMessageQueueConfig(): Promise<MessageQueueConfig>;
 declare function getCircuitBreakerConfig(): Promise<CircuitBreakerConfig>;
 declare function getAgentRegistryConfig(): Promise<AgentRegistryConfig>;
 declare function getSessionConfig(): Promise<SessionConfig$1>;
+declare function getGatewayClientConfig(): Promise<GatewayClientConfig | undefined>;
+declare function getGatewayClientUrl(): Promise<string | undefined>;
 declare function getHTTPSConfig(): Promise<HTTPSConfig | undefined>;
 declare function getAuthConfig(): Promise<AuthConfig | undefined>;
 declare function getClusterConfig(): Promise<GatewayConfig['cluster'] | undefined>;
@@ -770,9 +788,16 @@ interface ChannelPlugin {
     getStatus(): ChannelStatus;
     getCapabilities(): ChannelCapabilities;
 }
+interface SessionOperations {
+    getSession(sessionId: string): {
+        backendSessionId: string | null;
+    } | undefined;
+    unbindBackendSession(gatewaySessionId: string): Promise<void>;
+}
 interface MessageHandler {
     onMessage(message: GatewayMessage): Promise<void>;
     onEvent(event: ChannelEvent): Promise<void>;
+    session?: SessionOperations;
 }
 interface ChannelHealth {
     healthy: boolean;
@@ -884,11 +909,10 @@ interface Subscriber {
     id: string;
     type: SubscriberType;
     connection: SubscriberConnection;
-    sessions: Set<string>;
     createdAt: number;
     lastActiveAt: number;
 }
-type SubscriberType = 'subagent' | 'tui' | 'desktop' | 'browser' | 'mobile' | 'api';
+type SubscriberType = 'subagent' | 'tui' | 'desktop' | 'browser' | 'mobile' | 'api' | 'acp';
 interface SubscriberConnection {
     send(message: GatewayMessage): Promise<void>;
     close(): Promise<void>;
@@ -916,24 +940,17 @@ interface RouteResult {
 declare function generateSubscriptionId(subscriberId: string, sessionId: string): string;
 
 declare const DEFAULT_WEBSOCKET_SERVER_CONFIG: GatewayServerConfig;
-type ClientMessageType = 'initialize' | 'subscribe' | 'unsubscribe' | 'message' | 'ping' | 'interrupt' | 'releaseSubscription' | 'agent_list_request' | 'agent_subscribe';
-type ServerMessageType = 'connected' | 'initialize_response' | 'subscribed' | 'unsubscribed' | 'event' | 'response' | 'error' | 'pong' | 'interrupted' | 'session_closed' | 'subscriptionReleased' | 'agent_list_response' | 'agent_update';
+type ClientMessageType = 'subscribe' | 'unsubscribe' | 'message' | 'ping' | 'interrupt' | 'releaseSubscription' | 'agent_list_request' | 'agent_subscribe' | 'agent_register' | 'agent_deregister';
+type ServerMessageType = 'connected' | 'subscribed' | 'unsubscribed' | 'event' | 'response' | 'error' | 'pong' | 'interrupted' | 'subscriptionReleased' | 'agent_list_response' | 'agent_update';
 interface WebSocketMessageBase {
     type: ClientMessageType | ServerMessageType;
     sessionId?: string;
 }
-interface ClientInitializeMessage extends WebSocketMessageBase {
-    type: 'initialize';
-    payload?: {
-        name?: string;
-        version?: string;
-        capabilities?: string[];
-    };
-}
 interface ClientSubscribeMessage extends WebSocketMessageBase {
     type: 'subscribe';
     sessionId: string;
     backendSessionId?: string;
+    clientId?: string;
     payload?: {
         eventTypes?: string[];
     };
@@ -975,8 +992,25 @@ interface ClientAgentListRequestMessage extends WebSocketMessageBase {
 interface ClientAgentSubscribeMessage extends WebSocketMessageBase {
     type: 'agent_subscribe';
     subscribe: boolean;
+    clientId?: string;
 }
-type ClientMessage = ClientInitializeMessage | ClientSubscribeMessage | ClientUnsubscribeMessage | ClientMessageMessage | ClientPingMessage | ClientInterruptMessage | ClientReleaseSubscriptionMessage | ClientAgentListRequestMessage | ClientAgentSubscribeMessage;
+interface ClientAgentRegisterMessage extends WebSocketMessageBase {
+    type: 'agent_register';
+    payload: {
+        agentId: string;
+        name: string;
+        address: string;
+        capabilities?: string[];
+        metadata?: Record<string, unknown>;
+    };
+}
+interface ClientAgentDeregisterMessage extends WebSocketMessageBase {
+    type: 'agent_deregister';
+    payload: {
+        agentId: string;
+    };
+}
+type ClientMessage = ClientSubscribeMessage | ClientUnsubscribeMessage | ClientMessageMessage | ClientPingMessage | ClientInterruptMessage | ClientReleaseSubscriptionMessage | ClientAgentListRequestMessage | ClientAgentSubscribeMessage | ClientAgentRegisterMessage | ClientAgentDeregisterMessage;
 interface ServerConnectedMessage extends WebSocketMessageBase {
     type: 'connected';
     clientId: string;
@@ -985,16 +1019,6 @@ interface ServerConnectedMessage extends WebSocketMessageBase {
         capabilities?: string[];
     };
 }
-interface ServerInitializeResponseMessage extends WebSocketMessageBase {
-    type: 'initialize_response';
-    success: boolean;
-    result?: {
-        sessionId?: string;
-        capabilities?: string[];
-        [key: string]: unknown;
-    };
-    error?: string;
-}
 interface ServerSubscribedMessage extends WebSocketMessageBase {
     type: 'subscribed';
     sessionId: string;
@@ -1033,13 +1057,6 @@ interface ServerInterruptedMessage extends WebSocketMessageBase {
     success: boolean;
     error?: string;
 }
-interface ServerSessionClosedMessage extends WebSocketMessageBase {
-    type: 'session_closed';
-    sessionId: string;
-    payload?: {
-        reason?: string;
-    };
-}
 interface ServerSubscriptionReleasedMessage extends WebSocketMessageBase {
     type: 'subscriptionReleased';
     sessionId: string;
@@ -1072,7 +1089,29 @@ interface ServerAgentUpdateMessage extends WebSocketMessageBase {
         metadata?: Record<string, unknown>;
     };
 }
-type ServerMessage = ServerConnectedMessage | ServerInitializeResponseMessage | ServerSubscribedMessage | ServerUnsubscribedMessage | ServerEventMessage | ServerResponseMessage | ServerErrorMessage | ServerPongMessage | ServerInterruptedMessage | ServerSessionClosedMessage | ServerSubscriptionReleasedMessage | ServerAgentListResponseMessage | ServerAgentUpdateMessage;
+interface ServerMessagePushMessage extends WebSocketMessageBase {
+    type: 'message';
+    sessionId: string;
+    payload: {
+        id: string;
+        type: 'input' | 'output' | 'system' | 'control';
+        content: AgentPromptPart[];
+        metadata?: {
+            channel?: {
+                platform: string;
+                channelId?: string;
+                userId?: string;
+                chatId?: string;
+            };
+            processorId?: string;
+            proactive?: boolean;
+            replyToMessageId?: string;
+        };
+        timestamp: number;
+        [key: string]: unknown;
+    };
+}
+type ServerMessage = ServerConnectedMessage | ServerSubscribedMessage | ServerUnsubscribedMessage | ServerEventMessage | ServerResponseMessage | ServerErrorMessage | ServerPongMessage | ServerInterruptedMessage | ServerSubscriptionReleasedMessage | ServerAgentListResponseMessage | ServerAgentUpdateMessage | ServerMessagePushMessage;
 type WebSocketMessage = ClientMessage | ServerMessage;
 interface ClientSubscription {
     clientId: string;
@@ -1095,9 +1134,9 @@ interface WebSocketConnectionInfo {
     remoteAddress?: string;
     authInfo?: ClientSubscription['authInfo'];
 }
-type SessionEventType = 'message' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'complete' | 'interrupted' | 'status_change';
+type SessionEventType$1 = 'message' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'complete' | 'interrupted' | 'status_change';
 interface SessionEventPayload {
-    type: SessionEventType | string;
+    type: SessionEventType$1 | string;
     sessionId: string;
     properties: {
         [key: string]: unknown;
@@ -1112,9 +1151,21 @@ interface ServerStatusResponse {
     status: 'running' | 'stopping' | 'stopped';
     connections: number;
     sessions: number;
-    subscriptions: number;
+    messageSubscriptions: number;
+    agentSubscriptions: number;
     uptime: number;
     version?: string;
+    agents?: {
+        total: number;
+        healthy: number;
+        unhealthy: number;
+    };
+    channels?: Array<{
+        id: string;
+        platform: string;
+        name: string;
+        version?: string;
+    }>;
 }
 interface CreateSessionRequest {
     title?: string;
@@ -1126,7 +1177,7 @@ interface CreateSessionRequest {
     };
     context?: Record<string, unknown>;
 }
-interface CreateSessionResponse$1 {
+interface CreateSessionResponse {
     id: string;
     createdAt: number;
 }
@@ -1141,7 +1192,7 @@ interface SendMessageRequest {
     }>;
     [key: string]: unknown;
 }
-interface SendMessageResponse$1 {
+interface SendMessageResponse {
     messageId: string;
     sessionId: string;
     createdAt: number;
@@ -1151,11 +1202,16 @@ interface SendMessageResponse$1 {
         channelInfo?: ChannelInfo;
     };
 }
+type SubscriptionType = 'message' | 'agent';
 interface SubscriptionsResponse {
     subscriptions: Array<{
+        type: SubscriptionType;
         sessionId: string;
         subscriberCount: number;
-        subscribers: string[];
+        subscribers: Array<{
+            id: string;
+            subscriptionId: string;
+        }>;
     }>;
     total: number;
 }
@@ -1203,10 +1259,10 @@ interface AgentRegistration {
 }
 type AgentRegistrationRequest = Omit<AgentRegistration, 'registeredAt' | 'lastHeartbeat' | 'connectionCount' | 'status'>;
 declare const DEFAULT_AGENT_REGISTRY_CONFIG: {
-    readonly heartbeatInterval: 30000;
-    readonly heartbeatTimeout: 90000;
-    readonly heartbeatCheckInterval: 10000;
-    readonly autoDeregisterTimeout: 300000;
+    readonly heartbeatInterval: 60000;
+    readonly heartbeatTimeout: 300000;
+    readonly heartbeatCheckInterval: 300000;
+    readonly autoDeregisterTimeout: 600000;
     readonly maxAgents: 100;
     readonly maxRegistrations: 1000;
 };
@@ -1351,12 +1407,12 @@ declare const DEFAULT_CONNECTION_POOL_CONFIG: {
     acquireTimeout: number;
     warmupCount: number;
 };
-type ConnectionState$1 = 'idle' | 'active' | 'unhealthy' | 'closed';
+type ConnectionState = 'idle' | 'active' | 'unhealthy' | 'closed';
 interface PooledConnection<T = unknown> {
     id: string;
     channelId: string;
     connection: T;
-    state: ConnectionState$1;
+    state: ConnectionState;
     lastActivity: number;
     createdAt: number;
     useCount: number;
@@ -1390,21 +1446,30 @@ interface CancelEvent {
     timestamp: number;
 }
 type CancelEventHandler = (event: CancelEvent) => void | Promise<void>;
+interface RouterSessionManager {
+    get(sessionId: string): {
+        backendSessionId?: string | null;
+    } | undefined;
+    bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
+}
 declare class MessageRouter {
     private log;
     private subscribers;
     private subscriptions;
-    private sessionSubscriptions;
+    private messageSubscriptions;
     private channelPlugins;
     private cancelHandlers;
     private processingMessages;
     private hookRegistry;
-    constructor(hookRegistry?: typeof this.hookRegistry);
+    private sessionManager;
+    constructor(hookRegistry?: typeof this.hookRegistry, sessionManager?: RouterSessionManager);
+    setSessionManager(sessionManager: RouterSessionManager): void;
     private triggerHook;
     private triggerBeforeSend;
     onCancel(handler: CancelEventHandler): void;
     offCancel(handler: CancelEventHandler): void;
     private emitCancel;
+    private selectSubscriber;
     route(message: GatewayMessage): Promise<RouteResult>;
     completeMessage(sessionId: string, messageId: string, subscriberId: string, reason?: 'completed' | 'failed' | 'timeout'): Promise<void>;
     subscribe(sessionId: string, subscriber: Subscriber): Promise<Subscription>;
@@ -1414,6 +1479,7 @@ declare class MessageRouter {
     unregisterChannel(pluginId: string): void;
     getSubscriber(subscriberId: string): Subscriber | undefined;
     getSubscription(subscriptionId: string): Subscription | undefined;
+    getMessageSubscriptions(): Map<string, Set<string>>;
     getSubscriberCount(sessionId: string): number;
     getStats(): {
         subscribers: number;
@@ -1443,6 +1509,7 @@ declare class GatewaySessionManager {
     closeById(sessionId: string): Promise<void>;
     bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
     unbindBackendSession(gatewaySessionId: string): Promise<void>;
+    findByBackendSessionId(backendSessionId: string): GatewaySession | undefined;
     getState(sessionId: string): SessionState | undefined;
     incrementMessageCountOrCreate(sessionId: string, channelInfo?: SessionChannelInfo): Promise<GatewaySession>;
     incrementMessageCount(sessionId: string): Promise<void>;
@@ -1461,15 +1528,28 @@ declare class GatewaySessionManager {
     };
 }
 
+type AgentEventType = 'register' | 'deregister' | 'heartbeat' | 'status_change';
+interface AgentEvent {
+    type: AgentEventType;
+    agent: AgentRegistration;
+    oldStatus?: AgentHealthStatus;
+}
+type AgentEventCallback = (event: AgentEvent) => void | Promise<void>;
 declare class AgentRegistry {
     private config;
     private agents;
     private heartbeatTimer;
     private roundRobinIndex;
-    constructor(config?: Partial<AgentRegistryConfig>);
+    private store;
+    private eventCallbacks;
+    constructor(config?: Partial<AgentRegistryConfig & {
+        dataDir?: string;
+    }>);
+    load(): Promise<void>;
     register(agent: AgentRegistrationRequest): Promise<void>;
     deregister(agentId: string): Promise<void>;
     heartbeat(agentId: string, metrics?: AgentRegistration['metadata']): Promise<void>;
+    setStatus(agentId: string, status: AgentHealthStatus): void;
     getAgent(agentId: string): AgentRegistration | undefined;
     getAllAgents(): AgentRegistration[];
     getHealthyAgents(): AgentRegistration[];
@@ -1479,6 +1559,9 @@ declare class AgentRegistry {
     startHeartbeatCheck(): void;
     stopHeartbeatCheck(): void;
     private checkHeartbeats;
+    onEvent(callback: AgentEventCallback): void;
+    offEvent(callback: AgentEventCallback): void;
+    private emitEvent;
     private selectRandom;
     private selectRoundRobin;
     private selectLeastConnections;
@@ -1487,15 +1570,21 @@ declare class AgentRegistry {
     setLastHeartbeat(agentId: string, timestamp: number): void;
 }
 
+type AgentListChangeCallback = (agents: AgentSyncInfo[], action: 'add' | 'update' | 'remove', agent: AgentSyncInfo) => void | Promise<void>;
 declare class AgentSyncManager {
     private config;
+    private internalConfig;
     private registry;
     private localNodeId;
     private localNodeName;
     private remoteNodes;
     private remoteAgents;
     private syncTimer;
+    private cleanupTimer;
+    private reconnectTimer;
+    private heartbeatTimer;
     private running;
+    private agentListChangeCallbacks;
     constructor(options: {
         registry: AgentRegistry;
         localNodeId: string;
@@ -1506,6 +1595,7 @@ declare class AgentSyncManager {
     stop(): Promise<void>;
     private pullFromAllNodes;
     pullFromNode(nodeId: string): Promise<AgentSyncInfo[]>;
+    private calculateRetryDelay;
     pushEvent(message: SyncMessage): Promise<void>;
     pushToNode(nodeId: string, message: SyncMessage): Promise<void>;
     handleSyncMessage(message: SyncMessage): Promise<void>;
@@ -1515,8 +1605,16 @@ declare class AgentSyncManager {
     private handleAgentDeregister;
     private handleAgentHeartbeat;
     private handleAgentStatusChange;
+    private cleanupStaleAgents;
+    private reconnectFailedNodes;
+    private checkNodeHealth;
+    private handleLocalAgentEvent;
+    private agentToSyncInfo;
     private resolveConflict;
     private getLocalAgentsForSync;
+    private notifyAgentListChange;
+    onAgentListChange(callback: AgentListChangeCallback): void;
+    offAgentListChange(callback: AgentListChangeCallback): void;
     getMergedAgentList(): AgentSyncInfo[];
     getRemoteAgents(): AgentSyncInfo[];
     getStats(): SyncStats;
@@ -1564,6 +1662,11 @@ declare namespace Log {
     function create(tags?: Record<string, any>): Logger;
 }
 
+interface LocalCommandResult {
+    handled: boolean;
+    reply?: string;
+    continueProcessing?: boolean;
+}
 declare abstract class BaseChannelPlugin implements ChannelPlugin {
     abstract readonly id: string;
     abstract readonly platform: PlatformType;
@@ -1594,12 +1697,12 @@ declare abstract class BaseChannelPlugin implements ChannelPlugin {
     protected buildSessionId(channelId: string, chatId: string, userId?: string): string;
     protected handleMessage(message: GatewayMessage): Promise<void>;
     protected handleEvent(type: string, data?: unknown): Promise<void>;
-    protected getCommandList(): Promise<Array<{
-        name: string;
-        description?: string;
-        agent?: string;
-        model?: string;
-    }>>;
+    protected getCommandList(): Promise<Command[]>;
+    protected processLocalCommand(command: string, sessionId: string, chatId: string): Promise<LocalCommandResult>;
+    private handleNewCommand;
+    private handleStatusCommand;
+    private formatStatusReport;
+    private formatUptime;
 }
 
 interface PluginLoaderConfig {
@@ -1621,6 +1724,7 @@ declare class ChannelPluginLoader {
     private backoffPolicy;
     constructor(config?: PluginLoaderConfig);
     setMessageHandler(handler: MessageHandler): void;
+    updateSessionHandler(session: NonNullable<MessageHandler['session']>): void;
     register(plugin: ChannelPlugin, config: ChannelConfig): Promise<void>;
     unregister(pluginId: string): Promise<void>;
     start(pluginId: string): Promise<void>;
@@ -1801,6 +1905,7 @@ interface ResolveChannelParams {
         get(sessionId: string): GatewaySession | undefined;
         getOrCreate(channelInfo: SessionChannelInfo, context?: Record<string, unknown>): Promise<GatewaySession>;
         bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
+        findByBackendSessionId(backendSessionId: string): GatewaySession | undefined;
         getAll?(): GatewaySession[];
     };
     pluginLoader?: {
@@ -1850,6 +1955,38 @@ interface ResolveChannelParams {
     };
 }
 
+declare class WebSocketServerAgentSync {
+    private wsServer;
+    private syncManager;
+    private gatewayId;
+    private subscribers;
+    private getClientWs;
+    constructor(options: {
+        wsServer: GatewayWebSocketServer;
+        syncManager: AgentSyncManager;
+        getClientWs: (clientId: string) => WSContext | undefined;
+    });
+    handleAgentListRequest(clientId: string, requestId: string): Promise<void>;
+    handleAgentSubscribe(clientId: string, subscribe: boolean): Promise<void>;
+    broadcastAgentUpdate(action: 'add' | 'update' | 'remove', agent: AgentSyncInfo): void;
+    broadcastAgentList(): void;
+    cleanupClientSubscription(clientId: string): void;
+    getSubscriberCount(): number;
+    getSubscribers(): string[];
+    private sendMessage;
+    handleAgentRegister(clientId: string, payload: {
+        agentId: string;
+        name: string;
+        address: string;
+        capabilities?: string[];
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    handleAgentDeregister(clientId: string, payload: {
+        agentId: string;
+    }): Promise<void>;
+    cleanupClient(clientId: string): Promise<void>;
+}
+
 type MessageSender = (pluginId: string, message: GatewayMessage, options?: SendOptions) => Promise<string>;
 interface SendOptions extends Record<string, unknown> {
 }
@@ -1861,8 +1998,7 @@ declare class GatewayWebSocketServer {
     private httpRedirectServer;
     private connections;
     private subscriptions;
-    private sessionSubscriptions;
-    private sessionLastActivity;
+    private clientLastActivity;
     private cleanupInterval;
     private heartbeatInterval;
     private startTime;
@@ -1872,6 +2008,20 @@ declare class GatewayWebSocketServer {
     setChannelResolveDeps(params: ResolveChannelParams): void;
     private pluginLoaderRef;
     setPluginLoader(sender: MessageSender): void;
+    private agentSyncRef;
+    getGatewayId(): string;
+    setAgentSync(agentSync: WebSocketServerAgentSync): void;
+    private agentRegistryRef;
+    setAgentRegistry(registry: {
+        getStats(): {
+            totalAgents: number;
+            healthyAgents: number;
+            unhealthyAgents: number;
+        };
+    }): void;
+    private routerRef;
+    setRouter(router: MessageRouter): void;
+    private subscribers;
     private getChannelResolveParams;
     start(): Promise<void>;
     private startHTTPServer;
@@ -1880,27 +2030,32 @@ declare class GatewayWebSocketServer {
     private setupWebSocketUpgrade;
     private startHTTPRedirectServer;
     stop(): Promise<void>;
-    broadcastToSession(sessionId: string, event: SessionEventPayload): void;
+    private touchClient;
     getConnectionCount(): number;
+    getStartTime(): number;
     getSubscriptionCount(): number;
     getConnectionInfos(): WebSocketConnectionInfo[];
     isRunning(): boolean;
     private handleConnection;
     private handleDisconnection;
+    private cleanupClientResources;
     private handleMessage;
-    private handleInitialize;
     private handleSubscribe;
     private handleUnsubscribe;
     private handleMessageRequest;
+    private getClientIdByWs;
+    getClientWs(clientId: string): WSContext | undefined;
     private handleInterrupt;
     private handleReleaseSubscription;
-    private touchSession;
     private checkConnectionTimeout;
-    private cleanupExpiredSessions;
-    private releaseSessionResources;
+    private cleanupInactiveClients;
     private sendMessage;
     private sendError;
     private createRoutes;
+    private handleAgentListRequest;
+    private handleAgentSubscribe;
+    private handleAgentRegister;
+    private handleAgentDeregister;
 }
 
 declare class GatewayServer implements IGatewayServer {
@@ -1914,6 +2069,9 @@ declare class GatewayServer implements IGatewayServer {
     private messageStore;
     private contactStore;
     private wsServer;
+    private agentRegistry;
+    private agentSyncManager;
+    private wsAgentSync;
     private running;
     private connections;
     private gatewayAgent;
@@ -1926,6 +2084,11 @@ declare class GatewayServer implements IGatewayServer {
         port?: number;
         hostname?: string;
         connections?: number;
+        agents?: {
+            total: number;
+            healthy: number;
+            unhealthy: number;
+        };
     };
     onMessage(message: GatewayMessage): Promise<void>;
     private saveContactFromMessage;
@@ -1957,184 +2120,6 @@ declare class GatewayServer implements IGatewayServer {
     getMessageHistory(sessionId: string, limit?: number): Promise<MessageRecord[]>;
 }
 
-interface GatewayClientConfig {
-    url: string;
-    type: SubscriberType;
-    id?: string;
-    reconnect?: {
-        enabled: boolean;
-        maxAttempts: number;
-        delay: number;
-    };
-    heartbeat?: {
-        enabled: boolean;
-        interval: number;
-    };
-}
-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;
-    chatType?: string;
-    chatTitle?: 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[];
-    preferLocal?: boolean;
-    filterOffline?: boolean;
-}
-declare class GatewayClient {
-    private log;
-    private config;
-    private ws;
-    private state;
-    private subscriptions;
-    private messageCallbacks;
-    private agentListCallbacks;
-    private cachedAgentList;
-    private localAgentList;
-    private reconnectAttempts;
-    private reconnectTimer;
-    private heartbeatTimer;
-    private agentListRequestId;
-    private agentListRequestResolve;
-    constructor(config: GatewayClientConfig);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    subscribe(sessionId: string, backendSessionId?: string): Promise<void>;
-    unsubscribe(sessionId: string): Promise<void>;
-    send(message: GatewayMessage): Promise<void>;
-    onMessage(callback: MessageCallback): void;
-    offMessage(callback: MessageCallback): void;
-    getState(): ConnectionState;
-    getId(): string;
-    getSubscriptions(): string[];
-    setLocalAgents(agents: AgentSyncInfo[]): void;
-    fetchAgentList(): Promise<AgentSyncInfo[]>;
-    getConnectableAgents(options?: AgentListMergeOptions): AgentSyncInfo[];
-    onAgentListChange(callback: AgentListChangeCallback): void;
-    offAgentListChange(callback: AgentListChangeCallback): void;
-    private mergeAgentLists;
-    private updateMergedAgentList;
-    private handleAgentListResponse;
-    private sendData;
-    private handleMessage;
-    private handleAgentUpdate;
-    private handleGatewayMessage;
-    private handleClose;
-    private scheduleReconnect;
-    private stopReconnect;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private resubscribeAll;
-    private getHttpUrl;
-    private httpRequest;
-    healthCheck(): Promise<HealthResponse>;
-    getStatus(): Promise<StatusResponse>;
-    listChannels(): Promise<ChannelListResponse>;
-    listContacts(platform: string, options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<ContactListResponse>;
-    getContact(uid: string): Promise<ContactInfo & {
-        aliases?: Record<string, unknown>;
-    }>;
-    getSession(sessionId: string): Promise<SessionInfo & {
-        subscriberCount?: number;
-    }>;
-    createSession(params?: {
-        title?: string;
-        channel?: {
-            platform?: string;
-            channelId?: string;
-            userId?: string;
-            chatId?: string;
-        };
-    }): Promise<CreateSessionResponse>;
-    getOrCreateSession(options: {
-        sessionId?: string;
-        channel?: string;
-        userId?: string;
-        chatId?: string;
-        platform?: string;
-    }): Promise<{
-        sessionId: string;
-        created: boolean;
-    }>;
-    listSessions(options?: {
-        limit?: number;
-        offset?: number;
-        platform?: string;
-        channelId?: string;
-        userId?: string;
-        chatId?: string;
-    }): Promise<SessionListResponse>;
-    sendMessage(sessionId: string, message: {
-        content: Array<{
-            type: string;
-            text?: string;
-            image?: string;
-            data?: string;
-        }>;
-        channel?: string;
-        userId?: string;
-        chatId?: string;
-        messageType?: string;
-        processorId?: string;
-        agent?: string;
-    }): Promise<SendMessageResponse>;
-}
-
 interface TelegramBotConfig {
     botToken: string;
     webhook?: {
@@ -2661,7 +2646,6 @@ declare class WebChatPlugin extends BaseChannelPlugin {
         maxMessageLength: number;
         maxMediaCount: number;
     };
-    pushEvent(sessionId: string, event: SessionEventPayload): void;
     getWebSocketServer(): GatewayWebSocketServer | null;
     handleConnection(ws: WebSocket, userId: string): Promise<void>;
     getConnectionCount(): number;
@@ -2867,7 +2851,200 @@ declare function createChannelPlugin<TConfig = unknown, TProbe = unknown>(option
 declare const ChannelPluginRegistry: Record<string, new (id?: string) => ChannelPlugin>;
 declare function getSupportedPlatforms(): string[];
 
-declare function setAgentAdapter(adapter: AgentAdapter): void;
+declare enum SdkEventType {
+    SDK_SESSION_STATUS = "agent.status",
+    SDK_ERROR = "sdk.error",
+    SDK_SESSION_UPDATE = "sdk.session_update",
+    SDK_PERMISSION_REQUEST = "sdk.permission_request",
+    SDK_SESSION_DELETED = "sdk.session_deleted"
+}
+declare const SdkSessionStatusSchema: z$1.ZodObject<{
+    sessionId: z$1.ZodString;
+    status: z$1.ZodEnum<{
+        idle: "idle";
+        busy: "busy";
+        retry: "retry";
+    }>;
+    timestamp: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SdkSessionStatusProps = z$1.infer<typeof SdkSessionStatusSchema>;
+declare const SdkErrorSchema: z$1.ZodObject<{
+    error: z$1.ZodString;
+    context: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
+    timestamp: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SdkErrorProps = z$1.infer<typeof SdkErrorSchema>;
+declare const SdkSessionUpdateSchema: z$1.ZodObject<{
+    sessionId: z$1.ZodString;
+    update: z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>;
+    timestamp: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SdkSessionUpdateProps = z$1.infer<typeof SdkSessionUpdateSchema>;
+declare const SdkPermissionRequestSchema: z$1.ZodObject<{
+    requestId: z$1.ZodString;
+    sessionId: z$1.ZodString;
+    permission: z$1.ZodString;
+    tool: z$1.ZodOptional<z$1.ZodObject<{
+        callId: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
+    timestamp: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SdkPermissionRequestProps = z$1.infer<typeof SdkPermissionRequestSchema>;
+declare const SdkSessionDeletedSchema: z$1.ZodObject<{
+    sessionId: z$1.ZodString;
+    timestamp: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SdkSessionDeletedProps = z$1.infer<typeof SdkSessionDeletedSchema>;
+type LocalEventProperties = SdkSessionStatusProps | SdkErrorProps | SdkSessionUpdateProps | SdkPermissionRequestProps | SdkSessionDeletedProps;
+interface LocalEvent<T extends SdkEventType = SdkEventType> {
+    type: T;
+    properties: LocalEventProperties;
+}
+type LocalEventCallback = (event: LocalEvent) => void | Promise<void>;
+declare class SdkEventBus {
+    private subscriptions;
+    private wildcardSubscriptions;
+    private destroyed;
+    subscribe(eventType: SdkEventType, callback: LocalEventCallback): () => void;
+    subscribeAll(callback: LocalEventCallback): () => void;
+    publish(event: LocalEvent): Promise<void>;
+    publishSync(event: LocalEvent): void;
+    subscriberCount(eventType?: SdkEventType): number;
+    totalSubscribers(): number;
+    hasSubscribers(eventType?: SdkEventType): boolean;
+    clear(): void;
+    destroy(): void;
+    isDestroyed(): boolean;
+}
+
+declare class SdkEventBridge {
+    private sdk;
+    private sdkEventBus?;
+    private abortController;
+    private started;
+    private readonly sessionFilter?;
+    constructor(sdk: EasbotClient, localEventBus?: SdkEventBus, sessionFilter?: (sessionId: string) => boolean);
+    private pushEvent;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isStarted(): boolean;
+    private runEventLoop;
+    private handleEvent;
+    private handleSessionDeleted;
+    private handlePermissionAsked;
+    private handleMessagePartUpdated;
+    private handleToolPart;
+    private handleTextPart;
+    private handleStepStartPart;
+    private handleStepFinishPart;
+    private handleReasoningPart;
+    private handleSessionStatus;
+}
+
+interface AgentClientFilterConfig {
+    includeThinking: boolean;
+    includeToolDetails: boolean;
+    includeToolOutput: boolean;
+    includeSteps: boolean;
+}
+declare const DEFAULT_AGENT_FILTER: AgentClientFilterConfig;
+declare const DEBUG_AGENT_FILTER: AgentClientFilterConfig;
+interface AgentMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    thinking?: string;
+    tools?: Array<{
+        name: string;
+        status: 'completed' | 'error';
+        output?: unknown;
+        error?: string;
+    }>;
+    metadata: {
+        sessionId: string;
+        sessionStatus?: 'idle' | 'busy' | 'retry' | 'error';
+        messageId: string;
+        timestamp: number;
+        tokens?: {
+            input: number;
+            output: number;
+            total: number;
+        };
+        error?: string;
+    };
+}
+type SessionEventType = 'part.updated' | 'session.status' | 'message.updated' | 'message.part.updated' | 'session.error';
+interface SessionError {
+    name: string;
+    data: {
+        message?: string;
+        providerId?: string;
+        statusCode?: number;
+        isRetryable?: boolean;
+        responseHeaders?: Record<string, string>;
+        metadata?: Record<string, unknown>;
+        retries?: number;
+        [key: string]: unknown;
+    };
+}
+interface SessionEvent {
+    type: SessionEventType;
+    properties: {
+        sessionId?: string;
+        info?: {
+            id?: string;
+        };
+        part?: PartData;
+        status?: {
+            type?: string;
+        };
+        error?: SessionError;
+    };
+}
+interface PartData {
+    type: 'text' | 'reasoning' | 'tool' | 'step-start' | 'step-finish';
+    text?: string;
+    messageId?: string;
+    time?: {
+        start?: number;
+        end?: number;
+    };
+    tool?: string;
+    state?: {
+        status?: 'running' | 'completed' | 'error';
+        output?: unknown;
+        error?: string;
+    };
+    tokens?: {
+        input: number;
+        output: number;
+        reasoning: number;
+    };
+}
+declare class SdkMessagetCollector {
+    private filterConfig;
+    events: SessionEvent[];
+    isComplete: boolean;
+    private hasTextEnd;
+    private hasStepFinish;
+    private error;
+    private sessionStatus;
+    private sessionId;
+    private messageId;
+    constructor(filterConfig?: AgentClientFilterConfig);
+    addEvent(event: SessionEvent): void;
+    private shouldIncludeEvent;
+    private checkCompletion;
+    checkComplete(): boolean;
+    hasTextEndReady(): boolean;
+    isTextOnlyComplete(): boolean;
+    resetForNextMessage(): void;
+    getCurrentMessageId(): string;
+    assembleMessage(): AgentMessage;
+    reset(): void;
+}
+
+declare function setAgentAdapter(adapter: AgentAdapter | undefined): void;
 declare function getAgentAdapter(): AgentAdapter | undefined;
 declare function hasAgentAdapter(): boolean;
 declare function requireAgentAdapter(): AgentAdapter;
@@ -2880,4 +3057,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, 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 };
+export { type AgentClientFilterConfig, type AgentDeregisterMessage, type AgentHealthStatus, type AgentHeartbeat, type AgentHeartbeatSyncMessage, type AgentListRequestMessage, type AgentListResponseMessage, type AgentMessage, 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 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, type CreateSessionRequest, type CreateSessionResponse, DEBUG_AGENT_FILTER, DEFAULT_AGENT_FILTER, 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, type GatewayClientConfig, GatewayClientConfigSchema, 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 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, SdkEventBridge, SdkEventBus, SdkEventType, SdkMessagetCollector, type SdkSessionStatusProps, type SendMessageRequest, type SendMessageResponse, type SerializableSession, type ServerConnectedMessage, type ServerErrorMessage, type ServerEventMessage, type ServerInterruptedMessage, type ServerMessage, type ServerMessageType, type ServerPongMessage, type ServerResponseMessage, type ServerStatusResponse, type ServerSubscribedMessage, type ServerSubscriptionReleasedMessage, type ServerUnsubscribedMessage, type SessionChannelInfo, type SessionConfig$1 as SessionConfig, SessionConfigSchema, type SessionContext, type SessionEventPayload, type SessionEventType$1 as 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, convertToGatewayMessage, createChannelPlugin, createDefaultSessionState, createGatewayMessage, createTextMessage, generateSessionId, generateSubscriptionId, getAgentAdapter, getAgentRegistryConfig, getAuthConfig, getChannelConfig, getCircuitBreakerConfig, getClusterConfig, getConfig, getConfigDirectory, getConnectionPoolConfig, getDefaultAgent, getGatewayClientConfig, getGatewayClientUrl, getHTTPSConfig, getLogLevel, getMessageQueueConfig, getServerConfig, getSessionConfig, getSupportedPlatforms, hasAgentAdapter, initLog, isConfigLoaded, loadConfig, parsePartialConfig, requireAgentAdapter, setAgentAdapter, validateConfig };