@efengx/openclaw-channel-dragon 0.5.27 → 0.5.29

package/dist/components/channel/ChannelComponent.d.ts

@@ -18,7 +18,11 @@ export declare class ChannelComponent implements IComponent {
     private normalizeSessionSegment;
     private resolveOpenClawAgentId;
     private buildOpenClawSessionKey;
+    private resolveWorkbenchSessionIdFromOpenClawSessionKey;
     private stringifyProgressDetail;
+    private findTaskCompletionEvent;
+    private extractGeneratedMediaLines;
+    private formatTaskCompletionReply;
     deliverToOpenClaw: (content: string, sessionId?: string, modelId?: string, attachments?: any[], messageId?: string | number) => Promise<void>;
     handleOutboundText: (ctx: any) => Promise<{
         ok: boolean;

package/dist/components/channel/ChannelComponent.js

@@ -34,6 +34,19 @@ export class ChannelComponent {
         const workbenchSessionId = this.normalizeSessionSegment(sessionId, 'default');
         return `agent:${openClawAgentId}:dragon:direct:${dragonAgentId}:${workbenchSessionId}`;
     }
+    resolveWorkbenchSessionIdFromOpenClawSessionKey(sessionKey) {
+        const raw = String(sessionKey || '').trim();
+        if (!raw)
+            return 'default';
+        const parts = raw.split(':');
+        if (parts[0] === 'agent' && parts[2] === channelId) {
+            return parts.slice(5).join(':') || 'default';
+        }
+        if (parts[0] === channelId) {
+            return parts.slice(3).join(':') || 'default';
+        }
+        return 'default';
+    }
     stringifyProgressDetail(value, maxLength = 240) {
         if (typeof value === 'string') {
             const text = value.trim();
@@ -49,6 +62,48 @@ export class ChannelComponent {
             return String(value).slice(0, maxLength);
         }
     }
+    findTaskCompletionEvent(value) {
+        if (!value || typeof value !== 'object')
+            return undefined;
+        if (value.type === 'task_completion')
+            return value;
+        const candidates = [
+            value.event,
+            value.data,
+            ...(Array.isArray(value.internalEvents) ? value.internalEvents : []),
+            ...(Array.isArray(value.events) ? value.events : []),
+        ];
+        for (const candidate of candidates) {
+            const found = this.findTaskCompletionEvent(candidate);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    extractGeneratedMediaLines(event) {
+        const lines = new Set();
+        for (const url of Array.isArray(event?.mediaUrls) ? event.mediaUrls : []) {
+            if (typeof url === 'string' && url.trim()) {
+                lines.add(`MEDIA:${url.trim()}`);
+            }
+        }
+        for (const attachment of Array.isArray(event?.attachments) ? event.attachments : []) {
+            const value = attachment?.url || attachment?.path || attachment?.filePath || attachment?.mediaUrl;
+            if (typeof value === 'string' && value.trim()) {
+                lines.add(`MEDIA:${value.trim()}`);
+            }
+        }
+        return Array.from(lines);
+    }
+    formatTaskCompletionReply(event) {
+        const result = typeof event?.result === 'string' ? event.result.trim() : '';
+        const mediaLines = this.extractGeneratedMediaLines(event);
+        const lines = [
+            result,
+            ...mediaLines.filter((line) => !result.includes(line)),
+        ].filter((line) => line.trim());
+        return lines.join('\n');
+    }
     deliverToOpenClaw = async (content, sessionId = 'default', modelId, attachments, messageId) => {
         const replyMsgId = messageId ? `dragon_msg_${messageId}` : `dragon_msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         if (messageId && this.processedMessageIds.has(messageId))
@@ -305,6 +360,30 @@ export class ChannelComponent {
         return { ok: true, messageId: Date.now().toString() };
     };
     handleAgentEvent = async (evt) => {
-        await this.telemetry.reportEvent(evt.stream, evt.data, evt.ts);
+        const sessionId = evt?.sessionId ||
+            this.resolveWorkbenchSessionIdFromOpenClawSessionKey(evt?.sessionKey);
+        await this.telemetry.reportEvent(evt.stream, evt.data, evt.ts, sessionId);
+        const taskCompletion = this.findTaskCompletionEvent(evt?.data);
+        if (!taskCompletion)
+            return;
+        const content = this.formatTaskCompletionReply(taskCompletion);
+        if (!content)
+            return;
+        await this.telemetry.reportProgress({
+            sessionId,
+            msgId: taskCompletion.childSessionId ? `dragon_task_${taskCompletion.childSessionId}` : undefined,
+            kind: 'task_completion',
+            phase: 'end',
+            status: taskCompletion.status === 'ok' ? 'completed' : taskCompletion.status,
+            title: taskCompletion.status === 'ok' ? '后台任务完成' : '后台任务更新',
+            detail: this.stringifyProgressDetail(taskCompletion.taskLabel || taskCompletion.statusLabel),
+            data: taskCompletion,
+        });
+        await this.telemetry.reportReply({
+            content,
+            sessionId,
+            source: 'agent_event_task_completion',
+            msgId: taskCompletion.childSessionId ? `dragon_task_reply_${taskCompletion.childSessionId}` : undefined,
+        });
     };
 }

package/dist/components/telemetry/TelemetryComponent.d.ts

@@ -16,7 +16,7 @@ export declare class TelemetryComponent implements IComponent {
         source?: string;
         msgId?: string;
     }): Promise<void>;
-    reportEvent(stream: string, data: any, ts: number): Promise<void>;
+    reportEvent(stream: string, data: any, ts: number, sessionId?: string): Promise<void>;
     reportProgress(payload: {
         sessionId: string;
         msgId?: string;

package/dist/components/telemetry/TelemetryComponent.js

@@ -36,7 +36,7 @@ export class TelemetryComponent {
             // Error logged by HttpComponent
         }
     }
-    async reportEvent(stream, data, ts) {
+    async reportEvent(stream, data, ts, sessionId = "default") {
         try {
             let telemetryPayload = null;
             if (stream === "thinking") {
@@ -63,7 +63,7 @@ export class TelemetryComponent {
                 this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ ...telemetryPayload, msgId }),
+                    body: JSON.stringify({ ...telemetryPayload, sessionId, msgId }),
                 }).catch(() => { });
             }
         }

package/dist/index.js

@@ -10,6 +10,18 @@ import { dragonChannelPluginVersion } from "./version.js";
 const channelId = "dragon";
 let cachedRuntime;
 const containers = new Map();
+function isDragonSessionKey(sessionKey) {
+    const raw = String(sessionKey || '').trim();
+    return raw.startsWith(`${channelId}:`) || /^agent:[^:]+:dragon(?::|$)/.test(raw);
+}
+function resolveAccountIdFromSessionKey(sessionKey) {
+    const raw = String(sessionKey || '').trim();
+    const parts = raw.split(':');
+    if (parts[0] === channelId) {
+        return parts[2] || "default";
+    }
+    return "default";
+}
 async function getOrCreateContainer(account, ctx) {
     const key = `${account.agentId}:${account.orchestratorUrl}`;
     if (containers.has(key))
@@ -147,37 +159,84 @@ 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 || {})}`);
                 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}`);
                     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}`);
+                    // 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).
+                    const sentMediaUrls = [];
+                    const pushMedia = (v, source) => {
+                        if (typeof v === 'string' && v.trim()) {
+                            const url = v.trim();
+                            sentMediaUrls.push(url);
+                            logger?.info?.(`[Dragon Plugin] handleAction extracted media URL from ${source}: ${url}`);
+                        }
+                    };
+                    pushMedia(params.media, "params.media");
+                    pushMedia(params.mediaUrl, "params.mediaUrl");
+                    pushMedia(params.path, "params.path");
+                    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}`);
+                        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}`);
+                        for (const a of params.attachments) {
+                            if (a && typeof a === 'object') {
+                                pushMedia(a.media, "attachment.media");
+                                pushMedia(a.mediaUrl, "attachment.mediaUrl");
+                                pushMedia(a.path, "attachment.path");
+                                pushMedia(a.filePath, "attachment.filePath");
+                                pushMedia(a.fileUrl, "attachment.fileUrl");
+                            }
+                        }
+                    }
+                    logger?.info?.(`[Dragon Plugin] handleAction total media URLs extracted: count=${sentMediaUrls.length}, urls=${JSON.stringify(sentMediaUrls)}`);
                     let text = params.message || params.text || "";
