@eclaw/openclaw-channel 1.0.18 → 1.1.1

package/dist/client.d.ts

@@ -12,19 +12,13 @@ export declare class EClawClient {
     constructor(config: EClawAccountConfig);
     /** Register callback URL with E-Claw backend */
     registerCallback(callbackUrl: string, callbackToken: string): Promise<RegisterResponse>;
-    /** Bind an entity via channel API (bypasses 6-digit code).
-     *  If entityId is omitted, the backend auto-selects the first free slot.
-     */
-    bindEntity(entityId?: number, name?: string): Promise<BindResponse>;
-    /** Send bot message to user (updates own entity state on wallpaper) */
+    /** Bind an entity via channel API (bypasses 6-digit code) */
+    bindEntity(entityId: number, name?: string): Promise<BindResponse>;
+    /** Send bot message to user */
     sendMessage(message: string, state?: string, mediaType?: string, mediaUrl?: string): Promise<MessageResponse>;
-    /** Send bot-to-bot message to another entity (speak-to) */
-    speakTo(toEntityId: number, text: string, expectsReply?: boolean): Promise<void>;
-    /** Broadcast message to all other bound entities */
-    broadcastToAll(text: string, expectsReply?: boolean): Promise<void>;
     /** Unregister callback on shutdown */
     unregisterCallback(): Promise<void>;
     get currentDeviceId(): string | null;
     get currentBotSecret(): string | null;
-    get currentEntityId(): number | undefined;
+    get currentEntityId(): number;
 }

package/dist/client.js

@@ -11,7 +11,7 @@ export class EClawClient {
     constructor(config) {
         this.apiBase = config.apiBase;
         this.apiKey = config.apiKey;
-        this.entityId = config.entityId; // undefined until assigned by bindEntity
+        this.entityId = config.entityId;
     }
     /** Register callback URL with E-Claw backend */
     async registerCallback(callbackUrl, callbackToken) {
@@ -31,40 +31,27 @@ export class EClawClient {
         this.deviceId = data.deviceId;
         return data;
     }
-    /** Bind an entity via channel API (bypasses 6-digit code).
-     *  If entityId is omitted, the backend auto-selects the first free slot.
-     */
+    /** Bind an entity via channel API (bypasses 6-digit code) */
     async bindEntity(entityId, name) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const body = { channel_api_key: this.apiKey };
-        if (entityId !== undefined)
-            body.entityId = entityId;
-        if (name)
-            body.name = name;
         const res = await fetch(`${this.apiBase}/api/channel/bind`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
+            body: JSON.stringify({
+                channel_api_key: this.apiKey,
+                entityId,
+                name: name || undefined,
+            }),
         });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const data = await res.json();
         if (!data.success) {
-            // Build a detailed error message when all slots are full
-            if (res.status === 409 && data.entities) {
-                const list = data.entities
-                    .map((e) => `  slot ${e.entityId} (${e.character})${e.name ? ` "${e.name}"` : ''}`)
-                    .join('\n');
-                throw new Error(`${data.message}\nCurrent entities:\n${list}\n` +
-                    'Add entityId to your channel config to target a specific slot after unbinding it.');
-            }
             throw new Error(data.message || `Bind failed (HTTP ${res.status})`);
         }
         this.botSecret = data.botSecret;
         this.deviceId = data.deviceId;
-        this.entityId = data.entityId; // Use server-assigned slot
+        this.entityId = entityId;
         return data;
     }
-    /** Send bot message to user (updates own entity state on wallpaper) */
+    /** Send bot message to user */
     async sendMessage(message, state = 'IDLE', mediaType, mediaUrl) {
         if (!this.deviceId || !this.botSecret) {
             throw new Error('Not bound — call bindEntity() first');
@@ -85,41 +72,6 @@ export class EClawClient {
         });
         return await res.json();
     }
