@hypercli.com/sdk 2026.6.26 → 2026.8.11

package/dist/openclaw/gateway.d.ts

@@ -6,6 +6,23 @@
  *
  * Protocol: OpenClaw Gateway v3-v4
  */
+import type { OpenClawSlackHttpConfiguration, OpenClawSlackRelayConfiguration, OpenClawSlackSocketConfiguration } from "./slack.js";
+import type { OpenClawTelegramConfigPatch, OpenClawWhatsAppConfigPatch } from "./channels.js";
+export declare const OPENCLAW_INTERNAL_MAIN_SESSION_KEY = "main";
+export declare const OPENCLAW_SDK_SESSION_PREFIX = "hcli:";
+export declare const OPENCLAW_DASHBOARD_SESSION_PREFIX = "dashboard:";
+export declare function createOpenClawSessionKey(existingSessionKeys?: Array<string | null | undefined>, prefix?: string): string;
+export declare function createOpenClawSdkSessionKey(existingSessionKeys?: Array<string | null | undefined>): string;
+export declare function isOpenClawInternalMainSessionKey(sessionKey: string | null | undefined): boolean;
+export declare function isOpenClawSdkSessionKey(sessionKey: string | null | undefined): boolean;
+export type GatewayProtocolErrorCode = "INVALID_JSON" | "INVALID_FRAME" | "INVALID_EVENT" | "INVALID_RESPONSE" | "AMBIGUOUS_CHAT_STREAM_EVENT" | "DUPLICATE_SEQUENCE" | "OUT_OF_ORDER_SEQUENCE";
+export interface GatewayProtocolErrorInfo {
+    code: GatewayProtocolErrorCode;
+    message: string;
+    frameType?: string;
+    event?: string;
+    requestId?: string;
+}
 export interface GatewayOptions {
     /** WebSocket URL for the agent gateway (typically wss://{agent-host}) */
     url: string;
@@ -13,6 +30,16 @@ export interface GatewayOptions {
     token?: string;
     /** Shared gateway auth token used in the WebSocket connect handshake. */
     gatewayToken?: string;
+    /** Bootstrap auth token used by newer OpenClaw gateway handshakes. */
+    bootstrapToken?: string;
+    /** Explicit device auth token used by newer OpenClaw gateway handshakes. */
+    deviceToken?: string;
+    /** Password auth field used by compatible gateway deployments. */
+    password?: string;
+    /** Approval-runtime auth token used by compatible gateway deployments. */
+    approvalRuntimeToken?: string;
+    /** Agent-runtime identity token used by compatible gateway deployments. */
+    agentRuntimeIdentityToken?: string;
     /** Deployment id used for trusted pairing approval via agent exec. */
     deploymentId?: string;
     /** HyperCLI API bearer token used for trusted pairing approval via agent exec. */
@@ -31,13 +58,29 @@ export interface GatewayOptions {
     clientVersion?: string;
     /** Client platform sent to the gateway */
     platform?: string;
+    /** Optional device family sent to the gateway */
+    deviceFamily?: string;
     /** Optional client instance ID */
     instanceId?: string;
     /** Optional gateway capability list */
     caps?: string[];
+    /** Connection role in the connect handshake (default: "operator"). Use "node" to serve node commands. */
+    role?: string;
+    /** Auth scopes requested in the connect handshake (default: operator scopes for the operator role, else empty). */
+    scopes?: string[];
+    /** Declared node command surface advertised in the connect handshake (node role). */
+    commands?: string[];
+    /** Optional policy permissions advertised in the connect handshake. */
+    permissions?: Record<string, boolean>;
+    /** Optional PATH-like environment hint advertised in the connect handshake. */
+    pathEnv?: string;
+    /** Minimum gateway protocol version this client can speak. Defaults to v3 for live-agent compatibility. */
+    minProtocol?: number;
+    /** Maximum gateway protocol version this client can speak. */
+    maxProtocol?: number;
     /** Origin header (default: omitted for non-browser SDK clients) */
     origin?: string;
-    /** Default RPC timeout in ms (default: 15000) */
+    /** Default RPC timeout in ms (default: 30000) */
     timeout?: number;
     /** Called after a successful hello-ok response */
     onHello?: (hello: Record<string, any>) => void;
@@ -48,6 +91,8 @@ export interface GatewayOptions {
         expected: number;
         received: number;
     }) => void;
+    /** Called when an inbound frame fails validation. Raw payloads are never included. */
+    onProtocolError?: (info: GatewayProtocolErrorInfo) => void;
     /** Called when a browser device pairing request is pending or updated. */
     onPairing?: (pairing: GatewayPairingState | null) => void;
 }
@@ -60,8 +105,48 @@ export interface GatewayEvent {
 export interface ChatEvent {
     type: "content" | "thinking" | "tool_call" | "tool_result" | "done" | "error";
     text?: string;
+    /** For content events, `true` replaces the turn's display text; `false` or omission appends. */
+    replace?: boolean;
+    /** Protocol event identity, when supplied by the gateway payload. */
+    eventId?: string;
+    /** Protocol message identity, when supplied by the gateway payload. */
+    messageId?: string;
+    /** Protocol turn identity, when supplied by the gateway payload. */
+    turnId?: string;
+    /** Protocol run identity, when supplied by the gateway payload. */
+    runId?: string;
+    /** Canonical session key reported by the gateway. */
+    sessionKey?: string;
+    /** Protocol payload revision, when supplied by the gateway. */
+    revision?: number | string;
     data?: Record<string, any>;
 }
+export declare class GatewayChatStreamInterruptedError extends Error {
+    static readonly code: "GATEWAY_CHAT_STREAM_INTERRUPTED";
+    readonly code: "GATEWAY_CHAT_STREAM_INTERRUPTED";
+    readonly reason: "sequence-gap" | "ambiguous-event";
+    readonly expectedSequence?: number;
+    readonly receivedSequence?: number;
+    constructor(reason: "sequence-gap" | "ambiguous-event", sequence?: {
+        expected: number;
+        received: number;
+    });
+}
+export interface GatewayAbortSignal {
+    readonly aborted: boolean;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+}
+export interface GatewayEphemeralChatOptions {
+    signal?: GatewayAbortSignal;
+    timeoutMs?: number;
+    maxResponseChars?: number;
+    /** Request the selected model's fastest supported service tier for this hidden session. */
+    fastMode?: boolean;
+    onEvent?: (event: ChatEvent) => void | Promise<void>;
+}
 export interface GatewayChatToolCall {
     id?: string;
     name: string;
@@ -75,6 +160,45 @@ export interface GatewayChatMessageSummary {
     toolCalls: GatewayChatToolCall[];
     mediaUrls: string[];
     timestamp?: number;
+    /** Protocol message identity, when supplied by the raw history message. */
+    messageId?: string;
+    /** Protocol turn identity, when supplied by the raw history message. */
+    turnId?: string;
+    /** Protocol run identity, when supplied by the raw history message. */
+    runId?: string;
+    /** Canonical session key reported by the raw history message. */
+    sessionKey?: string;
+    /** Protocol message revision, when supplied by the raw history message. */
+    revision?: number | string;
+}
+export interface GatewayChatMessageGetOptions {
+    agentId?: string;
+    maxChars?: number;
+}
+export interface GatewayChatMessageGetResult {
+    ok: boolean;
+    message?: unknown;
+    unavailableReason?: "not_found" | "oversized" | "not_visible";
+}
+export interface GatewayChatHistorySessionInfo extends Record<string, unknown> {
+    key?: string;
+    sessionId?: string;
+    status?: string;
+    hasActiveRun?: boolean;
+    activeRunIds?: string[];
+}
+export interface GatewayChatInFlightRun extends Record<string, unknown> {
+    runId?: string;
+    text?: string;
+    events?: unknown[];
+    plan?: unknown;
+}
+export interface GatewayChatHistoryResult extends Record<string, unknown> {
+    messages: any[];
+    sessionKey?: string;
+    sessionId?: string;
+    sessionInfo?: GatewayChatHistorySessionInfo | null;
+    inFlightRun?: GatewayChatInFlightRun | null;
 }
 export interface GatewaySessionPatch {
     key: string;
@@ -82,6 +206,29 @@ export interface GatewaySessionPatch {
     thinkingLevel?: string;
     [key: string]: unknown;
 }
+export interface GatewaySessionCreateParams {
+    key?: string;
+    agentId?: string;
+    label?: string;
+    model?: string;
+    parentSessionKey?: string;
+    fork?: boolean;
+    emitCommandHooks?: boolean;
+    task?: string;
+    message?: string;
+    worktree?: boolean;
+}
+export interface GatewaySessionCreateResult extends Record<string, unknown> {
+    ok: true;
+    key: string;
+    sessionId?: string;
+    entry?: Record<string, unknown>;
+    runStarted?: boolean;
+}
+export interface GatewaySessionsListResult extends Record<string, any> {
+    sessions: any[];
+    defaults?: Record<string, any>;
+}
 export interface GatewayChatAttachmentPayload {
     type: string;
     mimeType?: string;
@@ -96,6 +243,14 @@ export interface BrowserChatAttachment {
     fileName?: string;
 }
 export type ChatAttachment = GatewayChatAttachmentPayload | BrowserChatAttachment;
+export interface GatewayEphemeralChatSession {
+    readonly sessionKey: string;
+    readonly closed: boolean;
+    chatSend(message: string, attachments?: ChatAttachment[]): AsyncGenerator<ChatEvent>;
+    chatHistory(limit?: number): Promise<any[]>;
+    chatAbort(): Promise<void>;
+    close(): Promise<void>;
+}
 export interface GatewayCloseInfo {
     code: number;
     reason: string;
@@ -132,6 +287,13 @@ export interface OpenClawConfigSchemaResponse {
     version?: string;
     generatedAt?: string;
 }
+export interface OpenClawSlackRelayOptions {
+    url: string;
+    gatewayId: string;
+    authTokenEnv?: string;
+    accountId?: string;
+    botToken?: OpenClawSlackRelayConfiguration["botToken"];
+}
 export interface OpenClawConfigNodeDescriptor {
     schema: Record<string, any>;
     type?: string;
@@ -140,6 +302,25 @@ export interface OpenClawConfigNodeDescriptor {
     additionalPropertySchema: Record<string, any> | null;
     isDynamicMap: boolean;
 }
+export type OpenClawConfigReloadKind = "restart" | "hot" | "none";
+export interface OpenClawConfigSchemaLookupChild {
+    key: string;
+    path: string;
+    type?: string | string[];
+    required: boolean;
+    hasChildren: boolean;
+    reloadKind?: OpenClawConfigReloadKind;
+    hint?: OpenClawConfigUiHint;
+    hintPath?: string;
+}
+export interface OpenClawConfigSchemaLookupResult {
+    path: string;
+    schema: unknown;
+    reloadKind?: OpenClawConfigReloadKind;
+    hint?: OpenClawConfigUiHint;
+    hintPath?: string;
+    children: OpenClawConfigSchemaLookupChild[];
+}
 export interface GatewaySkillsStatusParams {
     agentId?: string;
 }
@@ -448,13 +629,386 @@ export interface GatewayIntegrationDisconnectResult {
     connectionId?: string;
     [key: string]: unknown;
 }
+export interface GatewayMessageActionParams {
+    channel: string;
+    action: string;
+    params: Record<string, unknown>;
+    accountId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    inboundTurnKind?: "user_request" | "room_event";
+    agentId?: string;
+    conversationReadOrigin?: "direct-operator";
+    idempotencyKey?: string;
+}
+export interface GatewaySendParams {
+    to: string;
+    message?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    buffer?: string;
+    filename?: string;
+    contentType?: string;
+    asVoice?: boolean;
+    gifPlayback?: boolean;
+    channel?: string;
+    accountId?: string;
+    agentId?: string;
+    replyToId?: string;
+    threadId?: string;
+    forceDocument?: boolean;
+    silent?: boolean;
+    parseMode?: "HTML";
+    sessionKey?: string;
+    idempotencyKey?: string;
+}
+export interface GatewaySendResult {
+    runId: string;
+    messageId: unknown;
+    channel: string;
+    chatId?: unknown;
+    channelId?: unknown;
+    toJid?: unknown;
+    conversationId?: unknown;
+    pollId?: unknown;
+}
+export type GatewayPluginState = "enabled" | "disabled" | "not-installed" | "error";
+export type GatewayPluginCatalogInstallAction = {
+    source: "clawhub";
+    packageName: string;
+} | {
+    source: "official";
+    pluginId: string;
+};
+export interface GatewayPluginCatalogEntry {
+    id: string;
+    name: string;
+    packageName?: string;
+    description?: string;
+    version?: string;
+    kind?: string[];
+    origin?: string;
+    installed: boolean;
+    enabled: boolean;
+    state: GatewayPluginState;
+    featured?: boolean;
+    order?: number;
+    hasIcon?: boolean;
+    install?: GatewayPluginCatalogInstallAction;
+    error?: string;
+    category?: string;
+    removable?: boolean;
+}
+export interface GatewayPluginsListResult {
+    plugins: GatewayPluginCatalogEntry[];
+    diagnostics: unknown[];
+    mutationAllowed: boolean;
+}
+export type GatewayPluginsInstallParams = {
+    source: "clawhub";
+    packageName: string;
+    version?: string;
+    acknowledgeClawHubRisk?: boolean;
+} | {
+    source: "official";
+    pluginId: string;
+};
+export interface GatewayPluginsInstallResult {
+    ok: true;
+    plugin: GatewayPluginCatalogEntry;
+    restartRequired: true;
+    warnings?: string[];
+}
+export interface GatewayPluginsSetEnabledParams {
+    pluginId: string;
+    enabled: boolean;
+}
+export interface GatewayPluginsSetEnabledResult {
+    ok: true;
+    plugin: GatewayPluginCatalogEntry;
+    restartRequired: boolean;
+    warnings?: string[];
+}
+export interface GatewayPluginsUninstallParams {
+    pluginId: string;
+}
+export interface GatewayPluginsUninstallResult {
+    ok: true;
+    pluginId: string;
+    restartRequired: true;
+    removed: string[];
+    warnings?: string[];
+}
+export interface GatewayPluginsRefreshResult {
+    ok: true;
+}
+export type GatewayToolProfileId = "minimal" | "coding" | "messaging" | "full";
+export type GatewayToolSource = "core" | "plugin" | "channel" | "mcp";
+export type GatewayToolRisk = "low" | "medium" | "high";
+export interface GatewayToolsCatalogParams {
+    agentId?: string;
+    includePlugins?: boolean;
+}
+export interface GatewayToolCatalogProfile {
+    id: GatewayToolProfileId;
+    label: string;
+}
+export interface GatewayToolCatalogEntry {
+    id: string;
+    label: string;
+    description: string;
+    source: "core" | "plugin";
+    pluginId?: string;
+    optional?: boolean;
+    risk?: GatewayToolRisk;
+    tags?: string[];
+    defaultProfiles: GatewayToolProfileId[];
+}
+export interface GatewayToolCatalogGroup {
+    id: string;
+    label: string;
+    source: "core" | "plugin";
+    pluginId?: string;
+    tools: GatewayToolCatalogEntry[];
+}
+export interface GatewayToolsCatalogResult {
+    agentId: string;
+    profiles: GatewayToolCatalogProfile[];
+    groups: GatewayToolCatalogGroup[];
+}
+export interface GatewayToolsEffectiveParams {
+    agentId?: string;
+    sessionKey: string;
+}
+export interface GatewayToolsEffectiveEntry {
+    id: string;
+    label: string;
+    description: string;
+    rawDescription: string;
+    source: GatewayToolSource;
+    pluginId?: string;
+    channelId?: string;
+    risk?: GatewayToolRisk;
+    tags?: string[];
+}
+export interface GatewayToolsEffectiveGroup {
+    id: GatewayToolSource;
+    label: string;
+    source: GatewayToolSource;
+    tools: GatewayToolsEffectiveEntry[];
+}
+export interface GatewayToolsEffectiveNotice {
+    id: string;
+    severity: "info" | "warning";
+    message: string;
+}
+export interface GatewayToolsEffectiveResult {
+    agentId: string;
+    profile: string;
+    groups: GatewayToolsEffectiveGroup[];
+    notices?: GatewayToolsEffectiveNotice[];
+}
+export interface GatewayToolsInvokeParams {
+    name: string;
+    args?: Record<string, unknown>;
+    sessionKey?: string;
+    agentId?: string;
+    confirm?: boolean;
+    idempotencyKey?: string;
+    conversationReadOrigin?: "direct-operator";
+}
+export interface GatewayToolsInvokeError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export interface GatewayToolsInvokeResult {
+    ok: boolean;
+    toolName: string;
+    output?: unknown;
+    requiresApproval?: boolean;
+    approvalId?: string;
+    source?: GatewayToolSource | (string & {});
+    error?: GatewayToolsInvokeError;
+}
+export type GatewayCommandSource = "native" | "skill" | "plugin";
+export type GatewayCommandScope = "text" | "native" | "both";
+export type GatewayCommandCategory = "session" | "options" | "status" | "management" | "media" | "tools" | "docks";
+export interface GatewayCommandArgChoice {
+    value: string;
+    label: string;
+}
+export interface GatewayCommandArg {
+    name: string;
+    description: string;
+    type: "string" | "number" | "boolean";
+    required?: boolean;
+    choices?: GatewayCommandArgChoice[];
+    dynamic?: boolean;
+}
+export interface GatewayCommandEntry {
+    name: string;
+    nativeName?: string;
+    textAliases?: string[];
+    description: string;
+    category?: GatewayCommandCategory;
+    source: GatewayCommandSource;
+    scope: GatewayCommandScope;
+    acceptsArgs: boolean;
+    args?: GatewayCommandArg[];
+}
+export interface GatewayCommandsListParams {
+    agentId?: string;
+    provider?: string;
+    scope?: GatewayCommandScope;
+    includeArgs?: boolean;
+}
+export interface GatewayCommandsListResult {
+    commands: GatewayCommandEntry[];
+}
+export interface ChannelsStatusParams {
+    probe?: boolean;
+    timeoutMs?: number;
+    channel?: string;
+}
+export interface ChannelsStartParams {
+    channel: string;
+    accountId?: string;
+}
+export interface ChannelsStartResult {
+    channel: string;
+    accountId: string;
+    started: boolean;
+}
+export interface ChannelsStopParams {
+    channel: string;
+    accountId?: string;
+}
+export interface ChannelsStopResult {
+    channel: string;
+    accountId: string;
+    stopped: boolean;
+}
+export type ChannelCredentialStatus = "available" | "configured_unavailable" | "missing";
+export interface ChannelAccountSnapshot {
+    accountId: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    linked?: boolean;
+    running?: boolean;
+    connected?: boolean;
+    restartPending?: boolean;
+    reconnectAttempts?: number;
+    lastConnectedAt?: number;
+    lastError?: string;
+    healthState?: string;
+    lastStartAt?: number;
+    lastStopAt?: number;
+    lastInboundAt?: number;
+    lastOutboundAt?: number;
+    lastMessageAt?: number | null;
+    lastEventAt?: number | null;
+    lastTransportActivityAt?: number;
+    statusState?: string;
+    terminalDisconnect?: boolean;
+    busy?: boolean;
+    activeRuns?: number;
+    lastRunActivityAt?: number;
+    lastProbeAt?: number;
+    mode?: string;
+    dmPolicy?: string;
+    allowFrom?: string[];
+    tokenSource?: string;
+    botTokenSource?: string;
+    appTokenSource?: string;
+    signingSecretSource?: string;
+    userTokenSource?: string;
+    tokenStatus?: ChannelCredentialStatus;
+    botTokenStatus?: ChannelCredentialStatus;
+    appTokenStatus?: ChannelCredentialStatus;
+    signingSecretStatus?: ChannelCredentialStatus;
+    userTokenStatus?: ChannelCredentialStatus;
+    baseUrl?: string;
+    allowUnmentionedGroups?: boolean;
+    cliPath?: string | null;
+    dbPath?: string | null;
+    port?: number | null;
+    probe?: unknown;
+    audit?: unknown;
+    application?: unknown;
+    [key: string]: unknown;
+}
+export interface ChannelUiMeta {
+    id: string;
+    label: string;
+    detailLabel: string;
+    systemImage?: string;
+    [key: string]: unknown;
+}
+export interface ChannelEventLoopHealth {
+    degraded: boolean;
+    reasons: Array<"event_loop_delay" | "event_loop_utilization" | "cpu">;
+    intervalMs: number;
+    delayP99Ms: number;
+    delayMaxMs: number;
+    utilization: number;
+    cpuCoreRatio: number;
+    [key: string]: unknown;
+}
+export interface ChannelsStatusResult {
+    ts: number;
+    channelOrder: string[];
+    channelLabels: Record<string, string>;
+    channelDetailLabels?: Record<string, string>;
+    channelSystemImages?: Record<string, string>;
+    channelMeta?: ChannelUiMeta[];
+    channels: Record<string, unknown>;
+    channelAccounts: Record<string, ChannelAccountSnapshot[]>;
+    channelDefaultAccountId: Record<string, string>;
+    eventLoop?: ChannelEventLoopHealth;
+    partial?: boolean;
+    warnings?: string[];
+    [key: string]: unknown;
+}
+export interface GatewayWebLoginStartOptions {
+    force?: boolean;
+    timeoutMs?: number;
+    verbose?: boolean;
+    accountId?: string;
+}
+export interface GatewayWebLoginStartResult {
+    qrDataUrl?: string;
+    message: string;
+    connected?: boolean;
+}
+export interface GatewayWebLoginWaitOptions {
+    timeoutMs?: number;
+    accountId?: string;
+    currentQrDataUrl?: string;
+}
+export interface GatewayWebLoginWaitResult {
+    connected: boolean;
+    message: string;
+    qrDataUrl?: string;
+}
 export type GatewayEventHandler = (event: GatewayEvent) => void;
 export type GatewayConnectionStateHandler = (state: GatewayConnectionState) => void;
+export type GatewayClientRequestOptions = {
+    expectFinal?: boolean;
+    timeoutMs?: number | null;
+    signal?: AbortSignal;
+    /** Called once for expectFinal requests after an accepted response, before the final result. */
+    onAccepted?: (payload: unknown) => void;
+};
 type GatewayErrorShape = {
     code: string;
     message: string;
     details?: unknown;
 };
+export declare function isOpenClawGatewayMethodUnsupported(error: unknown, method?: string): boolean;
+export declare const MIN_GATEWAY_VERSION = 3;
+export declare const MAX_GATEWAY_VERSION = 4;
 export declare function normalizeChatAttachments(attachments?: ChatAttachment[]): GatewayChatAttachmentPayload[] | undefined;
 export declare function extractGatewayChatThinking(message: unknown): string;
 export declare function extractGatewayChatMediaUrls(message: unknown): string[];
@@ -472,6 +1026,11 @@ export declare class GatewayClient {
     private url;
     private token?;
     private gatewayToken?;
+    private bootstrapToken?;
+    private deviceToken?;
+    private password?;
+    private approvalRuntimeToken?;
+    private agentRuntimeIdentityToken?;
     private deploymentId?;
     private apiKey?;
     private apiBase?;
@@ -481,13 +1040,31 @@ export declare class GatewayClient {
     private clientDisplayName?;
     private clientVersion;
     private clientPlatform;
+    private clientDeviceFamily?;
     private clientInstanceId?;
     private caps;
+    private role;
+    private scopes;
+    private commands?;
+    private permissions?;
+    private pathEnv?;
+    private minProtocol;
+    private maxProtocol;
     private origin?;
     private defaultTimeout;
     private ws;
     private pending;
     private eventHandlers;
+    private internalEventHandlers;
+    private internalStreamCloseHandlers;
+    private activeNormalChatStreams;
+    private activeStrictChatStreams;
+    private activeEphemeralSessionKeys;
+    private suppressedEphemeralRunIds;
+    private pendingEphemeralChatAcks;
+    private deferredEphemeralCorrelationEvents;
+    private deferredEphemeralEventsCanRepublish;
+    private suppressUncorrelatedChatEventsUntil;
     private connectionStateHandlers;
     private connected;
     private connectionState;
@@ -514,6 +1091,7 @@ export declare class GatewayClient {
     private readonly onHello?;
     private readonly onClose?;
     private readonly onGap?;
+    private readonly onProtocolError?;
     private readonly onPairing?;
     get version(): string | null;
     get protocol(): number | null;
@@ -527,6 +1105,18 @@ export declare class GatewayClient {
     private storageScope;
     /** Subscribe to server-sent events */
     onEvent(handler: GatewayEventHandler): () => void;
+    private currentEphemeralSessionKeys;
+    private shouldSuppressPublicEvent;
+    private suppressEphemeralRunId;
+    private beginEphemeralChatAcknowledgement;
+    private deferEphemeralCorrelationEvent;
+    private finishEphemeralChatAcknowledgement;
+    private publishPublicEvent;
+    private notifyInternalStreamClose;
+    private interruptNormalChatStreams;
+    private handleForwardSequenceGap;
+    private reportProtocolError;
+    private rejectMalformedPendingResponse;
     /** Connect and keep reconnecting until stopped */
     connect(): Promise<void>;
     start(): Promise<void>;
@@ -545,12 +1135,18 @@ export declare class GatewayClient {
     private handleMessage;
     private sendRawRequest;
     private rpc;
-    request<T = any>(method: string, params?: Record<string, any>, timeout?: number): Promise<T>;
+    request<T = any>(method: string, params?: Record<string, any>, options?: number | null | GatewayClientRequestOptions): Promise<T>;
     configGet(): Promise<Record<string, any>>;
     configSchema(): Promise<OpenClawConfigSchemaResponse>;
+    configSchemaLookup(path: string): Promise<OpenClawConfigSchemaLookupResult>;
     configPatch(patch: Record<string, any>): Promise<void>;
     configApply(config: Record<string, any>): Promise<void>;
     configSet(config: Record<string, any>): Promise<void>;
+    configureSlackSocket(config: OpenClawSlackSocketConfiguration, accountId?: string): Promise<void>;
+    configureSlackHttp(config: OpenClawSlackHttpConfiguration, accountId?: string): Promise<void>;
+    configureSlackRelay(options: OpenClawSlackRelayOptions | OpenClawSlackRelayConfiguration, accountId?: string): Promise<void>;
+    configureTelegram(config: OpenClawTelegramConfigPatch, accountId?: string): Promise<void>;
+    configureWhatsapp(config: OpenClawWhatsAppConfigPatch, accountId?: string): Promise<void>;
     modelsList(): Promise<any[]>;
     skillsStatus(params?: GatewaySkillsStatusParams): Promise<GatewaySkillsStatusReport>;
     skillsSearch(params?: GatewaySkillsSearchParams): Promise<GatewaySkillsSearchResult>;
@@ -564,26 +1160,72 @@ export declare class GatewayClient {
     integrationsStatus(params?: GatewayIntegrationStatusParams): Promise<GatewayIntegrationStatusResult>;
     integrationsDisconnect(params: GatewayIntegrationDisconnectParams): Promise<GatewayIntegrationDisconnectResult>;
     waitReady(timeoutMs?: number, options?: GatewayWaitReadyOptions): Promise<Record<string, any>>;
-    channelsStatus(probe?: boolean, timeoutMs?: number): Promise<Record<string, any>>;
+    channelsStatus(probe?: boolean, timeoutMs?: number, channel?: string): Promise<ChannelsStatusResult>;
+    channelsStart(channel: string, accountId?: string): Promise<ChannelsStartResult>;
+    channelsStop(channel: string, accountId?: string): Promise<ChannelsStopResult>;
     channelsLogout(channel: string, accountId?: string): Promise<Record<string, any>>;
-    webLoginStart(options?: {
-        force?: boolean;
-        timeoutMs?: number;
-        verbose?: boolean;
-        accountId?: string;
-    }): Promise<Record<string, any>>;
-    webLoginWait(options?: {
-        timeoutMs?: number;
-        accountId?: string;
-    }): Promise<Record<string, any>>;
+    messageAction<TResult = unknown>(params: GatewayMessageActionParams): Promise<TResult>;
+    send(params: GatewaySendParams): Promise<GatewaySendResult>;
+    readMediaBytes(pathOrUrl: string): Promise<Uint8Array>;
+    pluginsList(): Promise<GatewayPluginsListResult>;
+    pluginsInstall(params: GatewayPluginsInstallParams): Promise<GatewayPluginsInstallResult>;
+    pluginsSetEnabled(params: GatewayPluginsSetEnabledParams): Promise<GatewayPluginsSetEnabledResult>;
+    pluginsUninstall(params: GatewayPluginsUninstallParams): Promise<GatewayPluginsUninstallResult>;
+    pluginsRefresh(): Promise<GatewayPluginsRefreshResult>;
+    toolsCatalog(params?: GatewayToolsCatalogParams): Promise<GatewayToolsCatalogResult>;
+    toolsEffective(params: GatewayToolsEffectiveParams): Promise<GatewayToolsEffectiveResult>;
+    toolsInvoke(params: GatewayToolsInvokeParams): Promise<GatewayToolsInvokeResult>;
+    commandsList(params?: GatewayCommandsListParams): Promise<GatewayCommandsListResult>;
+    webLoginStart(options?: GatewayWebLoginStartOptions): Promise<GatewayWebLoginStartResult>;
+    webLoginWait(options?: GatewayWebLoginWaitOptions): Promise<GatewayWebLoginWaitResult>;
+    sessionsListResult(): Promise<GatewaySessionsListResult>;
     sessionsList(): Promise<any[]>;
     sessionsPreview(sessionKey: string, limit?: number): Promise<any[]>;
+    sessionsSubscribe(): Promise<boolean>;
+    sessionsCreate(params?: GatewaySessionCreateParams): Promise<GatewaySessionCreateResult>;
     sessionsPatch(patch: GatewaySessionPatch): Promise<Record<string, any>>;
+    chatHistoryResult(sessionKey?: string, limit?: number): Promise<GatewayChatHistoryResult>;
     chatHistory(sessionKey?: string, limit?: number): Promise<any[]>;
-    chatAbort(sessionKey?: string): Promise<void>;
+    chatMessageGet(sessionKey: string, messageId: string, options?: GatewayChatMessageGetOptions): Promise<GatewayChatMessageGetResult>;
+    chatAbort(sessionKey?: string, runId?: string): Promise<void>;
     sendChat(message: string, sessionKey?: string, agentId?: string, attachments?: ChatAttachment[]): Promise<any>;
-    sessionsReset(sessionKey: string, reason?: "new" | "reset"): Promise<void>;
-    chatSend(message: string, sessionKey: string, attachments?: ChatAttachment[]): AsyncGenerator<ChatEvent>;
+    sessionsReset(sessionKey: string, reason?: "new" | "reset"): Promise<string>;
+    createEphemeralChatSession(): Promise<GatewayEphemeralChatSession>;
+    /** Paired nodes known to the gateway. */
+    nodesList(): Promise<any[]>;
+    /** Detailed metadata for one paired node (caps + supported invoke commands). */
+    nodeDescribe(nodeId: string): Promise<any>;
+    /** Pending and paired node-pairing requests. */
+    nodePairList(): Promise<{
+        pending: any[];
+        paired: any[];
+    }>;
+    /**
+     * Approve a pending node pairing (and its declared command surface). This is
+     * the sibling of `device.pair.approve`; it requires `operator.pairing` and,
+     * for command-bearing nodes, `operator.write`/`operator.admin`.
+     */
+    nodePairApprove(requestId: string): Promise<any>;
+    /** Reject a pending node pairing request. */
+    nodePairReject(requestId: string): Promise<void>;
+    /** Remove an already-paired node from the gateway trust set. */
+    nodePairRemove(nodeId: string): Promise<void>;
+    /** Rename a paired node while preserving its stable node id. */
+    nodeRename(nodeId: string, displayName: string): Promise<void>;
+    /**
+     * Invoke a command on a paired node and return its result. The node must be
+     * connected, have declared `command`, and the command must be allowed by the
+     * gateway policy (declared + approved surface, and/or
+     * `gateway.nodes.allowCommands`).
+     */
+    nodeInvoke(nodeId: string, command: string, params?: Record<string, any>, timeoutMs?: number): Promise<any>;
+    chatSend(message: string, sessionKey: string, attachments?: ChatAttachment[], options?: {
+        strictCorrelation?: boolean;
+        ephemeralSession?: boolean;
+        captureHistoryBaseline?: boolean;
+        priorAssistantTexts?: string[];
+    }): AsyncGenerator<ChatEvent>;
+    runEphemeralChat(message: string, options?: GatewayEphemeralChatOptions): Promise<string>;
     filesList(agentId?: string): Promise<any[]>;
     fileGet(agentId: string, name: string): Promise<string>;
     fileSet(agentId: string, name: string, content: string): Promise<void>;
@@ -597,5 +1239,29 @@ export declare class GatewayClient {
     execDeny(execId: string): Promise<void>;
     status(): Promise<Record<string, any>>;
 }
+/** Handler for one node command. Receives decoded params, returns a JSON-serializable payload. */
+export type NodeCommandHandler = (params: any) => Promise<any> | any;
+export interface NodeServerOptions extends Omit<GatewayOptions, "role" | "scopes" | "commands" | "clientMode"> {
+    /** Stable node id advertised to operators (defaults to the client instance id). */
+    nodeId?: string;
+}
+/**
+ * Serve a node command surface over a gateway connection. Wraps a
+ * {@link GatewayClient} connected as `role: "node"`, subscribes to
+ * `node.invoke.request`, dispatches to the registered handlers, and replies with
+ * `node.invoke.result` (JSON-encoded payload on success, or an error).
+ */
+export declare class NodeServer {
+    readonly gateway: GatewayClient;
+    private readonly handlers;
+    private unsubscribe;
+    constructor(commands: Record<string, NodeCommandHandler>, options: NodeServerOptions);
+    /** Connect as a node and start answering invoke requests. Resolves once connected. */
+    start(): Promise<void>;
+    /** Stop answering requests and disconnect. */
+    stop(): void;
+    private handleInvoke;
+    private dispatch;
+}
 export {};
 //# sourceMappingURL=gateway.d.ts.map