@easbot/gateway 0.1.11

package/dist/index.d.cts

@@ -0,0 +1,2238 @@
+import { IGatewayServer, GatewayConfig as GatewayConfig$1, GatewayServerConfig as GatewayServerConfig$1, PlatformType, GatewayMessage, SubAgentConfig, ChannelInfo } from '@easbot/types';
+export { AgentInfo, ChannelInfo, GatewayMessage, GatewayMessagePromptPart, IGatewayServer, MessageContext, MessageMetadata, MessageType, PlatformType } from '@easbot/types';
+import z from 'zod';
+import { WSContext } from '@easbot/utils';
+
+declare namespace Gateway {
+    export interface BootstrapConfig {
+        directory?: string;
+        printLogs?: boolean;
+        logLevel?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+    }
+    type StateResult = {
+        server: IGatewayServer | null;
+        config: GatewayConfig$1 | null;
+        initialized: boolean;
+        status: 'stopped' | 'starting' | 'running' | 'stopping' | 'error';
+        error?: string;
+    };
+    export function init(config?: BootstrapConfig): Promise<void>;
+    export function isInitialized(): boolean;
+    export function state(): Promise<StateResult>;
+    export function get(): Promise<IGatewayServer | null>;
+    export function isEnabled(): Promise<boolean>;
+    export function config(): Promise<GatewayConfig$1 | null>;
+    export function getStatus(): 'stopped' | 'starting' | 'running' | 'stopping' | 'error';
+    export function start(options?: Partial<GatewayServerConfig$1>): Promise<void>;
+    export function stop(): Promise<void>;
+    export function restart(options?: Partial<GatewayServerConfig$1>): Promise<void>;
+    export function reloadConfig(): Promise<GatewayConfig$1>;
+    export function createGatewayServer(config: GatewayServerConfig$1, options?: {
+        startupTimeout?: number;
+        onStarted?: (server: IGatewayServer) => void | Promise<void>;
+    }): Promise<IGatewayServer>;
+    export {  };
+}
+
+declare const ChannelTypeSchema: z.ZodEnum<{
+    signal: "signal";
+    telegram: "telegram";
+    slack: "slack";
+    feishu: "feishu";
+    wechat: "wechat";
+    webchat: "webchat";
+    nostr: "nostr";
+}>;
+type ChannelType = z.infer<typeof ChannelTypeSchema>;
+declare const MessagePrioritySchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    critical: "critical";
+}>;
+type MessagePriority = z.infer<typeof MessagePrioritySchema>;
+declare const TelegramChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    botToken: z.ZodString;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type TelegramChannelConfig = z.infer<typeof TelegramChannelConfigSchema>;
+declare const SlackChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    botToken: z.ZodString;
+    appToken: z.ZodOptional<z.ZodString>;
+    signingSecret: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type SlackChannelConfig = z.infer<typeof SlackChannelConfigSchema>;
+declare const FeishuChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    appId: z.ZodString;
+    appSecret: z.ZodString;
+    encryptKey: z.ZodOptional<z.ZodString>;
+    verificationToken: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type FeishuChannelConfig = z.infer<typeof FeishuChannelConfigSchema>;
+declare const WeChatChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        official: "official";
+        wecom: "wecom";
+    }>>;
+    appId: z.ZodString;
+    appSecret: z.ZodString;
+    token: z.ZodOptional<z.ZodString>;
+    encodingAESKey: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type WeChatChannelConfig = z.infer<typeof WeChatChannelConfigSchema>;
+declare const WebChatChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    cors: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+type WebChatChannelConfig = z.infer<typeof WebChatChannelConfigSchema>;
+declare const SignalChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    serviceUrl: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    phoneNumber: z.ZodString;
+    password: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type SignalChannelConfig = z.infer<typeof SignalChannelConfigSchema>;
+declare const NostrChannelConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    relays: z.ZodArray<z.ZodString>;
+    privateKey: z.ZodOptional<z.ZodString>;
+    publicKey: z.ZodOptional<z.ZodString>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type NostrChannelConfig = z.infer<typeof NostrChannelConfigSchema>;
+declare const ChannelConfigSchema: z.ZodObject<{
+    telegram: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        botToken: z.ZodString;
+        webhookUrl: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    slack: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        botToken: z.ZodString;
+        appToken: z.ZodOptional<z.ZodString>;
+        signingSecret: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    feishu: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        appId: z.ZodString;
+        appSecret: z.ZodString;
+        encryptKey: z.ZodOptional<z.ZodString>;
+        verificationToken: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    wechat: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            official: "official";
+            wecom: "wecom";
+        }>>;
+        appId: z.ZodString;
+        appSecret: z.ZodString;
+        token: z.ZodOptional<z.ZodString>;
+        encodingAESKey: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    webchat: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        cors: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+    signal: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        serviceUrl: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        phoneNumber: z.ZodString;
+        password: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    nostr: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        relays: z.ZodArray<z.ZodString>;
+        privateKey: z.ZodOptional<z.ZodString>;
+        publicKey: z.ZodOptional<z.ZodString>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const HTTPSConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    cert: z.ZodString;
+    key: z.ZodString;
+    certPath: z.ZodOptional<z.ZodString>;
+    keyPath: z.ZodOptional<z.ZodString>;
+    ca: z.ZodOptional<z.ZodString>;
+    forceRedirect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    httpPort: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+type HTTPSConfig = z.infer<typeof HTTPSConfigSchema>;
+declare const TokenAuthItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+    permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TokenAuthItem = z.infer<typeof TokenAuthItemSchema>;
+declare const TokenAuthConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    tokens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    onInvalid: z.ZodDefault<z.ZodEnum<{
+        reject: "reject";
+        anonymous: "anonymous";
+    }>>;
+    allowAnonymous: z.ZodDefault<z.ZodBoolean>;
+    defaultPermissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TokenAuthConfig = z.infer<typeof TokenAuthConfigSchema>;
+declare const OAuth2AuthConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    authorizationServer: z.ZodString;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    tokenValidationEndpoint: z.ZodString;
+    scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type OAuth2AuthConfig = z.infer<typeof OAuth2AuthConfigSchema>;
+declare const AuthConfigSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        token: "token";
+        oauth2: "oauth2";
+    }>>;
+    token: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        tokens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            expiresAt: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        onInvalid: z.ZodDefault<z.ZodEnum<{
+            reject: "reject";
+            anonymous: "anonymous";
+        }>>;
+        allowAnonymous: z.ZodDefault<z.ZodBoolean>;
+        defaultPermissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    oauth2: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        authorizationServer: z.ZodString;
+        clientId: z.ZodString;
+        clientSecret: z.ZodString;
+        tokenValidationEndpoint: z.ZodString;
+        scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AuthConfig = z.infer<typeof AuthConfigSchema>;
+declare const AgentSyncConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        push: "push";
+        pull: "pull";
+        both: "both";
+    }>>;
+    interval: z.ZodDefault<z.ZodNumber>;
+    pushEvents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        register: "register";
+        deregister: "deregister";
+        heartbeat: "heartbeat";
+        status_change: "status_change";
+    }>>>;
+    conflictResolution: z.ZodDefault<z.ZodEnum<{
+        latest: "latest";
+        local: "local";
+        remote: "remote";
+    }>>;
+}, z.core.$strip>;
+type AgentSyncConfig = z.infer<typeof AgentSyncConfigSchema>;
+declare const GatewayNodeConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    address: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+type GatewayNodeConfig = z.infer<typeof GatewayNodeConfigSchema>;
+declare const GatewayClusterConfigSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        address: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>>;
+    sync: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            push: "push";
+            pull: "pull";
+            both: "both";
+        }>>;
+        interval: z.ZodDefault<z.ZodNumber>;
+        pushEvents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            register: "register";
+            deregister: "deregister";
+            heartbeat: "heartbeat";
+            status_change: "status_change";
+        }>>>;
+        conflictResolution: z.ZodDefault<z.ZodEnum<{
+            latest: "latest";
+            local: "local";
+            remote: "remote";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type GatewayClusterConfig = z.infer<typeof GatewayClusterConfigSchema>;
+declare const ConnectionPoolConfigSchema: z.ZodObject<{
+    maxConnectionsPerChannel: z.ZodDefault<z.ZodNumber>;
+    idleTimeout: z.ZodDefault<z.ZodNumber>;
+    reuseStrategy: z.ZodDefault<z.ZodEnum<{
+        lru: "lru";
+        fifo: "fifo";
+        random: "random";
+    }>>;
+    healthCheckInterval: z.ZodDefault<z.ZodNumber>;
+    acquireTimeout: z.ZodDefault<z.ZodNumber>;
+    warmupCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ConnectionPoolConfig = z.infer<typeof ConnectionPoolConfigSchema>;
+declare const MessageQueueConfigSchema: z.ZodObject<{
+    maxLength: z.ZodDefault<z.ZodNumber>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    batchTimeout: z.ZodDefault<z.ZodNumber>;
+    priorityLevels: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type MessageQueueConfig = z.infer<typeof MessageQueueConfigSchema>;
+declare const CircuitBreakerConfigSchema: z.ZodObject<{
+    failureThreshold: z.ZodDefault<z.ZodNumber>;
+    successThreshold: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    halfOpenDuration: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type CircuitBreakerConfig = z.infer<typeof CircuitBreakerConfigSchema>;
+declare const AgentRegistryConfigSchema: z.ZodObject<{
+    heartbeatInterval: z.ZodDefault<z.ZodNumber>;
+    heartbeatTimeout: z.ZodDefault<z.ZodNumber>;
+    heartbeatCheckInterval: z.ZodDefault<z.ZodNumber>;
+    autoDeregisterTimeout: z.ZodDefault<z.ZodNumber>;
+    maxAgents: z.ZodDefault<z.ZodNumber>;
+    persistenceFile: z.ZodOptional<z.ZodString>;
+    maxRegistrations: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type AgentRegistryConfig = z.infer<typeof AgentRegistryConfigSchema>;
+declare const SessionConfigSchema: z.ZodObject<{
+    sessionTimeout: z.ZodDefault<z.ZodNumber>;
+    resumeGracePeriod: z.ZodDefault<z.ZodNumber>;
+    maxSessions: z.ZodDefault<z.ZodNumber>;
+    persistenceFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SessionConfig$1 = z.infer<typeof SessionConfigSchema>;
+declare const GatewayServerConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    hostname: z.ZodDefault<z.ZodString>;
+    path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sessionExpireMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    https: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        cert: z.ZodString;
+        key: z.ZodString;
+        certPath: z.ZodOptional<z.ZodString>;
+        keyPath: z.ZodOptional<z.ZodString>;
+        ca: z.ZodOptional<z.ZodString>;
+        forceRedirect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        httpPort: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<{
+            token: "token";
+            oauth2: "oauth2";
+        }>>;
+        token: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            tokens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodString;
+                permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                expiresAt: z.ZodOptional<z.ZodNumber>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            onInvalid: z.ZodDefault<z.ZodEnum<{
+                reject: "reject";
+                anonymous: "anonymous";
+            }>>;
+            allowAnonymous: z.ZodDefault<z.ZodBoolean>;
+            defaultPermissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        oauth2: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            authorizationServer: z.ZodString;
+            clientId: z.ZodString;
+            clientSecret: z.ZodString;
+            tokenValidationEndpoint: z.ZodString;
+            scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cors: z.ZodDefault<z.ZodBoolean>;
+    corsOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mdns: z.ZodDefault<z.ZodBoolean>;
+    mdnsDomain: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type GatewayServerConfig = z.infer<typeof GatewayServerConfigSchema>;
+declare const GatewayConfigSchema: z.ZodObject<{
+    server: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        hostname: z.ZodDefault<z.ZodString>;
+        path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        sessionExpireMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        https: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            cert: z.ZodString;
+            key: z.ZodString;
+            certPath: z.ZodOptional<z.ZodString>;
+            keyPath: z.ZodOptional<z.ZodString>;
+            ca: z.ZodOptional<z.ZodString>;
+            forceRedirect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            httpPort: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        auth: z.ZodOptional<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<{
+                token: "token";
+                oauth2: "oauth2";
+            }>>;
+            token: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                tokens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    value: z.ZodString;
+                    permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    expiresAt: z.ZodOptional<z.ZodNumber>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                onInvalid: z.ZodDefault<z.ZodEnum<{
+                    reject: "reject";
+                    anonymous: "anonymous";
+                }>>;
+                allowAnonymous: z.ZodDefault<z.ZodBoolean>;
+                defaultPermissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            oauth2: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                authorizationServer: z.ZodString;
+                clientId: z.ZodString;
+                clientSecret: z.ZodString;
+                tokenValidationEndpoint: z.ZodString;
+                scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        cors: z.ZodDefault<z.ZodBoolean>;
+        corsOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mdns: z.ZodDefault<z.ZodBoolean>;
+        mdnsDomain: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    channels: z.ZodOptional<z.ZodObject<{
+        telegram: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            botToken: z.ZodString;
+            webhookUrl: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        slack: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            botToken: z.ZodString;
+            appToken: z.ZodOptional<z.ZodString>;
+            signingSecret: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        feishu: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            appId: z.ZodString;
+            appSecret: z.ZodString;
+            encryptKey: z.ZodOptional<z.ZodString>;
+            verificationToken: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        wechat: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                official: "official";
+                wecom: "wecom";
+            }>>;
+            appId: z.ZodString;
+            appSecret: z.ZodString;
+            token: z.ZodOptional<z.ZodString>;
+            encodingAESKey: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        webchat: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            cors: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        signal: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            serviceUrl: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            phoneNumber: z.ZodString;
+            password: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        nostr: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            relays: z.ZodArray<z.ZodString>;
+            privateKey: z.ZodOptional<z.ZodString>;
+            publicKey: z.ZodOptional<z.ZodString>;
+            maxConnections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cluster: z.ZodOptional<z.ZodObject<{
+        nodeId: z.ZodString;
+        nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            address: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>>>;
+        sync: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                push: "push";
+                pull: "pull";
+                both: "both";
+            }>>;
+            interval: z.ZodDefault<z.ZodNumber>;
+            pushEvents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                register: "register";
+                deregister: "deregister";
+                heartbeat: "heartbeat";
+                status_change: "status_change";
+            }>>>;
+            conflictResolution: z.ZodDefault<z.ZodEnum<{
+                latest: "latest";
+                local: "local";
+                remote: "remote";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    connectionPool: z.ZodOptional<z.ZodObject<{
+        maxConnectionsPerChannel: z.ZodDefault<z.ZodNumber>;
+        idleTimeout: z.ZodDefault<z.ZodNumber>;
+        reuseStrategy: z.ZodDefault<z.ZodEnum<{
+            lru: "lru";
+            fifo: "fifo";
+            random: "random";
+        }>>;
+        healthCheckInterval: z.ZodDefault<z.ZodNumber>;
+        acquireTimeout: z.ZodDefault<z.ZodNumber>;
+        warmupCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    messageQueue: z.ZodOptional<z.ZodObject<{
+        maxLength: z.ZodDefault<z.ZodNumber>;
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+        batchTimeout: z.ZodDefault<z.ZodNumber>;
+        priorityLevels: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    circuitBreaker: z.ZodOptional<z.ZodObject<{
+        failureThreshold: z.ZodDefault<z.ZodNumber>;
+        successThreshold: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        halfOpenDuration: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    agentRegistry: z.ZodOptional<z.ZodObject<{
+        heartbeatInterval: z.ZodDefault<z.ZodNumber>;
+        heartbeatTimeout: z.ZodDefault<z.ZodNumber>;
+        heartbeatCheckInterval: z.ZodDefault<z.ZodNumber>;
+        autoDeregisterTimeout: z.ZodDefault<z.ZodNumber>;
+        maxAgents: z.ZodDefault<z.ZodNumber>;
+        persistenceFile: z.ZodOptional<z.ZodString>;
+        maxRegistrations: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    session: z.ZodOptional<z.ZodObject<{
+        sessionTimeout: z.ZodDefault<z.ZodNumber>;
+        resumeGracePeriod: z.ZodDefault<z.ZodNumber>;
+        maxSessions: z.ZodDefault<z.ZodNumber>;
+        persistenceFile: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultAgent: z.ZodOptional<z.ZodString>;
+    logLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        DEBUG: "DEBUG";
+        INFO: "INFO";
+        WARN: "WARN";
+        ERROR: "ERROR";
+    }>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
+declare function validateConfig(config: unknown): GatewayConfig;
+declare function parsePartialConfig(partial: unknown): GatewayConfig;
+
+declare function loadConfig(directory?: string): Promise<GatewayConfig>;
+declare function getConfig(): GatewayConfig | null;
+declare function isConfigLoaded(): boolean;
+declare function clearConfigCache(): void;
+declare function getConfigDirectory(): string;
+declare function getServerConfig(): Promise<GatewayServerConfig>;
+declare function getChannelConfig<K extends keyof NonNullable<GatewayConfig['channels']>>(channelType: K): Promise<NonNullable<GatewayConfig['channels']>[K]>;
+declare function getConnectionPoolConfig(): Promise<ConnectionPoolConfig>;
+declare function getMessageQueueConfig(): Promise<MessageQueueConfig>;
+declare function getCircuitBreakerConfig(): Promise<CircuitBreakerConfig>;
+declare function getAgentRegistryConfig(): Promise<AgentRegistryConfig>;
+declare function getSessionConfig(): Promise<SessionConfig$1>;
+declare function getHTTPSConfig(): Promise<HTTPSConfig | undefined>;
+declare function getAuthConfig(): Promise<AuthConfig | undefined>;
+declare function getClusterConfig(): Promise<GatewayConfig['cluster'] | undefined>;
+declare function getDefaultAgent(): Promise<string | undefined>;
+declare function getLogLevel(): Promise<'DEBUG' | 'INFO' | 'WARN' | 'ERROR'>;
+
+declare function createGatewayMessage(sessionId: string, type: 'input' | 'output' | 'system' | 'control', content: Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    image: string | URL | Uint8Array;
+    mime?: string;
+} | {
+    type: 'file';
+    data: string | URL | Uint8Array;
+    mime?: string;
+}>, metadata?: {
+    channel?: {
+        platform?: PlatformType | string;
+        channelId?: string;
+        userId?: string;
+        chatId?: string;
+        [key: string]: unknown;
+    };
+    context?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+}): GatewayMessage;
+declare function createTextMessage(sessionId: string, type: 'input' | 'output' | 'system' | 'control', text: string, metadata?: {
+    channel?: {
+        platform?: PlatformType | string;
+        channelId?: string;
+        userId?: string;
+        chatId?: string;
+        [key: string]: unknown;
+    };
+    context?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+}): GatewayMessage;
+
+interface ChannelConfig {
+    enabled: boolean;
+    platform: Record<string, unknown>;
+    session: SessionConfig;
+    routing: RoutingConfig;
+}
+interface SessionConfig {
+    autoCreate: boolean;
+    resetPolicy: SessionResetPolicy;
+    timeout?: number;
+}
+type SessionResetPolicy = 'never' | 'onNewConversation' | 'timeout';
+interface RoutingConfig {
+    broadcast: boolean;
+    dispatchToSubAgent: boolean;
+    subAgent?: SubAgentConfig;
+}
+interface ChannelPlugin {
+    readonly id: string;
+    readonly platform: PlatformType;
+    readonly name: string;
+    readonly version?: string;
+    start(config: ChannelConfig, messageHandler: MessageHandler): Promise<void>;
+    stop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    healthCheck(): Promise<ChannelHealth>;
+    getStatus(): ChannelStatus;
+}
+interface MessageHandler {
+    onMessage(message: GatewayMessage): Promise<void>;
+    onEvent(event: ChannelEvent): Promise<void>;
+}
+interface ChannelHealth {
+    healthy: boolean;
+    lastCheck: number;
+    error?: string;
+    details?: Record<string, unknown>;
+}
+interface ChannelStatus {
+    status: ChannelStatusType;
+    lastActivity?: number;
+    reconnectAttempts?: number;
+    error?: string;
+}
+type ChannelStatusType = 'starting' | 'running' | 'stopping' | 'stopped' | 'error' | 'reconnecting';
+interface ChannelEvent {
+    type: ChannelEventType;
+    channelId: string;
+    data?: unknown;
+    timestamp: number;
+}
+type ChannelEventType = 'connected' | 'disconnected' | 'reconnecting' | 'error' | 'message_received' | 'message_sent' | 'user_joined' | 'user_left';
+
+interface GatewaySession {
+    id: string;
+    channel: SessionChannelInfo;
+    backendSessionId: string | null;
+    subscribers: Set<string>;
+    state: SessionState;
+    createdAt: number;
+    lastActiveAt: number;
+}
+interface SessionChannelInfo {
+    platform: PlatformType;
+    channelId: string;
+    chatId?: string;
+    userId?: string;
+}
+interface SessionState {
+    status: SessionStatusType;
+    messageCount: number;
+    lastMessageAt: number | null;
+}
+type SessionStatusType = 'active' | 'idle' | 'closed';
+interface SessionContext {
+    userId?: string;
+    chatId?: string;
+    threadId?: string;
+    [key: string]: unknown;
+}
+interface SessionFilter {
+    platform?: PlatformType;
+    channelId?: string;
+    userId?: string;
+    status?: SessionStatusType;
+}
+declare function generateSessionId(channel: SessionChannelInfo): string;
+declare function createDefaultSessionState(): SessionState;
+
+interface Subscriber {
+    id: string;
+    type: SubscriberType;
+    connection: SubscriberConnection;
+    sessions: Set<string>;
+    createdAt: number;
+    lastActiveAt: number;
+}
+type SubscriberType = 'subagent' | 'tui' | 'desktop' | 'browser' | 'mobile' | 'api';
+interface SubscriberConnection {
+    send(message: GatewayMessage): Promise<void>;
+    close(): Promise<void>;
+    isConnected(): boolean;
+}
+interface Subscription {
+    id: string;
+    subscriberId: string;
+    sessionId: string;
+    createdAt: number;
+    options?: SubscriptionOptions;
+}
+interface SubscriptionOptions {
+    includeHistory?: boolean;
+    historyLimit?: number;
+    includeSystem?: boolean;
+    includeControl?: boolean;
+}
+interface RouteResult {
+    success: boolean;
+    broadcastCount: number;
+    dispatchedToSubAgent: boolean;
+    error?: string;
+}
+declare function generateSubscriptionId(subscriberId: string, sessionId: string): string;
+
+declare const DEFAULT_WEBSOCKET_SERVER_CONFIG: Partial<{
+    enabled: boolean;
+    port: number;
+    hostname: string;
+    path: string;
+    maxConnections: number;
+    connectionTimeout: number;
+    heartbeatInterval: number;
+    sessionExpireMs: number;
+    cors: boolean;
+    mdns: boolean;
+    mdnsDomain: string;
+    https?: {
+        enabled: boolean;
+        cert: string;
+        key: string;
+        forceRedirect: boolean;
+        httpPort: number;
+        certPath?: string | undefined;
+        keyPath?: string | undefined;
+        ca?: string | undefined;
+    } | undefined;
+    auth?: {
+        type: "token" | "oauth2";
+        token?: {
+            enabled: boolean;
+            tokens: {
+                name: string;
+                value: string;
+                permissions: string[];
+                expiresAt?: number | undefined;
+                description?: string | undefined;
+            }[];
+            onInvalid: "reject" | "anonymous";
+            allowAnonymous: boolean;
+            defaultPermissions: string[];
+        } | undefined;
+        oauth2?: {
+            enabled: boolean;
+            authorizationServer: string;
+            clientId: string;
+            clientSecret: string;
+            tokenValidationEndpoint: string;
+            scope: string[];
+        } | undefined;
+    } | undefined;
+    corsOrigins?: string[] | undefined;
+}>;
+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';
+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;
+    payload?: {
+        eventTypes?: string[];
+    };
+}
+interface ClientUnsubscribeMessage extends WebSocketMessageBase {
+    type: 'unsubscribe';
+    sessionId: string;
+}
+interface ClientMessageMessage extends WebSocketMessageBase {
+    type: 'message';
+    sessionId: string;
+    payload: {
+        content: string | Array<{
+            type: 'text';
+            text: string;
+        } | {
+            type: 'image';
+            image: string | URL | Uint8Array;
+            mime?: string;
+        }>;
+        [key: string]: unknown;
+    };
+}
+interface ClientPingMessage extends WebSocketMessageBase {
+    type: 'ping';
+}
+interface ClientInterruptMessage extends WebSocketMessageBase {
+    type: 'interrupt';
+    sessionId: string;
+}
+interface ClientReleaseSubscriptionMessage extends WebSocketMessageBase {
+    type: 'releaseSubscription';
+    sessionId: string;
+}
+interface ClientAgentListRequestMessage extends WebSocketMessageBase {
+    type: 'agent_list_request';
+    requestId: string;
+}
+interface ClientAgentSubscribeMessage extends WebSocketMessageBase {
+    type: 'agent_subscribe';
+    subscribe: boolean;
+}
+type ClientMessage = ClientInitializeMessage | ClientSubscribeMessage | ClientUnsubscribeMessage | ClientMessageMessage | ClientPingMessage | ClientInterruptMessage | ClientReleaseSubscriptionMessage | ClientAgentListRequestMessage | ClientAgentSubscribeMessage;
+interface ServerConnectedMessage extends WebSocketMessageBase {
+    type: 'connected';
+    clientId: string;
+    payload?: {
+        version?: string;
+        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;
+}
+interface ServerUnsubscribedMessage extends WebSocketMessageBase {
+    type: 'unsubscribed';
+    sessionId: string;
+}
+interface ServerEventMessage extends WebSocketMessageBase {
+    type: 'event';
+    sessionId: string;
+    payload: {
+        eventType: string;
+        [key: string]: unknown;
+    };
+}
+interface ServerResponseMessage extends WebSocketMessageBase {
+    type: 'response';
+    sessionId: string;
+    result?: unknown;
+    success: boolean;
+    error?: string;
+}
+interface ServerErrorMessage extends WebSocketMessageBase {
+    type: 'error';
+    message: string;
+    code?: string;
+    sessionId?: string;
+}
+interface ServerPongMessage extends WebSocketMessageBase {
+    type: 'pong';
+}
+interface ServerInterruptedMessage extends WebSocketMessageBase {
+    type: 'interrupted';
+    sessionId: string;
+    success: boolean;
+    error?: string;
+}
+interface ServerSessionClosedMessage extends WebSocketMessageBase {
+    type: 'session_closed';
+    sessionId: string;
+    payload?: {
+        reason?: string;
+    };
+}
+interface ServerSubscriptionReleasedMessage extends WebSocketMessageBase {
+    type: 'subscriptionReleased';
+    sessionId: string;
+}
+interface ServerAgentListResponseMessage extends WebSocketMessageBase {
+    type: 'agent_list_response';
+    requestId: string;
+    agents: Array<{
+        id: string;
+        name: string;
+        sourceGatewayId: string;
+        address: string;
+        capabilities: string[];
+        status: 'healthy' | 'unhealthy' | 'offline';
+        updatedAt: number;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+interface ServerAgentUpdateMessage extends WebSocketMessageBase {
+    type: 'agent_update';
+    action: 'add' | 'update' | 'remove';
+    agent: {
+        id: string;
+        name: string;
+        sourceGatewayId: string;
+        address: string;
+        capabilities: string[];
+        status: 'healthy' | 'unhealthy' | 'offline';
+        updatedAt: number;
+        metadata?: Record<string, unknown>;
+    };
+}
+type ServerMessage = ServerConnectedMessage | ServerInitializeResponseMessage | ServerSubscribedMessage | ServerUnsubscribedMessage | ServerEventMessage | ServerResponseMessage | ServerErrorMessage | ServerPongMessage | ServerInterruptedMessage | ServerSessionClosedMessage | ServerSubscriptionReleasedMessage | ServerAgentListResponseMessage | ServerAgentUpdateMessage;
+type WebSocketMessage = ClientMessage | ServerMessage;
+interface ClientSubscription {
+    clientId: string;
+    ws: WSContext;
+    subscribedSessions: Set<string>;
+    subscribedEventTypes: Set<string>;
+    authInfo?: {
+        tokenName: string;
+        permissions: string[];
+    };
+    connectedAt: number;
+    lastActivityAt: number;
+}
+type WebSocketConnectionState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
+interface WebSocketConnectionInfo {
+    clientId: string;
+    state: WebSocketConnectionState;
+    connectedAt: number;
+    lastActivityAt: number;
+    remoteAddress?: string;
+    authInfo?: ClientSubscription['authInfo'];
+}
+type SessionEventType = 'message' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'complete' | 'interrupted' | 'status_change';
+interface SessionEventPayload {
+    type: SessionEventType | string;
+    sessionId: string;
+    properties: {
+        [key: string]: unknown;
+    };
+}
+interface HealthCheckResponse {
+    status: 'healthy' | 'unhealthy';
+    timestamp: number;
+    version?: string;
+}
+interface ServerStatusResponse {
+    status: 'running' | 'stopping' | 'stopped';
+    connections: number;
+    sessions: number;
+    subscriptions: number;
+    uptime: number;
+    version?: string;
+}
+interface CreateSessionRequest {
+    title?: string;
+    channel?: {
+        platform?: PlatformType | string;
+        channelId?: string;
+        userId?: string;
+        chatId?: string;
+    };
+    context?: Record<string, unknown>;
+}
+interface CreateSessionResponse {
+    id: string;
+    createdAt: number;
+}
+interface SendMessageRequest {
+    content: string | Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        image: string;
+        mime?: string;
+    }>;
+    [key: string]: unknown;
+}
+interface SendMessageResponse {
+    messageId: string;
+    sessionId: string;
+    createdAt: number;
+}
+interface SubscriptionsResponse {
+    subscriptions: Array<{
+        sessionId: string;
+        subscriberCount: number;
+        subscribers: string[];
+    }>;
+    total: number;
+}
+
+interface TokenConfig {
+    name: string;
+    value: string;
+    permissions: string[];
+    expiresAt?: number;
+    description?: string;
+}
+interface AuthResult {
+    success: boolean;
+    authInfo?: {
+        tokenName: string;
+        permissions: string[];
+    };
+    error?: string;
+}
+interface IAuthProvider {
+    validateToken(token: string): Promise<AuthResult>;
+    checkPermission(authInfo: AuthResult['authInfo'], permission: string): boolean;
+    checkPermissions(authInfo: AuthResult['authInfo'], permissions: string[]): boolean;
+}
+declare const DEFAULT_TOKEN_AUTH_CONFIG: {
+    type: "token";
+    enabled: boolean;
+    tokens: never[];
+    onInvalid: "reject";
+    allowAnonymous: boolean;
+    defaultPermissions: never[];
+};
+
+type AgentHealthStatus = 'healthy' | 'unhealthy' | 'offline';
+interface AgentRegistration {
+    id: string;
+    name: string;
+    capabilities: string[];
+    address: string;
+    status: AgentHealthStatus;
+    lastHeartbeat: number;
+    registeredAt: number;
+    connectionCount: number;
+    metadata?: Record<string, unknown>;
+}
+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 maxAgents: 100;
+    readonly maxRegistrations: 1000;
+};
+type AgentSelectionStrategy = 'random' | 'round-robin' | 'least-connections';
+interface AgentSelectionOptions {
+    strategy: AgentSelectionStrategy;
+    capabilities?: string[];
+    healthyOnly?: boolean;
+}
+interface AgentHeartbeat {
+    agentId: string;
+    timestamp: number;
+    status: AgentHealthStatus;
+    metrics?: {
+        cpuUsage?: number;
+        memoryUsage?: number;
+        connectionCount?: number;
+        messageQueueLength?: number;
+    };
+}
+interface AgentSelectionRecord {
+    sessionId: string;
+    messageId: string;
+    agentId: string;
+    selectedAt: number;
+    strategy: AgentSelectionStrategy;
+}
+interface AgentRegistryStats {
+    totalAgents: number;
+    healthyAgents: number;
+    unhealthyAgents: number;
+    offlineAgents: number;
+    totalConnections: number;
+}
+
+interface GatewayNodeInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    lastSyncAt: number;
+    status: 'online' | 'offline' | 'unknown';
+    metadata?: Record<string, unknown>;
+}
+interface AgentSyncInfo {
+    id: string;
+    name: string;
+    sourceGatewayId: string;
+    address: string;
+    capabilities: string[];
+    status: AgentHealthStatus;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+type SyncMode = 'pull' | 'push' | 'both';
+type PushEventType = 'register' | 'deregister' | 'heartbeat' | 'status_change';
+type ConflictResolutionStrategy = 'latest' | 'local' | 'remote';
+interface SyncConfig {
+    mode: SyncMode;
+    interval: number;
+    pushEvents: PushEventType[];
+    conflictResolution: ConflictResolutionStrategy;
+    remoteNodes: Array<{
+        id: string;
+        address: string;
+        port: number;
+    }>;
+}
+declare const DEFAULT_SYNC_CONFIG: SyncConfig;
+interface AgentListRequestMessage {
+    type: 'agent_list_request';
+    requestId: string;
+    sourceNodeId: string;
+    timestamp: number;
+    incremental?: boolean;
+    lastSyncAt?: number;
+}
+interface AgentListResponseMessage {
+    type: 'agent_list_response';
+    requestId: string;
+    sourceNodeId: string;
+    timestamp: number;
+    agents: AgentSyncInfo[];
+    fullList: boolean;
+    syncAt: number;
+}
+interface AgentRegisterMessage {
+    type: 'agent_register';
+    sourceNodeId: string;
+    timestamp: number;
+    agent: AgentSyncInfo;
+}
+interface AgentDeregisterMessage {
+    type: 'agent_deregister';
+    sourceNodeId: string;
+    timestamp: number;
+    agentId: string;
+}
+interface AgentHeartbeatSyncMessage {
+    type: 'agent_heartbeat';
+    sourceNodeId: string;
+    timestamp: number;
+    agentId: string;
+    heartbeatAt: number;
+    status: AgentHealthStatus;
+}
+interface AgentStatusChangeMessage {
+    type: 'agent_status_change';
+    sourceNodeId: string;
+    timestamp: number;
+    agentId: string;
+    oldStatus: AgentHealthStatus;
+    newStatus: AgentHealthStatus;
+    changedAt: number;
+}
+type SyncMessage = AgentListRequestMessage | AgentListResponseMessage | AgentRegisterMessage | AgentDeregisterMessage | AgentHeartbeatSyncMessage | AgentStatusChangeMessage;
+interface SyncState {
+    localNodeId: string;
+    remoteNodes: Map<string, {
+        info: GatewayNodeInfo;
+        lastSyncAt: number;
+        status: 'syncing' | 'synced' | 'error';
+        error?: string;
+    }>;
+    localAgents: Map<string, AgentSyncInfo>;
+    remoteAgents: Map<string, AgentSyncInfo>;
+}
+interface SyncStats {
+    localAgentCount: number;
+    remoteAgentCount: number;
+    totalAgentCount: number;
+    onlineNodeCount: number;
+    offlineNodeCount: number;
+    lastSyncAt: number | null;
+}
+
+declare const DEFAULT_CONNECTION_POOL_CONFIG: {
+    maxConnectionsPerChannel: number;
+    idleTimeout: number;
+    reuseStrategy: "lru";
+    healthCheckInterval: number;
+    acquireTimeout: number;
+    warmupCount: number;
+};
+type ConnectionState$1 = 'idle' | 'active' | 'unhealthy' | 'closed';
+interface PooledConnection<T = unknown> {
+    id: string;
+    channelId: string;
+    connection: T;
+    state: ConnectionState$1;
+    lastActivity: number;
+    createdAt: number;
+    useCount: number;
+}
+interface ConnectionPoolStats {
+    activeConnections: number;
+    idleConnections: number;
+    totalConnections: number;
+    waitingQueueLength: number;
+    unhealthyConnections: number;
+}
+type ConnectionFactory<T = unknown> = (channelId: string) => Promise<T>;
+type ConnectionCloser<T = unknown> = (connection: T) => Promise<void>;
+type ConnectionHealthChecker<T = unknown> = (connection: T) => Promise<boolean>;
+type ConnectionPoolEventType = 'connection_created' | 'connection_acquired' | 'connection_released' | 'connection_closed' | 'connection_unhealthy' | 'pool_exhausted' | 'pool_warmed_up';
+interface ConnectionPoolEvent<T = unknown> {
+    type: ConnectionPoolEventType;
+    connectionId?: string;
+    channelId?: string;
+    connection?: PooledConnection<T>;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+type ConnectionPoolEventCallback<T = unknown> = (event: ConnectionPoolEvent<T>) => void | 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 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;
+    autoSaveInterval: number;
+    maxRetentionDays: number;
+}
+declare class GatewaySessionManager {
+    private log;
+    private sessionStore;
+    private config;
+    private initialized;
+    constructor(config?: Partial<SessionManagerConfig>);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    getOrCreate(channelInfo: SessionChannelInfo, context?: SessionContext): Promise<GatewaySession>;
+    get(sessionId: string): GatewaySession | undefined;
+    closeSession(sessionId: string): Promise<void>;
+    closeById(sessionId: string): Promise<void>;
+    bindBackendSession(gatewaySessionId: string, backendSessionId: string): Promise<void>;
+    unbindBackendSession(gatewaySessionId: string): Promise<void>;
+    getState(sessionId: string): SessionState | undefined;
+    incrementMessageCountOrCreate(sessionId: string, channelInfo?: SessionChannelInfo): Promise<GatewaySession>;
+    incrementMessageCount(sessionId: string): Promise<void>;
+    addSubscriber(sessionId: string, subscriberId: string): Promise<void>;
+    removeSubscriber(sessionId: string, subscriberId: string): Promise<void>;
+    query(filter: SessionFilter): GatewaySession[];
+    getSessionsByChannel(channelId: string): GatewaySession[];
+    getAllSessions(): GatewaySession[];
+    getSessionCount(): number;
+    cleanupIdleSessions(idleTimeoutMs: number): Promise<number>;
+    save(): Promise<void>;
+    getStats(): {
+        total: number;
+        byStatus: Record<SessionStatusType, number>;
+        byPlatform: Record<string, number>;
+    };
+}
+
+declare class AgentRegistry {
+    private config;
+    private agents;
+    private heartbeatTimer;
+    private roundRobinIndex;
+    constructor(config?: Partial<AgentRegistryConfig>);
+    register(agent: AgentRegistrationRequest): Promise<void>;
+    deregister(agentId: string): Promise<void>;
+    heartbeat(agentId: string, metrics?: AgentRegistration['metadata']): Promise<void>;
+    getAgent(agentId: string): AgentRegistration | undefined;
+    getAllAgents(): AgentRegistration[];
+    getHealthyAgents(): AgentRegistration[];
+    selectAgent(options: AgentSelectionOptions): AgentRegistration | undefined;
+    incrementConnection(agentId: string): void;
+    decrementConnection(agentId: string): void;
+    startHeartbeatCheck(): void;
+    stopHeartbeatCheck(): void;
+    private checkHeartbeats;
+    private selectRandom;
+    private selectRoundRobin;
+    private selectLeastConnections;
+    getStats(): AgentRegistryStats;
+    setAgentStatus(agentId: string, status: AgentHealthStatus): void;
+    setLastHeartbeat(agentId: string, timestamp: number): void;
+}
+
+declare class AgentSyncManager {
+    private config;
+    private registry;
+    private localNodeId;
+    private localNodeName;
+    private remoteNodes;
+    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>;
+    private pullFromAllNodes;
+    pullFromNode(nodeId: string): Promise<AgentSyncInfo[]>;
+    pushEvent(message: SyncMessage): Promise<void>;
+    pushToNode(nodeId: string, message: SyncMessage): Promise<void>;
+    handleSyncMessage(message: SyncMessage): Promise<void>;
+    private handleAgentListRequest;
+    private handleAgentListResponse;
+    private handleAgentRegister;
+    private handleAgentDeregister;
+    private handleAgentHeartbeat;
+    private handleAgentStatusChange;
+    private resolveConflict;
+    private getLocalAgentsForSync;
+    getMergedAgentList(): AgentSyncInfo[];
+    getRemoteAgents(): AgentSyncInfo[];
+    getStats(): SyncStats;
+    isRunning(): boolean;
+    addRemoteNode(node: {
+        id: string;
+        address: string;
+        port: number;
+    }): void;
+    removeRemoteNode(nodeId: string): void;
+}
+
+declare namespace Log {
+    const Level: z.ZodEnum<{
+        DEBUG: "DEBUG";
+        INFO: "INFO";
+        WARN: "WARN";
+        ERROR: "ERROR";
+    }>;
+    type Level = z.infer<typeof Level>;
+    function getLevel(): Level;
+    type Logger = {
+        debug(message?: any, extra?: Record<string, any>): void;
+        info(message?: any, extra?: Record<string, any>): void;
+        error(message?: any, extra?: Record<string, any>): void;
+        warn(message?: any, extra?: Record<string, any>): void;
+        tag(key: string, value: string): Logger;
+        clone(): Logger;
+        time(message: string, extra?: Record<string, any>): {
+            stop(): void;
+            [Symbol.dispose](): void;
+        };
+    };
+    const Default: Logger;
+    interface Options {
+        print: boolean;
+        logDir: string;
+        logFile?: string;
+        dev?: boolean;
+        level?: Level;
+    }
+    function file(): string;
+    function init(options: Options): Promise<void>;
+    function close(): Promise<void>;
+    function create(tags?: Record<string, any>): Logger;
+}
+
+declare abstract class BaseChannelPlugin implements ChannelPlugin {
+    abstract readonly id: string;
+    abstract readonly platform: PlatformType;
+    abstract readonly name: string;
+    readonly version?: string;
+    protected log: ReturnType<typeof Log.create>;
+    protected config: ChannelConfig | null;
+    protected messageHandler: MessageHandler | null;
+    protected _status: ChannelStatusType;
+    protected lastActivity: number;
+    constructor();
+    protected initLog(): void;
+    start(config: ChannelConfig, messageHandler: MessageHandler): Promise<void>;
+    stop(): Promise<void>;
+    healthCheck(): Promise<ChannelHealth>;
+    getStatus(): ChannelStatus;
+    abstract send(message: GatewayMessage): Promise<string>;
+    protected abstract doStart(): Promise<void>;
+    protected abstract doStop(): Promise<void>;
+    protected doHealthCheck(): Promise<boolean>;
+    protected updateActivity(): void;
+    protected handleMessage(message: GatewayMessage): Promise<void>;
+    protected handleEvent(type: string, data?: unknown): Promise<void>;
+}
+
+interface MessageRecord {
+    message: GatewayMessage;
+    status: MessageStatus;
+    processedBy: string | null;
+    processedAt: number | null;
+    retryCount: number;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+type MessageStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+interface MessageStoreConfig {
+    storagePath: string;
+    maxRetentionDays: number;
+    maxRecords: number;
+}
+declare class MessageStore {
+    private log;
+    private config;
+    private messages;
+    private sessionMessages;
+    constructor(config?: Partial<MessageStoreConfig>);
+    store(message: GatewayMessage): Promise<MessageRecord>;
+    get(messageId: string): MessageRecord | undefined;
+    updateStatus(messageId: string, status: MessageStatus, options?: {
+        processedBy?: string;
+        error?: string;
+    }): Promise<void>;
+    incrementRetry(messageId: string): number;
+    isProcessed(messageId: string): boolean;
+    getSessionHistory(sessionId: string, limit?: number): MessageRecord[];
+    getPendingMessages(sessionId?: string): MessageRecord[];
+    getFailedMessages(maxRetries?: number): MessageRecord[];
+    cleanup(): Promise<number>;
+    getStats(): {
+        total: number;
+        pending: number;
+        processing: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+    };
+}
+
+interface SerializableSession {
+    id: string;
+    channel: SessionChannelInfo;
+    backendSessionId: string | null;
+    subscribers: string[];
+    state: SessionState;
+    createdAt: number;
+    lastActiveAt: number;
+}
+interface SessionStoreConfig {
+    storagePath: string;
+    autoSaveInterval: number;
+    maxRetentionDays: number;
+    enablePersistence: boolean;
+}
+declare class SessionStore {
+    private log;
+    private config;
+    private sessions;
+    private channelSessions;
+    private autoSaveTimer;
+    private isDirty;
+    constructor(config?: Partial<SessionStoreConfig>);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    set(session: GatewaySession): Promise<void>;
+    get(sessionId: string): GatewaySession | undefined;
+    delete(sessionId: string): Promise<void>;
+    getAll(): GatewaySession[];
+    getByChannel(channelId: string): GatewaySession[];
+    size(): number;
+    private markDirty;
+    save(): Promise<void>;
+    load(): Promise<void>;
+    private serializeAll;
+    private serialize;
+    private getSessionFilePath;
+    private ensureStorageDir;
+    private startAutoSave;
+    private stopAutoSave;
+    cleanup(): Promise<number>;
+    getStats(): {
+        total: number;
+        byStatus: Record<SessionStatusType, number>;
+        byPlatform: Record<string, number>;
+    };
+}
+
+interface PluginLoaderConfig {
+    pluginDir?: string;
+    autoDiscover?: boolean;
+    healthCheckInterval?: number;
+    healthCheckTimeout?: number;
+}
+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>;
+}
+
+declare class GatewayWebSocketServer {
+    private config;
+    private server;
+    private wss;
+    private httpsServer;
+    private httpRedirectServer;
+    private connections;
+    private subscriptions;
+    private sessionSubscriptions;
+    private sessionLastActivity;
+    private cleanupInterval;
+    private heartbeatInterval;
+    private startTime;
+    private running;
+    constructor(config?: Partial<GatewayServerConfig>);
+    start(): Promise<void>;
+    private startHTTPServer;
+    private startHTTPSServer;
+    private loadSSLCertificates;
+    private setupWebSocketUpgrade;
+    private startHTTPRedirectServer;
+    stop(): Promise<void>;
+    broadcastToSession(sessionId: string, event: SessionEventPayload): void;
+    getConnectionCount(): number;
+    getSubscriptionCount(): number;
+    getConnectionInfos(): WebSocketConnectionInfo[];
+    isRunning(): boolean;
+    private handleConnection;
+    private handleDisconnection;
+    private handleMessage;
+    private handleInitialize;
+    private handleSubscribe;
+    private handleUnsubscribe;
+    private handleMessageRequest;
+    private handleInterrupt;
+    private handleReleaseSubscription;
+    private touchSession;
+    private checkConnectionTimeout;
+    private cleanupExpiredSessions;
+    private releaseSessionResources;
+    private sendMessage;
+    private sendError;
+    private createRoutes;
+}
+
+declare class GatewayServer implements IGatewayServer {
+    private log;
+    private config;
+    private router;
+    private sessionManager;
+    private pluginLoader;
+    private messageStore;
+    private running;
+    private connections;
+    constructor(config: GatewayServerConfig$1);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        running: boolean;
+        port?: number;
+        hostname?: string;
+        connections?: number;
+    };
+    onMessage(message: GatewayMessage): Promise<void>;
+    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;
+    }): Promise<string>;
+    sendProactiveMessage(pluginId: string, sessionId: string, content: GatewayMessage['content'], channel: ChannelInfo): Promise<string>;
+    getSessionManager(): GatewaySessionManager;
+    getRouter(): MessageRouter;
+    getPluginLoader(): ChannelPluginLoader;
+    getMessageStore(): MessageStore;
+    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>;
+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): 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;
+}
+
+interface TelegramBotConfig {
+    botToken: string;
+    webhook?: {
+        enabled: boolean;
+        url: string;
+        port?: number;
+    };
+    polling?: {
+        enabled: boolean;
+        interval?: number;
+    };
+}
+declare class TelegramPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "telegram";
+    readonly name = "Telegram Bot";
+    private botConfig;
+    private pollingInterval;
+    private lastUpdateId;
+    private baseUrl;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    private startPolling;
+    private stopPolling;
+    private poll;
+    private handleTelegramMessage;
+    private toGatewayMessage;
+    private parseContent;
+    private getSessionId;
+    private extractText;
+    private getMe;
+    private getUpdates;
+    private sendMessage;
+    private request;
+}
+
+interface DiscordBotConfig {
+    botToken: string;
+    applicationId?: string;
+    gateway?: {
+        enabled: boolean;
+        intents: number[];
+    };
+    webhook?: {
+        enabled: boolean;
+        path: string;
+        port?: number;
+    };
+}
+declare class DiscordPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "discord";
+    readonly name = "Discord Bot";
+    private botConfig;
+    private baseUrl;
+    private gatewayWs;
+    private heartbeatInterval;
+    private sessionId;
+    private sequenceNumber;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    private startGateway;
+    private handleGatewayMessage;
+    private handleHello;
+    private handleDispatch;
+    private handleDiscordMessage;
+    private toGatewayMessage;
+    private parseContent;
+    private getSessionId;
+    private extractText;
+    private getCurrentUser;
+    private getGatewayBot;
+    private createMessage;
+    private request;
+}
+
+interface SlackBotConfig {
+    botToken: string;
+    appToken?: string;
+    signingSecret?: string;
+    socketMode?: boolean;
+    webhook?: {
+        enabled: boolean;
+        path: string;
+        port?: number;
+    };
+}
+declare class SlackPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "slack";
+    readonly name = "Slack Bot";
+    private botConfig;
+    private baseUrl;
+    private socketModeClient;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    private startSocketMode;
+    private handleSocketModeEvent;
+    private handleSlackMessage;
+    private toGatewayMessage;
+    private parseContent;
+    private getSessionId;
+    private extractText;
+    private authTest;
+    private postMessage;
+    private request;
+}
+
+interface FeishuBotConfig {
+    appId: string;
+    appSecret: string;
+    encryptKey?: string;
+    verificationToken?: string;
+    webhook?: {
+        enabled: boolean;
+        path: string;
+        port?: number;
+    };
+}
+interface FeishuMessageEvent {
+    type: string;
+    app_id: string;
+    tenant_key: string;
+    event: {
+        type: string;
+        message: {
+            message_id: string;
+            root_id?: string;
+            parent_id?: string;
+            chat_id: string;
+            message_type: string;
+            content: string;
+            create_time: string;
+            sender: {
+                sender_id: {
+                    open_id: string;
+                    union_id: string;
+                    user_id: string;
+                };
+                sender_type: string;
+                tenant_key: string;
+            };
+        };
+    };
+}
+declare class FeishuPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "feishu";
+    readonly name = "Feishu Bot";
+    private botConfig;
+    private baseUrl;
+    private tenantAccessToken;
+    private tokenExpireTime;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    handleWebhookEvent(event: FeishuMessageEvent): Promise<void>;
+    private toGatewayMessage;
+    private parseContent;
+    private extractPostContent;
+    private getSessionId;
+    private extractText;
+    private refreshTenantAccessToken;
+    private ensureTokenValid;
+    private sendMessage;
+}
+
+interface WeChatBotConfig {
+    mode: 'official' | 'wecom';
+    appId: string;
+    appSecret: string;
+    token?: string;
+    encodingAESKey?: string;
+    agentId?: string;
+    webhook?: {
+        enabled: boolean;
+        path: string;
+        port?: number;
+    };
+}
+declare class WeChatPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "wechat";
+    readonly name = "WeChat Bot";
+    private botConfig;
+    private accessToken;
+    private tokenExpireTime;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    handleWebhookMessage(xmlData: string): Promise<void>;
+    private parseXmlMessage;
+    private toGatewayMessage;
+    private parseContent;
+    private getSessionId;
+    private extractText;
+    private refreshAccessToken;
+    private ensureTokenValid;
+    private sendOfficialMessage;
+    private sendWeComMessage;
+}
+
+interface WebChatConfig {
+    port: number;
+    hostname: string;
+    path: string;
+    heartbeatInterval: number;
+    connectionTimeout: number;
+    sessionExpireMs: number;
+    maxConnections: number;
+    cors: boolean;
+    https?: HTTPSConfig;
+}
+declare class WebChatPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "webchat";
+    readonly name = "WebChat";
+    private webChatConfig;
+    private connections;
+    private heartbeatInterval;
+    private wsServer;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    private startWebSocketServer;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    pushEvent(sessionId: string, event: SessionEventPayload): void;
+    getWebSocketServer(): GatewayWebSocketServer | null;
+    handleConnection(ws: WebSocket, userId: string): Promise<void>;
+    private handleWebSocketMessage;
+    private handleChatMessage;
+    private startHeartbeat;
+    private findConnectionByUser;
+    private generateConnectionId;
+    getConnectionCount(): number;
+    getWsServerConnectionCount(): number;
+}
+
+interface SignalBotConfig {
+    serviceUrl: string;
+    phoneNumber: string;
+    password?: string;
+    webhook?: {
+        enabled: boolean;
+        path: string;
+        port?: number;
+    };
+}
+declare class SignalPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "signal";
+    readonly name = "Signal Bot";
+    private botConfig;
+    private pollingInterval;
+    private lastTimestamp;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    private startPolling;
+    private poll;
+    private handleSignalMessage;
+    private toGatewayMessage;
+    private parseContent;
+    private getSessionId;
+    private extractText;
+    private getAccountInfo;
+    private receiveMessages;
+    private sendMessage;
+    private request;
+}
+
+interface NostrBotConfig {
+    relays: string[];
+    privateKey?: string;
+    publicKey?: string;
+    timeout: number;
+}
+declare class NostrPlugin extends BaseChannelPlugin {
+    readonly id: string;
+    readonly platform: "nostr";
+    readonly name = "Nostr Bot";
+    private botConfig;
+    private relayConnections;
+    private subscriptions;
+    private eventHandlers;
+    constructor(id?: string);
+    protected doStart(): Promise<void>;
+    protected doStop(): Promise<void>;
+    send(message: GatewayMessage): Promise<string>;
+    private connectToRelay;
+    private handleRelayMessage;
+    private handleNostrEvent;
+    private toGatewayMessage;
+    private parseContent;
+    private findReplyTo;
+    private getSessionId;
+    private extractText;
+    private subscribeToRelay;
+    private createEvent;
+    private computeEventId;
+    private signEvent;
+    private publishEvent;
+}
+
+interface ChannelSetupAdapter {
+    initialize?: () => Promise<void>;
+    destroy?: () => Promise<void>;
+}
+interface ChannelMessagingAdapter {
+    send: (message: GatewayMessage) => Promise<string>;
+    transformMessage?: (message: unknown) => Promise<GatewayMessage | null>;
+}
+interface ChannelStatusAdapter<TConfig = unknown, TProbe = unknown> {
+    healthCheck?: () => Promise<boolean>;
+    getStatus?: () => Promise<{
+        healthy: boolean;
+        connections?: number;
+        messages?: number;
+        errors?: number;
+        metadata?: Record<string, unknown>;
+    }>;
+    getConfig?: () => TConfig;
+    probe?: () => Promise<TProbe>;
+}
+interface ChannelDirectoryAdapter {
+    listSessions?: () => Promise<Array<{
+        sessionId: string;
+        userId?: string;
+        createdAt: number;
+        lastActivityAt: number;
+    }>>;
+    getSession?: (sessionId: string) => Promise<{
+        sessionId: string;
+        userId?: string;
+        createdAt: number;
+        lastActivityAt: number;
+    } | null>;
+}
+interface ChannelMessageActionAdapter {
+    beforeSend?: (message: GatewayMessage) => Promise<GatewayMessage>;
+    afterSend?: (message: GatewayMessage, result: string) => Promise<void>;
+    beforeReceive?: (message: GatewayMessage) => Promise<GatewayMessage>;
+    afterReceive?: (message: GatewayMessage) => Promise<void>;
+}
+interface ChannelBindingsAdapter {
+    bindUser?: (userId: string, sessionId: string) => Promise<void>;
+    unbindUser?: (userId: string) => Promise<void>;
+    getUserSession?: (userId: string) => Promise<string | null>;
+}
+interface CreateChannelPluginOptions<TConfig = unknown, TProbe = unknown> {
+    id: string;
+    platform: PlatformType | string;
+    name: string;
+    version?: string;
+    setup?: ChannelSetupAdapter;
+    messaging: ChannelMessagingAdapter;
+    status?: ChannelStatusAdapter<TConfig, TProbe>;
+    directory?: ChannelDirectoryAdapter;
+    actions?: ChannelMessageActionAdapter;
+    bindings?: ChannelBindingsAdapter;
+}
+declare function createChannelPlugin<TConfig = unknown, TProbe = unknown>(options: CreateChannelPluginOptions<TConfig, TProbe>): BaseChannelPlugin;
+
+declare const ChannelPluginRegistry: Record<string, new (id?: string) => ChannelPlugin>;
+declare function getSupportedPlatforms(): string[];
+
+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, getAgentRegistryConfig, getAuthConfig, getChannelConfig, getCircuitBreakerConfig, getClusterConfig, getConfig, getConfigDirectory, getConnectionPoolConfig, getDefaultAgent, getHTTPSConfig, getLogLevel, getMessageQueueConfig, getServerConfig, getSessionConfig, getSupportedPlatforms, isConfigLoaded, loadConfig, parsePartialConfig, validateConfig };