@eclaw/openclaw-channel 1.1.0 → 1.1.2

package/dist/gateway.js

@@ -1,51 +1,57 @@
-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';
-// ── 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));
+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);
 }
 /**
  * Gateway lifecycle: start an E-Claw account.
  *
- * 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)
+ * 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
  * 4. Auto-bind entity if not already bound
- * 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
+ * 5. Keep the promise alive until abort signal fires
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function startAccount(ctx) {
-    const { accountId, config } = ctx;
-    const account = resolveAccount(config, accountId);
-    if (!account.enabled || !account.apiKey || !account.apiSecret) {
+    const accountId = ctx.accountId ?? ctx.account?.accountId ?? 'default';
+    const account = resolveAccountFromCtx(ctx);
+    if (!account.enabled || !account.apiKey) {
         console.log(`[E-Claw] Account ${accountId} disabled or missing credentials, skipping`);
         return;
     }
@@ -54,141 +60,59 @@ export async function startAccount(ctx) {
     setClient(accountId, client);
     // Generate per-session callback token
     const callbackToken = randomBytes(32).toString('hex');
-    // Determine webhook configuration
-    const webhookPort = parseInt(process.env.ECLAW_WEBHOOK_PORT || '0') || 0;
-    const publicUrl = process.env.ECLAW_WEBHOOK_URL;
+    // Webhook URL: account config > env var > warn
+    const publicUrl = account.webhookUrl?.replace(/\/$/, '')
+        || process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
     if (!publicUrl) {
-        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');
+        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');
     }
-    // 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);
+    // 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();
             });
         }
         else {
-            res.writeHead(404);
-            res.end('Not Found');
+            resolve();
         }
-    };
-    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,24 +1,3 @@
-/**
- * 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,5 +1,6 @@
 import { setPluginRuntime } from './runtime.js';
 import { eclawChannel } from './channel.js';
+import { dispatchWebhook } from './webhook-registry.js';
 /**
  * E-Claw Channel Plugin for OpenClaw.
  *
@@ -12,24 +13,52 @@ import { eclawChannel } from './channel.js';
  *       accounts:
  *         default:
  *           apiKey: "eck_..."
- *           apiSecret: "ecs_..."
  *           apiBase: "https://eclawbot.com"
  *           entityId: 0
  *           botName: "My Bot"
+ *           webhookUrl: "https://your-openclaw-domain.com"
  *
- * Environment variables:
- *   ECLAW_WEBHOOK_URL  - Public URL for receiving callbacks (required for production)
- *   ECLAW_WEBHOOK_PORT - Port for webhook server (default: random)
+ * 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.
  */
+/** 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: 'eclaw',
+    id: 'openclaw-channel',
     name: 'E-Claw',
-    description: 'E-Claw AI Agent collaboration channel plugin',
+    description: 'E-Claw AI chat platform 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/onboarding.d.ts

@@ -0,0 +1,19 @@
+export declare const eclawOnboardingAdapter: {
+    channel: string;
+    getStatus: ({ cfg }: {
+        cfg: any;
+    }) => Promise<{
+        channel: string;
+        configured: boolean;
+        statusLines: string[];
+        selectionHint: string;
+        quickstartScore: number;
+    }>;
+    configure: ({ cfg, prompter }: {
+        cfg: any;
+        prompter: any;
+    }) => Promise<{
+        cfg: any;
+        accountId: string;
+    }>;
+};

package/dist/onboarding.js

@@ -0,0 +1,77 @@
+import { listAccountIds, resolveAccount } from './config.js';
+const DEFAULT_ACCOUNT_ID = 'default';
+export const eclawOnboardingAdapter = {
+    channel: 'eclaw',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getStatus: async ({ cfg }) => {
+        const ids = listAccountIds(cfg);
+        const configured = ids.some((id) => {
+            const acc = resolveAccount(cfg, id);
+            return Boolean(acc.apiKey);
+        });
+        return {
+            channel: 'eclaw',
+            configured,
+            statusLines: [`E-Claw: ${configured ? 'configured' : 'not configured'}`],
+            selectionHint: configured ? 'configured' : 'E-Claw (AI Live Wallpaper Chat)',
+            quickstartScore: configured ? 1 : 3,
+        };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configure: async ({ cfg, prompter }) => {
+        const accountId = DEFAULT_ACCOUNT_ID;
+        const resolved = resolveAccount(cfg, accountId);
+        await prompter.note([
+            '1. Log in to https://eclawbot.com',
+            '2. Go to Portal → Settings → Channel API',
+            '3. Create an API Key',
+            '4. Enter the credentials below',
+        ].join('\n'), 'E-Claw Setup');
+        const apiKey = await prompter.text({
+            message: 'Channel API Key',
+            placeholder: 'eck_...',
+            initialValue: resolved.apiKey || '',
+            validate: (v) => (String(v ?? '').trim() ? undefined : 'Required'),
+        });
+        const entityIdStr = await prompter.text({
+            message: 'Entity ID (0–3)',
+            placeholder: '0',
+            initialValue: String(resolved.entityId ?? 0),
+            validate: (v) => {
+                const n = Number(v);
+                return Number.isInteger(n) && n >= 0 && n <= 3 ? undefined : 'Must be 0–3';
+            },
+        });
+        const botName = await prompter.text({
+            message: 'Bot display name (optional)',
+            placeholder: 'My Bot',
+            initialValue: resolved.botName ?? '',
+        });
+        const webhookUrl = await prompter.text({
+            message: 'Webhook URL (your OpenClaw public URL, e.g. https://openclaw.example.com)',
+            placeholder: 'https://your-openclaw-domain.com',
+            initialValue: resolved.webhookUrl ?? '',
+        });
+        const nextCfg = {
+            ...cfg,
+            channels: {
+                ...(cfg.channels ?? {}),
+                eclaw: {
+                    ...(cfg.channels?.eclaw ?? {}),
+                    accounts: {
+                        ...(cfg.channels?.eclaw?.accounts ?? {}), // eslint-disable-line @typescript-eslint/no-explicit-any
+                        [accountId]: {
+                            apiKey: String(apiKey).trim(),
+                            apiBase: resolved.apiBase || 'https://eclawbot.com',
+                            entityId: Number(entityIdStr),
+                            botName: String(botName).trim() || undefined,
+                            webhookUrl: String(webhookUrl).trim() || undefined,
+                            enabled: true,
+                        },
+                    },
+                },
+            },
+        };
+        return { cfg: nextCfg, accountId };
+    },
+};

package/dist/outbound.d.ts

@@ -1,4 +1,6 @@
 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,5 +1,13 @@
 /** 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);
 }
@@ -10,6 +18,11 @@ 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: '' };
@@ -32,6 +45,11 @@ 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,10 +2,19 @@
 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 {
@@ -24,6 +33,7 @@ export interface EClawInboundMessage {
     fromEntityId?: number;
     fromCharacter?: string;
     fromPublicCode?: string;
+    eclaw_context?: EClawContext;
 }
 /** Entity info returned by channel register */
 export interface EClawEntityInfo {
@@ -49,6 +59,13 @@ 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,7 +1,18 @@
 /**
  * Create an HTTP request handler for inbound messages from E-Claw.
  *
- * 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.
+ * 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]")
  */
-export declare function createWebhookHandler(expectedToken: string, accountId: string): (req: any, res: any) => Promise<void>;
+export declare function createWebhookHandler(expectedToken: string, accountId: string, cfg: any): (req: any, res: any) => Promise<void>;