-    /** Send bot-to-bot message to another entity (speak-to) */
-    async speakTo(toEntityId, text, expectsReply = false) {
-        if (!this.deviceId || !this.botSecret) {
-            throw new Error('Not bound — call bindEntity() first');
-        }
-        await fetch(`${this.apiBase}/api/entity/speak-to`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                deviceId: this.deviceId,
-                fromEntityId: this.entityId,
-                toEntityId,
-                botSecret: this.botSecret,
-                text,
-                expects_reply: expectsReply,
-            }),
-        });
-    }
-    /** Broadcast message to all other bound entities */
-    async broadcastToAll(text, expectsReply = false) {
-        if (!this.deviceId || !this.botSecret) {
-            throw new Error('Not bound — call bindEntity() first');
-        }
-        await fetch(`${this.apiBase}/api/entity/broadcast`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                deviceId: this.deviceId,
-                fromEntityId: this.entityId,
-                botSecret: this.botSecret,
-                text,
-                expects_reply: expectsReply,
-            }),
-        });
-    }
     /** Unregister callback on shutdown */
     async unregisterCallback() {
         await fetch(`${this.apiBase}/api/channel/register`, {

package/dist/config.js

@@ -28,7 +28,7 @@ export function resolveAccount(cfg, accountId) {
         apiKey: account?.apiKey ?? '',
         apiSecret: account?.apiSecret,
         apiBase: (account?.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
-        entityId: account?.entityId, // undefined = auto-assign
+        entityId: account?.entityId ?? 0,
         botName: account?.botName,
         webhookUrl: account?.webhookUrl,
     };

package/dist/gateway.d.ts

@@ -4,8 +4,10 @@
  * 1. Resolve credentials from ctx.account or disk
  * 2. Register a per-session handler in the webhook-registry (served by the
  *    main OpenClaw gateway HTTP server at /eclaw-webhook — no separate port)
- * 3. Register callback URL with E-Claw backend
+ * 3. Register callback URL with E-Claw backend (with exponential-backoff retry)
  * 4. Auto-bind entity if not already bound
- * 5. Keep the promise alive until abort signal fires
+ * 5. Periodically re-register to keep callback URL live (health check)
+ * 6. On health-check failure, reconnect with exponential backoff
+ * 7. Keep the promise alive until abort signal fires
  */
 export declare function startAccount(ctx: any): Promise<void>;

package/dist/gateway.js

@@ -7,6 +7,26 @@ import { EClawClient } from './client.js';
 import { setClient } from './outbound.js';
 import { createWebhookHandler } from './webhook-handler.js';
 import { registerWebhookToken, unregisterWebhookToken } from './webhook-registry.js';
+// ── Reconnect / health-check constants ───────────────────────────────────────
+const HEALTH_CHECK_INTERVAL_MS = 60_000; // re-register every 60 s to stay live
+const BACKOFF_INITIAL_MS = 5_000; // first retry after 5 s
+const BACKOFF_MAX_MS = 300_000; // cap at 5 min
+const BACKOFF_MULTIPLIER = 2;
+/** Sleep ms, but resolve early if abortSignal fires. */
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true });
+    });
+}
+/** Add ±20 % random jitter to reduce thundering-herd on reconnect. */
+function jitter(ms) {
+    return Math.floor(ms * (0.8 + Math.random() * 0.4));
+}
 /**
  * Resolve account from ctx.
  *
@@ -22,7 +42,7 @@ function resolveAccountFromCtx(ctx) {
             apiKey: ctx.account.apiKey,
             apiSecret: ctx.account.apiSecret,
             apiBase: (ctx.account.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
-            entityId: ctx.account.entityId, // undefined = auto-select
+            entityId: ctx.account.entityId ?? 0,
             botName: ctx.account.botName,
             webhookUrl: ctx.account.webhookUrl,
         };
@@ -43,9 +63,11 @@ function resolveAccountFromCtx(ctx) {
  * 1. Resolve credentials from ctx.account or disk
  * 2. Register a per-session handler in the webhook-registry (served by the
  *    main OpenClaw gateway HTTP server at /eclaw-webhook — no separate port)
- * 3. Register callback URL with E-Claw backend
+ * 3. Register callback URL with E-Claw backend (with exponential-backoff retry)
  * 4. Auto-bind entity if not already bound
- * 5. Keep the promise alive until abort signal fires
+ * 5. Periodically re-register to keep callback URL live (health check)
+ * 6. On health-check failure, reconnect with exponential backoff
+ * 7. Keep the promise alive until abort signal fires
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function startAccount(ctx) {
@@ -76,42 +98,103 @@ export async function startAccount(ctx) {
     const handler = createWebhookHandler(callbackToken, accountId, ctx.cfg);
     registerWebhookToken(callbackToken, accountId, handler);
     console.log(`[E-Claw] Webhook registered at: ${callbackUrl}`);
-    try {
-        // Register callback with E-Claw backend
-        const regData = await client.registerCallback(callbackUrl, callbackToken);
-        console.log(`[E-Claw] Registered with E-Claw. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
-        // Bind entity via channel API.
-        // /api/channel/bind is idempotent for the same channel account:
-        //   - Not bound → binds fresh, returns new botSecret
-        //   - Already bound via this channel account → returns existing botSecret (reconnect)
-        //   - Bound via different method → throws error (user must unbind first)
-        // entityId is omitted here so the server auto-selects the best slot
-        const bindData = await client.bindEntity(account.entityId, account.botName);
-        const assignedEntityId = bindData.entityId;
-        const entityInfo = regData.entities.find(e => e.entityId === assignedEntityId);
-        const wasAlreadyBound = entityInfo?.isBound ?? false;
-        console.log(wasAlreadyBound
-            ? `[E-Claw] Entity ${assignedEntityId} reconnected (existing channel binding), publicCode: ${bindData.publicCode}`
-            : `[E-Claw] Entity ${assignedEntityId} bound, publicCode: ${bindData.publicCode}`);
-        console.log(`[E-Claw] Account ${accountId} ready!`);
+    const signal = ctx.abortSignal;
+    // ── Core setup: register callback + bind entity ───────────────────────────
+    /**
+     * One full register+bind cycle. Returns true on success, false on failure.
+     */
+    async function attemptSetup() {
+        try {
+            const regData = await client.registerCallback(callbackUrl, callbackToken);
+            console.log(`[E-Claw][${accountId}] Registered. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
+            const entity = regData.entities.find(e => e.entityId === account.entityId);
+            if (!entity?.isBound) {
+                console.log(`[E-Claw][${accountId}] Entity ${account.entityId} not bound, binding...`);
+                const bindData = await client.bindEntity(account.entityId, account.botName);
+                console.log(`[E-Claw][${accountId}] Bound entity ${account.entityId}, publicCode: ${bindData.publicCode}`);
+            }
+            else {
+                console.log(`[E-Claw][${accountId}] Entity ${account.entityId} already bound`);
+                const bindData = await client.bindEntity(account.entityId, account.botName);
+                console.log(`[E-Claw][${accountId}] Retrieved credentials for entity ${account.entityId}`);
+                void bindData;
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`[E-Claw][${accountId}] Setup attempt failed:`, err);
+            return false;
+        }
+    }
+    // ── Initial connect with exponential backoff ──────────────────────────────
+    let backoffMs = BACKOFF_INITIAL_MS;
+    let attempt = 0;
+    while (!signal?.aborted) {
+        attempt++;
+        const ok = await attemptSetup();
+        if (ok) {
+            console.log(`[E-Claw][${accountId}] Account ready! (attempt #${attempt})`);
+            break;
+        }
+        const delay = jitter(Math.min(backoffMs, BACKOFF_MAX_MS));
+        console.warn(`[E-Claw][${accountId}] Retrying in ${Math.round(delay / 1000)}s (attempt #${attempt})...`);
+        await sleep(delay, signal);
+        backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
     }
-    catch (err) {
-        console.error(`[E-Claw] Setup failed for account ${accountId}:`, err);
+    if (signal?.aborted) {
         unregisterWebhookToken(callbackToken);
         return;
     }
+    // ── Periodic health check + auto-reconnect ────────────────────────────────
+    // Re-register every 60 s. If it fails, enter a reconnect backoff loop.
+    // Guard flag prevents concurrent reconnect loops from stacking.
+    let isReconnecting = false;
+    async function runHealthCheck() {
+        if (isReconnecting)
+            return;
+        try {
+            await client.registerCallback(callbackUrl, callbackToken);
+            // Silent success — no log spam when healthy
+        }
+        catch (err) {
+            if (isReconnecting)
+                return;
+            isReconnecting = true;
+            console.warn(`[E-Claw][${accountId}] Health check failed — starting reconnect loop:`, err);
+            let reconnBackoff = BACKOFF_INITIAL_MS;
+            let reconnAttempt = 0;
+            while (!signal?.aborted) {
+                reconnAttempt++;
+                const delay = jitter(Math.min(reconnBackoff, BACKOFF_MAX_MS));
+                console.warn(`[E-Claw][${accountId}] Reconnect attempt #${reconnAttempt} in ${Math.round(delay / 1000)}s...`);
+                await sleep(delay, signal);
+                if (signal?.aborted)
+                    break;
+                const recovered = await attemptSetup();
+                if (recovered) {
+                    console.log(`[E-Claw][${accountId}] Reconnected successfully after ${reconnAttempt} attempt(s)!`);
+                    break;
+                }
+                reconnBackoff = Math.min(reconnBackoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
+            }
+            isReconnecting = false;
+        }
+    }
+    const healthTimer = setInterval(() => { void runHealthCheck(); }, HEALTH_CHECK_INTERVAL_MS);
     // Keep the promise alive until abort signal fires
     return new Promise((resolve) => {
-        const signal = ctx.abortSignal;
         if (signal) {
             signal.addEventListener('abort', () => {
-                console.log(`[E-Claw] Shutting down account ${accountId}`);
+                console.log(`[E-Claw][${accountId}] Shutting down account`);
+                clearInterval(healthTimer);
                 client.unregisterCallback().catch(() => { });
                 unregisterWebhookToken(callbackToken);
                 resolve();
             });
         }
         else {
+            // No abort signal — resolve immediately (should not happen in normal use)
+            clearInterval(healthTimer);
             resolve();
         }
     });

package/dist/outbound.d.ts

@@ -1,6 +1,4 @@
 import { EClawClient } from './client.js';
-export declare function setActiveEvent(accountId: string, event: string): void;
-export declare function clearActiveEvent(accountId: string): void;
 export declare function setClient(accountId: string, client: EClawClient): void;
 export declare function getClient(accountId: string): EClawClient | undefined;
 /** OpenClaw outbound: send text message to E-Claw user */

package/dist/outbound.js

@@ -1,13 +1,5 @@
 /** Client instances keyed by accountId */
 const clients = new Map();
-/** Track current inbound event type per account to suppress duplicate sendMessage calls */
-const activeEvent = new Map();
-export function setActiveEvent(accountId, event) {
-    activeEvent.set(accountId, event);
-}
-export function clearActiveEvent(accountId) {
-    activeEvent.delete(accountId);
-}
 export function setClient(accountId, client) {
     clients.set(accountId, client);
 }
@@ -18,11 +10,6 @@ export function getClient(accountId) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function sendText(ctx) {
     const accountId = ctx.accountId ?? 'default';
-    // Suppress duplicate delivery for bot-to-bot events — webhook-handler's deliver handles these
-    const event = activeEvent.get(accountId) ?? 'message';
-    if (event === 'entity_message' || event === 'broadcast') {
-        return { channel: 'eclaw', messageId: '', chatId: '' };
-    }
     const client = clients.get(accountId);
     if (!client) {
         return { channel: 'eclaw', messageId: '', chatId: '' };
@@ -45,11 +32,6 @@ export async function sendText(ctx) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function sendMedia(ctx) {
     const accountId = ctx.accountId ?? 'default';
-    // Suppress duplicate delivery for bot-to-bot events — webhook-handler's deliver handles these
-    const event = activeEvent.get(accountId) ?? 'message';
-    if (event === 'entity_message' || event === 'broadcast') {
-        return { channel: 'eclaw', messageId: '', chatId: '' };
-    }
     const client = clients.get(accountId);
     if (!client) {
         return { channel: 'eclaw', messageId: '', chatId: '' };

package/dist/types.d.ts

@@ -4,18 +4,10 @@ export interface EClawAccountConfig {
     apiKey: string;
     apiSecret?: string;
     apiBase: string;
-    entityId?: number;
+    entityId: number;
     botName?: string;
     webhookUrl?: string;
 }
-/** Context block injected by E-Claw server for Channel Bot parity with Traditional Bot */
-export interface EClawContext {
-    b2bRemaining?: number;
-    b2bMax?: number;
-    expectsReply?: boolean;
-    missionHints?: string;
-    silentToken?: string;
-}
 /** Inbound message from E-Claw callback webhook */
 export interface EClawInboundMessage {
     event: 'message' | 'entity_message' | 'broadcast' | 'cross_device_message';
@@ -33,7 +25,6 @@ export interface EClawInboundMessage {
     fromEntityId?: number;
     fromCharacter?: string;
     fromPublicCode?: string;
-    eclaw_context?: EClawContext;
 }
 /** Entity info returned by channel register */
 export interface EClawEntityInfo {
@@ -59,13 +50,6 @@ export interface BindResponse {
     publicCode: string;
     bindingType: string;
 }
-/** Error response when all entity slots are full */
-export interface SlotsFullError {
-    success: false;
-    message: string;
-    entities: EClawEntityInfo[];
-    hint: string;
-}
 /** Response from POST /api/channel/message */
 export interface MessageResponse {
     success: boolean;

package/dist/webhook-handler.d.ts

@@ -1,18 +1,10 @@
 /**
  * Create an HTTP request handler for inbound messages from E-Claw.
  *
- * Handles three event types:
- *   - 'message'        → Normal human message; reply via sendMessage()
- *   - 'entity_message' → Bot-to-bot speak-to; reply via sendMessage() + speakTo(fromEntityId)
- *   - 'broadcast'      → Broadcast from another entity; reply via sendMessage() + speakTo(fromEntityId)
+ * When a user sends a message on E-Claw, the backend POSTs structured JSON
+ * to this webhook. We normalize it into OpenClaw's native PascalCase context
+ * format and dispatch to the agent via dispatchReplyWithBufferedBlockDispatcher.
  *
- * The `deliver` callback routes AI response to the correct E-Claw endpoint
- * based on the inbound event type.
- *
- * Channel Bot Context Parity v1.0.17:
- *   - Bot-to-bot / broadcast now calls sendMessage() to update own wallpaper AND speakTo() to reply
- *   - Quota awareness via eclaw_context.b2bRemaining / b2bMax
- *   - Mission context via eclaw_context.missionHints
- *   - Silent suppression via silentToken (default "[SILENT]")
+ * The `deliver` callback sends the AI reply back to E-Claw via the API client.
  */
 export declare function createWebhookHandler(expectedToken: string, accountId: string, cfg: any): (req: any, res: any) => Promise<void>;

package/dist/webhook-handler.js

@@ -1,21 +1,13 @@
 import { getPluginRuntime } from './runtime.js';
-import { getClient, setActiveEvent, clearActiveEvent } from './outbound.js';
+import { getClient } from './outbound.js';
 /**
  * Create an HTTP request handler for inbound messages from E-Claw.
  *
- * Handles three event types:
- *   - 'message'        → Normal human message; reply via sendMessage()
- *   - 'entity_message' → Bot-to-bot speak-to; reply via sendMessage() + speakTo(fromEntityId)
- *   - 'broadcast'      → Broadcast from another entity; reply via sendMessage() + speakTo(fromEntityId)
+ * When a user sends a message on E-Claw, the backend POSTs structured JSON
+ * to this webhook. We normalize it into OpenClaw's native PascalCase context
+ * format and dispatch to the agent via dispatchReplyWithBufferedBlockDispatcher.
  *
- * The `deliver` callback routes AI response to the correct E-Claw endpoint
- * based on the inbound event type.
- *
- * Channel Bot Context Parity v1.0.17:
- *   - Bot-to-bot / broadcast now calls sendMessage() to update own wallpaper AND speakTo() to reply
- *   - Quota awareness via eclaw_context.b2bRemaining / b2bMax
- *   - Mission context via eclaw_context.missionHints
- *   - Silent suppression via silentToken (default "[SILENT]")
+ * The `deliver` callback sends the AI reply back to E-Claw via the API client.
  */
 export function createWebhookHandler(expectedToken, accountId, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,37 +31,14 @@ cfg // full openclaw config (ctx.cfg from startAccount)
             const rt = getPluginRuntime();
             const client = getClient(accountId);
             const conversationId = msg.conversationId || `${msg.deviceId}:${msg.entityId}`;
-            // Capture event context for deliver routing
-            const event = msg.event || 'message';
-            const fromEntityId = msg.fromEntityId;
-            const fromCharacter = msg.fromCharacter;
-            // Read server-injected context block (Channel Bot parity)
-            const eclawCtx = msg.eclaw_context;
-            const silentToken = eclawCtx?.silentToken ?? '[SILENT]';
             // Map E-Claw media type to OpenClaw media type
             const ocMediaType = msg.mediaType === 'photo' ? 'image'
                 : msg.mediaType === 'voice' ? 'audio'
                     : msg.mediaType === 'video' ? 'video'
                         : msg.mediaType ? 'file'
                             : undefined;
-            // Build body — enrich with event context for bot-to-bot and broadcast
-            let body = msg.text || '';
-            if ((event === 'entity_message' || event === 'broadcast') && fromEntityId !== undefined) {
-                const senderLabel = fromCharacter
-                    ? `Entity ${fromEntityId} (${fromCharacter})`
-                    : `Entity ${fromEntityId}`;
-                const eventPrefix = event === 'broadcast'
-                    ? `[Broadcast from ${senderLabel}]`
-                    : `[Bot-to-Bot message from ${senderLabel}]`;
-                const quotaLine = eclawCtx?.b2bRemaining !== undefined
-                    ? `[Quota: ${eclawCtx.b2bRemaining}/${eclawCtx.b2bMax ?? 8} remaining — output "${silentToken}" if no new info worth replying to]`
-                    : '';
-                const missionBlock = eclawCtx?.missionHints ?? '';
-                body = [eventPrefix, quotaLine, missionBlock, msg.text || '']
-                    .filter(Boolean)
-                    .join('\n');
-            }
             // Build context in OpenClaw's native PascalCase format
+            // (same convention as Telegram/LINE/WhatsApp channels)
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const inboundCtx = {
                 Surface: 'eclaw',
@@ -80,9 +49,9 @@ cfg // full openclaw config (ctx.cfg from startAccount)
                 To: conversationId,
                 OriginatingTo: msg.from,
                 SessionKey: conversationId,
-                Body: body,
-                RawBody: body,
-                CommandBody: body,
+                Body: msg.text || '',
+                RawBody: msg.text || '',
+                CommandBody: msg.text || '',
                 ChatType: 'direct',
                 ...(ocMediaType && msg.mediaUrl ? {
                     MediaType: ocMediaType,
@@ -90,50 +59,32 @@ cfg // full openclaw config (ctx.cfg from startAccount)
                 } : {}),
             };
             const ctxPayload = rt.channel.reply.finalizeInboundContext(inboundCtx);
-            // Track event type so outbound.sendText() can suppress duplicate delivery
-            setActiveEvent(accountId, event);
-            try {
-                await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-                    ctx: ctxPayload,
-                    cfg,
-                    dispatcherOptions: {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        deliver: async (payload) => {
-                            if (!client)
-                                return;
-                            const text = typeof payload.text === 'string' ? payload.text.trim() : '';
-                            // [SILENT] token or empty → skip all API calls
-                            if (!text || text === silentToken)
-                                return;
-                            if ((event === 'entity_message' || event === 'broadcast') && fromEntityId !== undefined) {
-                                // Bot-to-bot / broadcast: update own wallpaper AND reply to sender
-                                await client.sendMessage(text, 'IDLE');
-                                await client.speakTo(fromEntityId, text, false);
-                            }
-                            else {
-                                // Normal human message: reply via channel message
-                                if (text) {
-                                    await client.sendMessage(text, 'IDLE');
-                                }
-                                else if (payload.mediaUrl) {
-                                    const rawType = typeof payload.mediaType === 'string' ? payload.mediaType : '';
-                                    const mediaType = rawType === 'image' ? 'photo'
-                                        : rawType === 'audio' ? 'voice'
-                                            : rawType === 'video' ? 'video'
-                                                : 'file';
-                                    await client.sendMessage('', 'IDLE', mediaType, payload.mediaUrl);
-                                }
-                            }
-                        },
-                        onError: (err) => {
-                            console.error('[E-Claw] Reply delivery error:', err);
-                        },
+            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                ctx: ctxPayload,
+                cfg,
+                dispatcherOptions: {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    deliver: async (payload) => {
+                        if (!client)
+                            return;
+                        const text = typeof payload.text === 'string' ? payload.text.trim() : '';
+                        if (text) {
+                            await client.sendMessage(text, 'IDLE');
+                        }
+                        else if (payload.mediaUrl) {
+                            const rawType = typeof payload.mediaType === 'string' ? payload.mediaType : '';
+                            const mediaType = rawType === 'image' ? 'photo'
+                                : rawType === 'audio' ? 'voice'
+                                    : rawType === 'video' ? 'video'
+                                        : 'file';
+                            await client.sendMessage('', 'IDLE', mediaType, payload.mediaUrl);
+                        }
+                    },
+                    onError: (err) => {
+                        console.error('[E-Claw] Reply delivery error:', err);
                     },
-                });
-            }
-            finally {
-                clearActiveEvent(accountId);
-            }
+                },
+            });
         }
         catch (err) {
             console.error('[E-Claw] Webhook dispatch error:', err);

package/openclaw.plugin.json

@@ -16,7 +16,7 @@
             "apiKey": { "type": "string", "description": "Channel API Key (eck_...)" },
             "apiSecret": { "type": "string", "description": "Channel API Secret (ecs_...)" },
             "apiBase": { "type": "string", "default": "https://eclawbot.com" },
-            "entityId": { "type": "number", "minimum": 0, "maximum": 7, "description": "Optional: entity slot to use (0-7). If omitted, auto-assigned to first free slot." },
+            "entityId": { "type": "number", "default": 0, "minimum": 0, "maximum": 7 },
             "botName": { "type": "string", "maxLength": 20 }
           },
           "required": ["apiKey", "apiSecret"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclaw/openclaw-channel",
-  "version": "1.0.18",
+  "version": "1.1.1",
   "description": "E-Claw channel plugin for OpenClaw — AI chat platform for live wallpaper entities",
   "type": "module",
   "main": "./dist/index.js",