-                    const media = params.media || params.mediaUrl || params.path || params.filePath || params.fileUrl;
-                    if (media && typeof media === 'string') {
-                        const mediaLine = `MEDIA: ${media}`;
+                    logger?.info?.(`[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}`;
                         if (!text.includes(mediaLine)) {
                             text = text ? `${text}\n${mediaLine}` : mediaLine;
                         }
                     }
+                    logger?.info?.(`[Dragon Plugin] handleAction sending text over channel: text_len=${text.length}, targetSession=${sessionId}`);
                     const result = await channel.handleOutboundText({
                         text,
                         peer: { id: sessionId }
                     });
-                    return {
+                    logger?.info?.(`[Dragon Plugin] handleAction channel send result: ok=${result.ok}, messageId=${result.messageId || "none"}`);
+                    const evidence = {
                         ok: result.ok,
                         ...result.messageId ? { messageId: result.messageId } : {},
+                        // Evidence fields that OpenClaw checks via hasMessagingToolDeliveryEvidence
+                        // and hasGatewayAgentDeliveredExpectedMedia
                         didSendViaMessagingTool: true,
-                        messagingToolSentTexts: [text],
-                        messagingToolSentTargets: [target]
+                        messagingToolSentTexts: text ? [text] : [],
+                        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}`);
+                    return evidence;
                 }
+                logger?.warn?.(`[Dragon Plugin] handleAction action "${action}" is not supported. Ignoring.`);
                 throw new Error(`Action "${action}" is not supported by the dragon channel plugin.`);
             }
         }
@@ -205,14 +264,15 @@ const entry = defineChannelPluginEntry({
         if (typeof agentEventHandler === 'function') {
             agentEventHandler(async (evt) => {
                 const sessionKey = evt.sessionKey;
-                if (!sessionKey || !sessionKey.startsWith(`${channelId}:`))
+                if (!isDragonSessionKey(sessionKey))
                     return;
-                const accountId = sessionKey.split(':')[2] || "default";
+                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 // Ensure runtime is passed
+                    channelRuntime: api?.runtime?.channelRuntime,
+                    logger: api?.runtime?.logger ?? api?.runtime?.log,
                 });
                 const channel = container.get('channel');
                 await channel.handleAgentEvent(evt);

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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