@efengx/openclaw-channel-dragon 0.5.29 → 0.5.32

package/dist/components/channel/ChannelComponent.js

@@ -125,7 +125,7 @@ export class ChannelComponent {
         const current = previous
             .catch(() => { })
             .then(async () => {
-            logger?.info?.(`[Dragon Plugin] v${dragonChannelPluginVersion} Sending to OpenClaw: "${content.substring(0, 50)}${content.length > 50 ? '...' : ''}" [WorkbenchSession: ${sessionId}] [OpenClawSessionKey: ${sessionKey}]`);
+            logger?.info?.(`[dragon channels][Dragon Plugin] v${dragonChannelPluginVersion} Sending to OpenClaw: "${content.substring(0, 50)}${content.length > 50 ? '...' : ''}" [WorkbenchSession: ${sessionId}] [OpenClawSessionKey: ${sessionKey}]`);
             const progress = (payload) => this.telemetry.reportProgress({
                 sessionId,
                 msgId: replyMsgId,
@@ -284,7 +284,7 @@ export class ChannelComponent {
                 });
             }
             catch (err) {
-                logger?.error?.(`[Dragon Plugin] Error during replyDispatcher: ${err?.message || err}`);
+                logger?.error?.(`[dragon channels][Dragon Plugin] Error during replyDispatcher: ${err?.message || err}`);
                 let resolvedErrorMessage = err?.message || String(err);
                 const isTakeoverError = resolvedErrorMessage.includes("session file changed while embedded prompt lock was released");
                 if (isTakeoverError) {
@@ -303,7 +303,7 @@ export class ChannelComponent {
                                     const item = JSON.parse(lines[i]);
                                     if (item.type === "message" && item.stopReason === "error" && item.errorMessage) {
                                         resolvedErrorMessage = item.errorMessage;
-                                        logger?.warn?.(`[Dragon Plugin] Extracted real underlying error from session file: ${resolvedErrorMessage}`);
+                                        logger?.warn?.(`[dragon channels][Dragon Plugin] Extracted real underlying error from session file: ${resolvedErrorMessage}`);
                                         break;
                                     }
                                 }
@@ -314,7 +314,7 @@ export class ChannelComponent {
                         }
                     }
                     catch (fsErr) {
-                        logger?.error?.(`[Dragon Plugin] Failed to read real error from session file: ${fsErr}`);
+                        logger?.error?.(`[dragon channels][Dragon Plugin] Failed to read real error from session file: ${fsErr}`);
                     }
                 }
                 // Check for insufficient spending cap/quota error and provide a friendly Chinese message
@@ -355,7 +355,7 @@ export class ChannelComponent {
     handleOutboundText = async (ctx) => {
         const text = ctx?.text || "";
         const { logger } = this.options;
-        logger?.info?.(`[Dragon Plugin] Outbound Text (Action): "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`);
+        logger?.info?.(`[dragon channels][Dragon Plugin] Outbound Text (Action): "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`);
         await this.telemetry.reportReply({ content: text, sessionId: ctx?.peer?.id || "default", source: "channel_outbound" });
         return { ok: true, messageId: Date.now().toString() };
     };

package/dist/components/http/HttpComponent.js

@@ -4,7 +4,7 @@ export class HttpComponent {
         this.options = options;
     }
     async start() {
-        this.options.logger?.info?.(`[Dragon-Channel] HttpComponent started for ${this.options.baseURL}`);
+        this.options.logger?.info?.(`[dragon channels][Dragon-Channel] HttpComponent started for ${this.options.baseURL}`);
     }
     async stop() { }
     async fetch(path, init) {
@@ -20,7 +20,7 @@ export class HttpComponent {
             headers
         });
         if (!res.ok && res.status !== 404) {
-            this.options.logger?.warn?.(`[Dragon-Channel] HTTP Request failed: ${res.status} ${url}`);
+            this.options.logger?.warn?.(`[dragon channels][Dragon-Channel] HTTP Request failed: ${res.status} ${url}`);
         }
         return res;
     }

package/dist/components/sync/SseComponent.d.ts

@@ -5,17 +5,30 @@ export declare class SseComponent implements IComponent {
     private http;
     private channel;
     private options;
-    private eventSource;
     private shouldReconnect;
     private reconnectTimer;
+    private idleTimer;
+    private fetchAbort;
+    private reader;
+    private reconnectAttempts;
+    private connectionSeq;
+    private lastTransportActivityAt;
     constructor(http: HttpComponent, channel: ChannelComponent, options: {
         agentId: string;
+        accountId: string;
         version: string;
         logger?: any;
+        abortSignal?: AbortSignal;
+        setStatus?: (next: Record<string, unknown>) => void;
+        reconnectMs?: number;
+        idleTimeoutMs?: number;
     });
     start(): Promise<void>;
     stop(): Promise<void>;
     private connect;
+    private touchTransport;
+    private armIdleWatchdog;
+    private markDisconnected;
     private startSseReader;
     private handleEvent;
     private scheduleReconnect;

package/dist/components/sync/SseComponent.js

@@ -2,44 +2,117 @@ export class SseComponent {
     http;
     channel;
     options;
-    eventSource;
     shouldReconnect = true;
     reconnectTimer;
+    idleTimer;
+    fetchAbort;
+    reader;
+    reconnectAttempts = 0;
+    connectionSeq = 0;
+    lastTransportActivityAt = 0;
     constructor(http, channel, options) {
         this.http = http;
         this.channel = channel;
         this.options = options;
     }
     async start() {
+        this.options.logger?.info?.(`[dragon channels][SSE] component start: version=${this.options.version}, agent=${this.options.agentId}, account=${this.options.accountId}, baseUrl=${this.http.options.baseURL}`);
+        this.options.setStatus?.({
+            accountId: this.options.accountId,
+            connected: false,
+            lastError: null,
+        });
+        this.options.abortSignal?.addEventListener('abort', () => {
+            this.options.logger?.info?.(`[dragon channels][SSE] upstream abort received: agent=${this.options.agentId}, account=${this.options.accountId}`);
+            void this.stop();
+        }, { once: true });
         this.connect();
     }
     async stop() {
         this.shouldReconnect = false;
         if (this.reconnectTimer)
             clearTimeout(this.reconnectTimer);
-        this.eventSource?.close();
+        this.reconnectTimer = undefined;
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = undefined;
+        this.fetchAbort?.abort();
+        this.fetchAbort = undefined;
+        try {
+            await this.reader?.cancel?.();
+        }
+        catch {
+            // Reader cancellation can race with fetch abort.
+        }
+        this.reader = undefined;
+        this.options.setStatus?.({
+            accountId: this.options.accountId,
+            connected: false,
+            lastStopAt: Date.now(),
+        });
+        this.options.logger?.info?.(`[dragon channels][SSE] component stopped: agent=${this.options.agentId}, account=${this.options.accountId}`);
     }
     connect() {
         if (!this.shouldReconnect)
             return;
         const { agentId, logger } = this.options;
         const url = `${this.http.options.baseURL}/api/agents/events`;
-        logger?.info?.(`[Dragon Plugin] v${this.options.version} connecting to Orchestrator SSE: ${url} (agent=${agentId})`);
+        const connectionId = `${Date.now()}-${++this.connectionSeq}`;
+        logger?.info?.(`[dragon channels][SSE] connect start: connection=${connectionId}, attempt=${this.reconnectAttempts + 1}, version=${this.options.version}, url=${url}, agent=${agentId}, account=${this.options.accountId}`);
         try {
-            // In Node 22, we might need a fetch-based SSE or a library,
-            // but for simplicity we'll use the same pattern as Bridge if possible.
-            // Actually, standard EventSource is not in Node globals yet.
-            // We'll use a simple fetch-based stream reader.
-            this.startSseReader(url);
+            void this.startSseReader(url, connectionId);
         }
         catch (err) {
-            logger?.error?.(`[Dragon Plugin] SSE Init Failed: ${err.message}`);
-            this.scheduleReconnect();
+            logger?.error?.(`[dragon channels][SSE] connect init failed: connection=${connectionId}, error=${err.message}`);
+            this.markDisconnected(err?.message || String(err));
+            this.scheduleReconnect('init_failed');
+        }
+    }
+    touchTransport(connectionId, reason) {
+        const now = Date.now();
+        this.lastTransportActivityAt = now;
+        this.options.setStatus?.({
+            accountId: this.options.accountId,
+            connected: true,
+            lastEventAt: now,
+            lastTransportActivityAt: now,
+            lastError: null,
+        });
+        this.options.logger?.debug?.(`[dragon channels][SSE] transport activity: connection=${connectionId}, reason=${reason}, at=${now}`);
+        this.armIdleWatchdog(connectionId);
+    }
+    armIdleWatchdog(connectionId) {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        const timeoutMs = this.options.idleTimeoutMs ?? 90_000;
+        this.idleTimer = setTimeout(() => {
+            if (!this.shouldReconnect)
+                return;
+            const idleMs = Date.now() - this.lastTransportActivityAt;
+            this.options.logger?.warn?.(`[dragon channels][SSE] idle timeout: connection=${connectionId}, idleMs=${idleMs}, timeoutMs=${timeoutMs}; aborting fetch for reconnect`);
+            this.markDisconnected(`SSE idle timeout after ${idleMs}ms`);
+            this.fetchAbort?.abort();
+        }, timeoutMs);
+        if (typeof this.idleTimer === 'object' && 'unref' in this.idleTimer) {
+            this.idleTimer.unref();
         }
     }
-    async startSseReader(url) {
+    markDisconnected(error) {
+        this.options.setStatus?.({
+            accountId: this.options.accountId,
+            connected: false,
+            lastError: error,
+            lastTransportActivityAt: this.lastTransportActivityAt || null,
+        });
+    }
+    async startSseReader(url, connectionId) {
+        const abort = new AbortController();
+        this.fetchAbort = abort;
+        const upstreamAbort = () => abort.abort();
+        this.options.abortSignal?.addEventListener('abort', upstreamAbort, { once: true });
         try {
             const response = await fetch(url, {
+                signal: abort.signal,
                 headers: {
                     'Accept': 'text/event-stream',
                     'Authorization': `Bearer ${this.http.options.authToken || ''}`
@@ -51,35 +124,87 @@ export class SseComponent {
             const reader = response.body?.getReader();
             if (!reader)
                 throw new Error("Response body is null");
-            this.options.logger?.debug?.(`[Dragon Plugin] SSE Stream Established.`);
+            this.reader = reader;
+            this.reconnectAttempts = 0;
+            const now = Date.now();
+            this.lastTransportActivityAt = now;
+            this.options.setStatus?.({
+                accountId: this.options.accountId,
+                connected: true,
+                lastConnectedAt: now,
+                lastTransportActivityAt: now,
+                lastError: null,
+                reconnectAttempts: 0,
+            });
+            this.options.logger?.info?.(`[dragon channels][SSE] stream established: connection=${connectionId}, agent=${this.options.agentId}, account=${this.options.accountId}`);
+            this.armIdleWatchdog(connectionId);
             const decoder = new TextDecoder();
             let buffer = "";
             while (this.shouldReconnect) {
                 const { value, done } = await reader.read();
-                if (done)
+                if (done) {
+                    this.options.logger?.warn?.(`[dragon channels][SSE] stream ended by remote: connection=${connectionId}`);
                     break;
+                }
+                this.touchTransport(connectionId, 'chunk');
                 buffer += decoder.decode(value, { stream: true });
                 const lines = buffer.split("\n");
                 buffer = lines.pop() || "";
                 for (const line of lines) {
-                    if (line.startsWith("data: ")) {
+                    const cleanLine = line.trim();
+                    if (!cleanLine || cleanLine.startsWith(':')) {
+                        this.touchTransport(connectionId, cleanLine.startsWith(':') ? 'heartbeat' : 'blank_line');
+                        continue;
+                    }
+                    if (cleanLine.startsWith("data: ")) {
                         try {
-                            const data = JSON.parse(line.slice(6));
+                            const data = JSON.parse(cleanLine.slice(6));
+                            this.options.logger?.debug?.(`[dragon channels][SSE] event received: connection=${connectionId}, type=${data?.type || 'unknown'}, agent=${data?.agentId || 'unknown'}`);
                             void this.handleEvent(data).catch((err) => {
-                                this.options.logger?.error?.(`[Dragon Plugin] SSE event handling failed: ${err?.message || err}`);
+                                this.options.logger?.error?.(`[dragon channels][SSE] event handling failed: connection=${connectionId}, error=${err?.message || err}`);
                             });
                         }
-                        catch (e) { }
+                        catch (e) {
+                            this.options.logger?.error?.(`[dragon channels][SSE] event JSON parse failed: connection=${connectionId}, line="${cleanLine}", error=${e?.message || e}`);
+                        }
                     }
                 }
             }
+            if (this.shouldReconnect) {
+                const message = 'SSE stream ended';
+                this.markDisconnected(message);
+                this.scheduleReconnect(message);
+            }
         }
         catch (err) {
             if (this.shouldReconnect) {
-                this.options.logger?.warn?.(`[Dragon Plugin] SSE Stream Disconnected: ${err.message}`);
-                this.scheduleReconnect();
+                const message = err?.name === 'AbortError'
+                    ? 'SSE fetch aborted'
+                    : (err?.message || String(err));
+                this.options.logger?.warn?.(`[dragon channels][SSE] stream disconnected: connection=${connectionId}, error=${message}`);
+                this.markDisconnected(message);
+                this.scheduleReconnect(message);
             }
         }
+        finally {
+            this.options.abortSignal?.removeEventListener('abort', upstreamAbort);
+            if (this.reader) {
+                try {
+                    await this.reader.cancel?.();
+                }
+                catch {
+                    // Ignore cancellation races.
+                }
+            }
+            if (this.fetchAbort === abort) {
+                this.fetchAbort = undefined;
+            }
+            if (this.idleTimer) {
+                clearTimeout(this.idleTimer);
+                this.idleTimer = undefined;
+            }
+            this.reader = undefined;
+        }
     }
     async handleEvent(data) {
         const { agentId, logger } = this.options;
@@ -89,18 +214,42 @@ export class SseComponent {
         // 2. Handle specific types
         if (data.type === 'WORKBENCH_MESSAGE') {
             const { content, sessionId, attachments, id, msgId } = data.payload || {};
-            logger?.info?.(`[Dragon Plugin] v${this.options.version} [SSE] Received from Workbench: "${content?.substring(0, 50)}${content?.length > 50 ? '...' : ''}" [Session: ${sessionId}]`);
+            logger?.info?.(`[dragon channels][Dragon Plugin] v${this.options.version} [SSE] Received from Workbench: "${content?.substring(0, 50)}${content?.length > 50 ? '...' : ''}" [Session: ${sessionId}]`);
             await this.channel.deliverToOpenClaw(content, sessionId, undefined, attachments, msgId || id);
         }
         else if (data.type === 'FETCH_HISTORY') {
             const { sessionId } = data.payload || {};
-            logger?.info?.(`[Dragon Plugin] Triggering history sync for session: ${sessionId}`);
+            logger?.info?.(`[dragon channels][Dragon Plugin] Triggering history sync for session: ${sessionId}`);
             // Handle history sync if needed, but deliverToOpenClaw usually handles normal chat
         }
     }
-    scheduleReconnect() {
+    scheduleReconnect(reason) {
+        if (!this.shouldReconnect)
+            return;
         if (this.reconnectTimer)
             clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = setTimeout(() => this.connect(), 5000);
+        this.reconnectAttempts += 1;
+        const baseMs = this.options.reconnectMs ?? 5_000;
+        const delayMs = Math.min(60_000, baseMs * Math.max(1, this.reconnectAttempts));
+        this.options.setStatus?.({
+            accountId: this.options.accountId,
+            connected: false,
+            restartPending: true,
+            reconnectAttempts: this.reconnectAttempts,
+            lastError: reason,
+        });
+        this.options.logger?.info?.(`[dragon channels][SSE] reconnect scheduled: attempt=${this.reconnectAttempts}, delayMs=${delayMs}, reason=${reason}, agent=${this.options.agentId}, account=${this.options.accountId}`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.options.setStatus?.({
+                accountId: this.options.accountId,
+                restartPending: false,
+                reconnectAttempts: this.reconnectAttempts,
+            });
+            this.connect();
+        }, delayMs);
+        if (typeof this.reconnectTimer === 'object' && 'unref' in this.reconnectTimer) {
+            this.reconnectTimer.unref();
+        }
     }
 }

package/dist/index.js

@@ -22,17 +22,27 @@ function resolveAccountIdFromSessionKey(sessionKey) {
     }
     return "default";
 }
+function containerKey(account) {
+    return `${account.accountId}:${account.agentId}:${account.orchestratorUrl}`;
+}
 async function getOrCreateContainer(account, ctx) {
-    const key = `${account.agentId}:${account.orchestratorUrl}`;
-    if (containers.has(key))
+    const key = containerKey(account);
+    if (containers.has(key)) {
+        const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
+        logger?.debug?.(`[dragon channels][Dragon Plugin] Reusing channel container: key=${key}, agent=${account.agentId}, account=${account.accountId}`);
         return containers.get(key);
+    }
     const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
     const container = new ServiceContainer();
-    logger?.info?.(`[Dragon Plugin] Starting channel plugin v${dragonChannelPluginVersion} for agent=${account.agentId}, account=${account.accountId}, orchestrator=${account.orchestratorUrl}`);
+    logger?.info?.(`[dragon channels][Dragon Plugin] Starting channel plugin v${dragonChannelPluginVersion} for agent=${account.agentId}, account=${account.accountId}, orchestrator=${account.orchestratorUrl}`);
     // 1. Core Infrastructure
     const http = container.register('http', new HttpComponent({
         baseURL: account.orchestratorUrl,
-        authToken: account.orchestratorAuthToken || process.env.DRAGON_ORCHESTRATOR_AUTH_TOKEN || process.env.DRAGON_GATEWAY_TOKEN,
+        authToken: account.orchestratorAuthToken ||
+            process.env.DRAGON_ORCHESTRATOR_AUTH_TOKEN ||
+            process.env.DRAGON_GATEWAY_TOKEN ||
+            process.env.GATEWAY_TOKEN ||
+            process.env.OPENCLAW_GATEWAY_AUTH_TOKEN,
         logger
     }));
     const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
@@ -47,13 +57,43 @@ async function getOrCreateContainer(account, ctx) {
     // 3. Sync Infrastructure
     container.register('sse', new SseComponent(http, channel, {
         agentId: account.agentId,
+        accountId: account.accountId,
         version: dragonChannelPluginVersion,
-        logger
+        logger,
+        abortSignal: ctx.abortSignal,
+        setStatus: ctx.setStatus,
+        reconnectMs: 5_000,
+        idleTimeoutMs: 90_000,
     }));
     await container.startAll();
     containers.set(key, container);
+    logger?.info?.(`[dragon channels][Dragon Plugin] Channel container started: key=${key}, agent=${account.agentId}, account=${account.accountId}`);
     return container;
 }
+async function stopContainer(account, ctx) {
+    const key = containerKey(account);
+    const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
+    const container = containers.get(key);
+    if (!container) {
+        logger?.debug?.(`[dragon channels][Dragon Plugin] No channel container to stop: key=${key}, agent=${account.agentId}, account=${account.accountId}`);
+        return;
+    }
+    logger?.info?.(`[dragon channels][Dragon Plugin] Stopping channel container: key=${key}, agent=${account.agentId}, account=${account.accountId}`);
+    try {
+        await container.stopAll();
+    }
+    finally {
+        containers.delete(key);
+        ctx?.setStatus?.({
+            accountId: account.accountId,
+            connected: false,
+            running: false,
+            restartPending: false,
+            lastStopAt: Date.now(),
+        });
+        logger?.info?.(`[dragon channels][Dragon Plugin] Channel container stopped: key=${key}, agent=${account.agentId}, account=${account.accountId}`);
+    }
+}
 const base = createChannelPluginBase({
     id: channelId,
     meta: {
@@ -76,7 +116,7 @@ const base = createChannelPluginBase({
             return {
                 accountId,
                 agentId: accountConfig.agentId || accountId,
-                orchestratorUrl: accountConfig.orchestratorUrl || "http://127.0.0.1:4000",
+                orchestratorUrl: accountConfig.orchestratorUrl,
                 orchestratorAuthToken: accountConfig.orchestratorAuthToken || accountConfig.authToken,
             };
         },
@@ -89,13 +129,35 @@ const plugin = createChatChannelPlugin({
         gateway: {
             startAccount: async (ctx) => {
                 const account = base.config.resolveAccount(ctx.cfg, ctx.accountId);
-                await getOrCreateContainer(account, ctx);
-                // v0.5.6+: Prevent channel exit by waiting for abort signal
-                if (ctx.abortSignal.aborted)
-                    return;
-                await new Promise((resolve) => {
-                    ctx.abortSignal.addEventListener('abort', resolve, { once: true });
+                const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
+                logger?.info?.(`[dragon channels][Dragon Plugin] startAccount begin: agent=${account.agentId}, account=${account.accountId}, orchestrator=${account.orchestratorUrl}`);
+                ctx.setStatus?.({
+                    accountId: account.accountId,
+                    enabled: true,
+                    configured: true,
+                    running: true,
+                    connected: false,
+                    lastStartAt: Date.now(),
+                    lastError: null,
                 });
+                try {
+                    await getOrCreateContainer(account, ctx);
+                    if (ctx.abortSignal.aborted)
+                        return;
+                    await new Promise((resolve) => {
+                        ctx.abortSignal.addEventListener('abort', resolve, { once: true });
+                    });
+                }
+                finally {
+                    logger?.info?.(`[dragon channels][Dragon Plugin] startAccount exiting: agent=${account.agentId}, account=${account.accountId}, aborted=${ctx.abortSignal.aborted}`);
+                    await stopContainer(account, ctx);
+                }
+            },
+            stopAccount: async (ctx) => {
+                const account = base.config.resolveAccount(ctx.cfg, ctx.accountId);
+                const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
+                logger?.info?.(`[dragon channels][Dragon Plugin] stopAccount requested: agent=${account.agentId}, account=${account.accountId}`);
+                await stopContainer(account, ctx);
             }
         },
         messaging: {
@@ -160,20 +222,20 @@ const plugin = createChatChannelPlugin({
             handleAction: async (ctx) => {
                 const { action, params, cfg, accountId } = ctx;
                 const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
-                logger?.info?.(`[Dragon Plugin] handleAction start: action=${action}, accountId=${accountId}, paramsKeys=${Object.keys(params || {})}`);
+                logger?.info?.(`[dragon channels][Dragon Plugin] handleAction start: action=${action}, accountId=${accountId}, paramsKeys=${Object.keys(params || {})}`);
                 if (action === "send") {
                     const account = base.config.resolveAccount(cfg, accountId);
                     const container = await getOrCreateContainer(account, ctx);
                     const channel = container.get('channel');
                     let target = params.to || params.target || ctx.toolContext?.currentChannelId || "default";
-                    logger?.info?.(`[Dragon Plugin] handleAction target resolution input: ${target}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolution input: ${target}`);
                     for (const prefix of ["dragon-workbench-", "dragon-workbench:", "dragon-", "dragon:"]) {
                         if (target.startsWith(prefix)) {
                             target = target.substring(prefix.length);
                         }
                     }
                     const sessionId = target || "default";
-                    logger?.info?.(`[Dragon Plugin] handleAction target resolved: sessionId=${sessionId}, rawTarget=${target}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolved: sessionId=${sessionId}, rawTarget=${target}`);
                     // Collect ALL media URLs from the params (mirrors what OpenClaw tracks internally
                     // via collectMessagingMediaUrlsFromRecord when the tool call starts, so that
                     // hasGatewayAgentDeliveredExpectedMedia can match them against expectedMediaUrls).
@@ -182,7 +244,7 @@ const plugin = createChatChannelPlugin({
                         if (typeof v === 'string' && v.trim()) {
                             const url = v.trim();
                             sentMediaUrls.push(url);
-                            logger?.info?.(`[Dragon Plugin] handleAction extracted media URL from ${source}: ${url}`);
+                            logger?.info?.(`[dragon channels][Dragon Plugin] handleAction extracted media URL from ${source}: ${url}`);
                         }
                     };
                     pushMedia(params.media, "params.media");
@@ -191,12 +253,12 @@ const plugin = createChatChannelPlugin({
                     pushMedia(params.filePath, "params.filePath");
                     pushMedia(params.fileUrl, "params.fileUrl");
                     if (Array.isArray(params.mediaUrls)) {
-                        logger?.info?.(`[Dragon Plugin] handleAction found params.mediaUrls array, size=${params.mediaUrls.length}`);
+                        logger?.info?.(`[dragon channels][Dragon Plugin] handleAction found params.mediaUrls array, size=${params.mediaUrls.length}`);
                         for (const u of params.mediaUrls)
                             pushMedia(u, "params.mediaUrls");
                     }
                     if (Array.isArray(params.attachments)) {
-                        logger?.info?.(`[Dragon Plugin] handleAction found params.attachments array, size=${params.attachments.length}`);
+                        logger?.info?.(`[dragon channels][Dragon Plugin] handleAction found params.attachments array, size=${params.attachments.length}`);
                         for (const a of params.attachments) {
                             if (a && typeof a === 'object') {
                                 pushMedia(a.media, "attachment.media");
@@ -207,9 +269,9 @@ const plugin = createChatChannelPlugin({
                             }
                         }
                     }
-                    logger?.info?.(`[Dragon Plugin] handleAction total media URLs extracted: count=${sentMediaUrls.length}, urls=${JSON.stringify(sentMediaUrls)}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction total media URLs extracted: count=${sentMediaUrls.length}, urls=${JSON.stringify(sentMediaUrls)}`);
                     let text = params.message || params.text || "";
-                    logger?.info?.(`[Dragon Plugin] handleAction base message text length: ${text.length}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction base message text length: ${text.length}`);
                     // Append media path to text so the Workbench can render the image
                     for (const url of sentMediaUrls) {
                         const mediaLine = `MEDIA: ${url}`;
@@ -217,12 +279,12 @@ const plugin = createChatChannelPlugin({
                             text = text ? `${text}\n${mediaLine}` : mediaLine;
                         }
                     }
-                    logger?.info?.(`[Dragon Plugin] handleAction sending text over channel: text_len=${text.length}, targetSession=${sessionId}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction sending text over channel: text_len=${text.length}, targetSession=${sessionId}`);
                     const result = await channel.handleOutboundText({
                         text,
                         peer: { id: sessionId }
                     });
-                    logger?.info?.(`[Dragon Plugin] handleAction channel send result: ok=${result.ok}, messageId=${result.messageId || "none"}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction channel send result: ok=${result.ok}, messageId=${result.messageId || "none"}`);
                     const evidence = {
                         ok: result.ok,
                         ...result.messageId ? { messageId: result.messageId } : {},
@@ -233,10 +295,10 @@ const plugin = createChatChannelPlugin({
                         messagingToolSentMediaUrls: sentMediaUrls,
                         messagingToolSentTargets: [{ to: target, ...(sentMediaUrls.length > 0 ? { mediaUrls: sentMediaUrls } : {}) }],
                     };
-                    logger?.info?.(`[Dragon Plugin] handleAction returning evidence to OpenClaw: didSendViaMessagingTool=${evidence.didSendViaMessagingTool}, sentMediaUrlsCount=${evidence.messagingToolSentMediaUrls.length}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction returning evidence to OpenClaw: didSendViaMessagingTool=${evidence.didSendViaMessagingTool}, sentMediaUrlsCount=${evidence.messagingToolSentMediaUrls.length}`);
                     return evidence;
                 }
-                logger?.warn?.(`[Dragon Plugin] handleAction action "${action}" is not supported. Ignoring.`);
+                logger?.warn?.(`[dragon channels][Dragon Plugin] handleAction action "${action}" is not supported. Ignoring.`);
                 throw new Error(`Action "${action}" is not supported by the dragon channel plugin.`);
             }
         }
@@ -268,12 +330,12 @@ const entry = defineChannelPluginEntry({
                     return;
                 const accountId = resolveAccountIdFromSessionKey(sessionKey);
                 const account = base.config.resolveAccount(api?.runtime?.cfg, accountId);
-                const container = await getOrCreateContainer(account, {
-                    cfg: api?.runtime?.cfg,
-                    abortSignal: new AbortController().signal,
-                    channelRuntime: api?.runtime?.channelRuntime,
-                    logger: api?.runtime?.logger ?? api?.runtime?.log,
-                });
+                const logger = api?.runtime?.logger ?? api?.runtime?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
+                const container = containers.get(containerKey(account));
+                if (!container) {
+                    logger?.warn?.(`[dragon channels][Dragon Plugin] agent event skipped because managed container is not running: sessionKey=${sessionKey}, account=${account.accountId}, agent=${account.agentId}`);
+                    return;
+                }
                 const channel = container.get('channel');
                 await channel.handleAgentEvent(evt);
             });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const dragonChannelPluginVersion = "0.5.29";
+export declare const dragonChannelPluginVersion = "0.5.32";

package/dist/version.js

@@ -1 +1 @@
-export const dragonChannelPluginVersion = "0.5.29";
+export const dragonChannelPluginVersion = "0.5.32";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efengx/openclaw-channel-dragon",
-  "version": "0.5.29",
+  "version": "0.5.32",
   "description": "Dragon workbench channel for OpenClaw",
   "author": "feng xiang <ofengx@gmail.com>",
   "type": "module",