@eclaw/openclaw-channel 1.0.18 → 1.1.0

package/dist/gateway.js

@@ -1,57 +1,51 @@
+import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { resolveAccount } from './config.js';
 import { EClawClient } from './client.js';
 import { setClient } from './outbound.js';
 import { createWebhookHandler } from './webhook-handler.js';
-import { registerWebhookToken, unregisterWebhookToken } from './webhook-registry.js';
-/**
- * Resolve account from ctx.
- *
- * OpenClaw may pass a pre-resolved account object in ctx.account,
- * or an empty config. Fall back to reading openclaw.json from disk.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function resolveAccountFromCtx(ctx) {
-    // Preferred: OpenClaw passes the resolved account in ctx.account
-    if (ctx.account?.apiKey) {
-        return {
-            enabled: ctx.account.enabled ?? true,
-            apiKey: ctx.account.apiKey,
-            apiSecret: ctx.account.apiSecret,
-            apiBase: (ctx.account.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
-            entityId: ctx.account.entityId, // undefined = auto-select
-            botName: ctx.account.botName,
-            webhookUrl: ctx.account.webhookUrl,
-        };
-    }
-    // Fallback: read config from disk (OpenClaw passes empty config object)
-    const configPath = process.env.OPENCLAW_CONFIG_PATH
-        || join(homedir(), '.openclaw', 'openclaw.json');
-    let fullConfig = {};
-    try {
-        fullConfig = JSON.parse(readFileSync(configPath, 'utf8'));
-    }
-    catch { /* ignore */ }
-    return resolveAccount(fullConfig, ctx.accountId ?? ctx.account?.accountId);
+// ── 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;
+/** Build callbackUrl fresh from env every time — never use a stale closure value. */
+function buildCallbackUrl(actualPort) {
+    const publicUrl = process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
+    const base = publicUrl || `http://localhost:${actualPort}`;
+    return `${base}/eclaw-webhook`;
+}
+/** 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));
 }
 /**
  * Gateway lifecycle: start an E-Claw account.
  *
- * 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
+ * 1. Initialize HTTP client with channel API credentials
+ * 2. Start a local HTTP server to receive webhook callbacks
+ * 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) {
-    const accountId = ctx.accountId ?? ctx.account?.accountId ?? 'default';
-    const account = resolveAccountFromCtx(ctx);
-    if (!account.enabled || !account.apiKey) {
+    const { accountId, config } = ctx;
+    const account = resolveAccount(config, accountId);
+    if (!account.enabled || !account.apiKey || !account.apiSecret) {
         console.log(`[E-Claw] Account ${accountId} disabled or missing credentials, skipping`);
         return;
     }
@@ -60,59 +54,141 @@ export async function startAccount(ctx) {
     setClient(accountId, client);
     // Generate per-session callback token
     const callbackToken = randomBytes(32).toString('hex');
-    // Webhook URL: account config > env var > warn
-    const publicUrl = account.webhookUrl?.replace(/\/$/, '')
-        || process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
+    // Determine webhook configuration
+    const webhookPort = parseInt(process.env.ECLAW_WEBHOOK_PORT || '0') || 0;
+    const publicUrl = process.env.ECLAW_WEBHOOK_URL;
     if (!publicUrl) {
-        console.warn('[E-Claw] Webhook URL not configured. ' +
-            'Run "openclaw configure" and enter your OpenClaw public URL, ' +
-            'or set ECLAW_WEBHOOK_URL env var. ' +
-            'Example: https://your-openclaw-domain.com');
+        console.warn('[E-Claw] ECLAW_WEBHOOK_URL not set. Set this to your public-facing URL ' +
+            'so E-Claw can send messages to this plugin. Example: https://my-openclaw.example.com');
     }
-    // The callback URL points to /eclaw-webhook on the main gateway HTTP server
-    const callbackUrl = `${publicUrl || 'http://localhost'}/eclaw-webhook`;
-    // Register handler in the per-token registry
-    // Pass ctx.cfg so the handler can dispatch to the correct OpenClaw agent
-    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!`);
-    }
-    catch (err) {
-        console.error(`[E-Claw] Setup failed for account ${accountId}:`, err);
-        unregisterWebhookToken(callbackToken);
-        return;
-    }
-    // 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}`);
-                client.unregisterCallback().catch(() => { });
-                unregisterWebhookToken(callbackToken);
-                resolve();
+    // Create webhook handler
+    const handler = createWebhookHandler(callbackToken, accountId);
+    // Parse JSON body for incoming requests
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const requestHandler = (req, res) => {
+        if (req.method === 'POST' && req.url?.startsWith('/eclaw-webhook')) {
+            let body = '';
+            req.on('data', (chunk) => { body += chunk.toString(); });
+            req.on('end', () => {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    req.body = JSON.parse(body);
+                }
+                catch {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    req.body = {};
+                }
+                handler(req, res);
             });
         }
         else {
-            resolve();
+            res.writeHead(404);
+            res.end('Not Found');
         }
+    };
+    const server = createServer(requestHandler);
+    return new Promise((resolve) => {
+        server.listen(webhookPort, async () => {
+            const addr = server.address();
+            const actualPort = typeof addr === 'object' && addr ? addr.port : webhookPort;
+            console.log(`[E-Claw] Webhook server listening on port ${actualPort}`);
+            const signal = ctx.abortSignal;
+            // ── Core setup: register callback + bind entity ─────────────────────
+            /**
+             * One full register+bind cycle. Returns true on success, false on failure.
+             * Reads ECLAW_WEBHOOK_URL fresh every call so a corrected env var takes
+             * effect automatically on the next reconnect.
+             */
+            async function attemptSetup() {
+                const callbackUrl = buildCallbackUrl(actualPort);
+                console.log(`[E-Claw][${accountId}] Registering callback: ${callbackUrl}`);
+                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`);
+                        // For already-bound entities, retrieve credentials via bind endpoint
+                        const bindData = await client.bindEntity(account.entityId, account.botName);
+                        console.log(`[E-Claw][${accountId}] Retrieved credentials for entity ${account.entityId}`);
+                        void bindData; // credentials stored in client
+                    }
+                    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);
+            }
+            if (signal?.aborted)
+                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; // already reconnecting, skip this tick
+                const callbackUrl = buildCallbackUrl(actualPort);
+                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);
+            // ── Cleanup on abort ────────────────────────────────────────────────
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    console.log(`[E-Claw][${accountId}] Shutting down account`);
+                    clearInterval(healthTimer);
+                    client.unregisterCallback().catch(() => { });
+                    server.close();
+                    resolve();
+                });
+            }
+        });
     });
 }

package/dist/index.d.ts

@@ -1,3 +1,24 @@
+/**
+ * E-Claw Channel Plugin for OpenClaw.
+ *
+ * Installation:
+ *   npm install @eclaw/openclaw-channel
+ *
+ * Configuration (config.yaml):
+ *   channels:
+ *     eclaw:
+ *       accounts:
+ *         default:
+ *           apiKey: "eck_..."
+ *           apiSecret: "ecs_..."
+ *           apiBase: "https://eclawbot.com"
+ *           entityId: 0
+ *           botName: "My Bot"
+ *
+ * Environment variables:
+ *   ECLAW_WEBHOOK_URL  - Public URL for receiving callbacks (required for production)
+ *   ECLAW_WEBHOOK_PORT - Port for webhook server (default: random)
+ */
 declare const plugin: {
     id: string;
     name: string;

package/dist/index.js

@@ -1,6 +1,5 @@
 import { setPluginRuntime } from './runtime.js';
 import { eclawChannel } from './channel.js';
-import { dispatchWebhook } from './webhook-registry.js';
 /**
  * E-Claw Channel Plugin for OpenClaw.
  *
@@ -13,52 +12,24 @@ import { dispatchWebhook } from './webhook-registry.js';
  *       accounts:
  *         default:
  *           apiKey: "eck_..."
+ *           apiSecret: "ecs_..."
  *           apiBase: "https://eclawbot.com"
  *           entityId: 0
  *           botName: "My Bot"
- *           webhookUrl: "https://your-openclaw-domain.com"
  *
- * The plugin registers /eclaw-webhook on the main OpenClaw gateway HTTP server,
- * so no separate port is needed. Set webhookUrl to your OpenClaw public URL
- * (e.g. https://eclaw2.zeabur.app) so E-Claw knows where to push messages.
+ * Environment variables:
+ *   ECLAW_WEBHOOK_URL  - Public URL for receiving callbacks (required for production)
+ *   ECLAW_WEBHOOK_PORT - Port for webhook server (default: random)
  */
-/** Parse JSON body from a raw incoming request */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function parseBody(req) {
-    return new Promise((resolve) => {
-        let body = '';
-        req.on('data', (chunk) => { body += chunk.toString(); });
-        req.on('end', () => {
-            try {
-                req.body = JSON.parse(body);
-            }
-            catch {
-                req.body = {};
-            }
-            resolve();
-        });
-    });
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const plugin = {
-    id: 'openclaw-channel',
+    id: 'eclaw',
     name: 'E-Claw',
-    description: 'E-Claw AI chat platform channel plugin',
+    description: 'E-Claw AI Agent collaboration channel plugin',
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     register(api) {
         console.log('[E-Claw] Plugin loaded');
         setPluginRuntime(api.runtime);
-        // Register /eclaw-webhook on the main OpenClaw gateway HTTP server.
-        // Token-based routing is handled in dispatchWebhook() — each account
-        // registers its own handler keyed by a random per-session Bearer token.
-        api.registerHttpRoute({
-            path: '/eclaw-webhook',
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            handler: async (req, res) => {
-                await parseBody(req);
-                await dispatchWebhook(req, res);
-            },
-        });
         api.registerChannel({ plugin: eclawChannel });
     },
 };

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

@@ -2,19 +2,10 @@
 export interface EClawAccountConfig {
     enabled: boolean;
     apiKey: string;
-    apiSecret?: 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 {
@@ -33,7 +24,6 @@ export interface EClawInboundMessage {
     fromEntityId?: number;
     fromCharacter?: string;
     fromPublicCode?: string;
-    eclaw_context?: EClawContext;
 }
 /** Entity info returned by channel register */
 export interface EClawEntityInfo {
@@ -59,13 +49,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,7 @@
 /**
  * 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)
- *
- * 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]")
+ * When a user sends a message on E-Claw, the backend POSTs structured JSON
+ * to this webhook. We normalize it and dispatch to the OpenClaw agent.
  */
-export declare function createWebhookHandler(expectedToken: string, accountId: string, cfg: any): (req: any, res: any) => Promise<void>;
+export declare function createWebhookHandler(expectedToken: string, accountId: string): (req: any, res: any) => Promise<void>;

package/dist/webhook-handler.js

@@ -1,26 +1,11 @@
 import { getPluginRuntime } from './runtime.js';
-import { getClient, setActiveEvent, clearActiveEvent } 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)
- *
- * 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]")
+ * When a user sends a message on E-Claw, the backend POSTs structured JSON
+ * to this webhook. We normalize it and dispatch to the OpenClaw agent.
  */
-export function createWebhookHandler(expectedToken, accountId, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-cfg // full openclaw config (ctx.cfg from startAccount)
-) {
+export function createWebhookHandler(expectedToken, accountId) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return async (req, res) => {
         // Verify callback token
@@ -37,103 +22,36 @@ cfg // full openclaw config (ctx.cfg from startAccount)
         // Dispatch to OpenClaw agent
         try {
             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');
+            // Map E-Claw media types to OpenClaw types
+            let media;
+            if (msg.mediaType && msg.mediaUrl) {
+                const type = msg.mediaType === 'photo' ? 'image'
+                    : msg.mediaType === 'voice' ? 'audio'
+                        : msg.mediaType === 'video' ? 'video'
+                            : 'file';
+                media = { type, url: msg.mediaUrl };
             }
-            // Build context in OpenClaw's native PascalCase format
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const inboundCtx = {
-                Surface: 'eclaw',
-                Provider: 'eclaw',
-                OriginatingChannel: 'eclaw',
-                AccountId: accountId,
-                From: msg.from,
-                To: conversationId,
-                OriginatingTo: msg.from,
-                SessionKey: conversationId,
-                Body: body,
-                RawBody: body,
-                CommandBody: body,
-                ChatType: 'direct',
-                ...(ocMediaType && msg.mediaUrl ? {
-                    MediaType: ocMediaType,
-                    MediaUrl: msg.mediaUrl,
-                } : {}),
+                channelId: 'eclaw',
+                accountId,
+                conversationId,
+                senderId: msg.from,
+                text: msg.text || '',
+                ...(media ? { media } : {}),
+                metadata: {
+                    deviceId: msg.deviceId,
+                    entityId: msg.entityId,
+                    event: msg.event,
+                    fromEntityId: msg.fromEntityId,
+                    fromCharacter: msg.fromCharacter,
+                    isBroadcast: msg.isBroadcast,
+                    timestamp: msg.timestamp,
+                },
             };
-            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);
-                        },
-                    },
-                });
-            }
-            finally {
-                clearActiveEvent(accountId);
-            }
+            // OpenClaw inbound dispatch pipeline
+            const ctx = await rt.channel.reply.finalizeInboundContext(inboundCtx);
+            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher(ctx);
         }
         catch (err) {
             console.error('[E-Claw] Webhook dispatch error:', err);