@efengx/openclaw-channel-dragon 0.5.35 → 0.5.37

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

@@ -1,5 +1,6 @@
 import { IComponent } from "../../core/IComponent.js";
 import { TelemetryComponent } from "../telemetry/TelemetryComponent.js";
+import { MediaRegistryComponent } from "../media/MediaRegistryComponent.js";
 export interface ChannelOptions {
     accountId: string;
     agentId: string;
@@ -10,9 +11,10 @@ export interface ChannelOptions {
 export declare class ChannelComponent implements IComponent {
     private options;
     private telemetry;
+    private mediaRegistry;
     private processedMessageIds;
     private sessionQueues;
-    constructor(options: ChannelOptions, telemetry: TelemetryComponent);
+    constructor(options: ChannelOptions, telemetry: TelemetryComponent, mediaRegistry: MediaRegistryComponent);
     start(): Promise<void>;
     stop(): Promise<void>;
     private normalizeSessionSegment;
@@ -23,16 +25,17 @@ export declare class ChannelComponent implements IComponent {
     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;
         messageId: string;
         error: any;
+        attachments?: undefined;
     } | {
         ok: boolean;
         messageId: string;
+        attachments: import("../media/MediaRegistryComponent.js").DragonMediaAttachment[];
         error?: undefined;
     }>;
     reportTargetProtocolError: (message: string, rawTarget: unknown) => Promise<void>;

package/dist/components/channel/ChannelComponent.js

@@ -4,11 +4,13 @@ const workbenchTargetPrefix = "dragon-workbench:";
 export class ChannelComponent {
     options;
     telemetry;
+    mediaRegistry;
     processedMessageIds = new Set();
     sessionQueues = new Map();
-    constructor(options, telemetry) {
+    constructor(options, telemetry, mediaRegistry) {
         this.options = options;
         this.telemetry = telemetry;
+        this.mediaRegistry = mediaRegistry;
     }
     async start() { }
     async stop() { }
@@ -96,29 +98,8 @@ export class ChannelComponent {
         }
         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');
+        return typeof event?.result === 'string' ? event.result.trim() : '';
     }
     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)}`;
@@ -166,13 +147,15 @@ export class ChannelComponent {
                     dispatcherOptions: {
                         deliver: async (payload) => {
                             const text = payload?.text || "";
-                            if (!text && !payload?.tool_calls?.length)
+                            const archivedAttachments = await this.mediaRegistry.archiveStructuredMedia(payload);
+                            if (!text && !payload?.tool_calls?.length && archivedAttachments.length === 0)
                                 return;
                             await this.telemetry.reportReply({
                                 content: text,
                                 sessionId,
                                 tool_calls: payload?.tool_calls,
                                 reasoning_content: payload?.reasoning_content,
+                                attachments: archivedAttachments.length > 0 ? archivedAttachments : payload?.attachments,
                                 source: "telemetry_deliver",
                                 msgId: replyMsgId,
                             });
@@ -218,12 +201,16 @@ export class ChannelComponent {
                             });
                         },
                         onToolResult: async (payload) => {
+                            const archivedAttachments = await this.mediaRegistry.archiveStructuredMedia(payload);
                             await progress({
-                                kind: 'tool',
+                                kind: archivedAttachments.length > 0 ? 'media' : 'tool',
                                 phase: 'end',
                                 status: 'completed',
-                                title: '工具执行完成',
-                                detail: this.stringifyProgressDetail(payload?.text || payload),
+                                title: archivedAttachments.length > 0 ? '媒体文件已生成' : '工具执行完成',
+                                detail: archivedAttachments.length > 0
+                                    ? archivedAttachments.map((item) => item.name).join(', ')
+                                    : this.stringifyProgressDetail(payload?.text || payload),
+                                data: archivedAttachments.length > 0 ? { ...payload, attachments: archivedAttachments } : payload,
                             });
                         },
                         onItemEvent: async (payload) => {
@@ -371,6 +358,7 @@ export class ChannelComponent {
     handleOutboundText = async (ctx) => {
         const text = ctx?.text || "";
         const { logger } = this.options;
+        const archivedAttachments = await this.mediaRegistry.archiveStructuredMedia(ctx);
         let sessionId;
         try {
             sessionId = this.decodeWorkbenchTarget(ctx?.peer?.id);
@@ -382,8 +370,13 @@ export class ChannelComponent {
             return { ok: false, messageId: Date.now().toString(), error: message };
         }
         logger?.info?.(`[dragon channels][Dragon Plugin] Outbound Text (Action): "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}" [Session: ${sessionId}] [RawPeer: ${ctx?.peer?.id || 'none'}]`);
-        await this.telemetry.reportReply({ content: text, sessionId, source: "channel_outbound" });
-        return { ok: true, messageId: Date.now().toString() };
+        await this.telemetry.reportReply({
+            content: text,
+            sessionId,
+            attachments: archivedAttachments.length > 0 ? archivedAttachments : ctx?.attachments,
+            source: "channel_outbound",
+        });
+        return { ok: true, messageId: Date.now().toString(), attachments: archivedAttachments };
     };
     reportTargetProtocolError = async (message, rawTarget) => {
         const content = [
@@ -407,7 +400,8 @@ export class ChannelComponent {
         if (!taskCompletion)
             return;
         const content = this.formatTaskCompletionReply(taskCompletion);
-        if (!content)
+        const archivedAttachments = await this.mediaRegistry.archiveStructuredMedia(taskCompletion);
+        if (!content && archivedAttachments.length === 0)
             return;
         await this.telemetry.reportProgress({
             sessionId,
@@ -417,11 +411,12 @@ export class ChannelComponent {
             status: taskCompletion.status === 'ok' ? 'completed' : taskCompletion.status,
             title: taskCompletion.status === 'ok' ? '后台任务完成' : '后台任务更新',
             detail: this.stringifyProgressDetail(taskCompletion.taskLabel || taskCompletion.statusLabel),
-            data: taskCompletion,
+            data: archivedAttachments.length > 0 ? { ...taskCompletion, attachments: archivedAttachments } : taskCompletion,
         });
         await this.telemetry.reportReply({
             content,
             sessionId,
+            attachments: archivedAttachments.length > 0 ? archivedAttachments : taskCompletion?.attachments,
             source: 'agent_event_task_completion',
             msgId: taskCompletion.childSessionId ? `dragon_task_reply_${taskCompletion.childSessionId}` : undefined,
         });

package/dist/components/media/MediaRegistryComponent.d.ts

@@ -0,0 +1,35 @@
+import { IComponent } from "../../core/IComponent.js";
+type LoggerLike = {
+    info?: (...args: any[]) => void;
+    warn?: (...args: any[]) => void;
+    error?: (...args: any[]) => void;
+};
+export type DragonMediaAttachment = {
+    type: string;
+    kind: string;
+    name: string;
+    mimeType?: string;
+    sourcePath?: string;
+    workspacePath?: string;
+    path?: string;
+    url?: string;
+    size?: number;
+};
+export declare class MediaRegistryComponent implements IComponent {
+    private options;
+    constructor(options: {
+        cfg: any;
+        logger?: LoggerLike;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private resolveWorkspaceRoot;
+    private normalizeLocalPath;
+    private isPathInside;
+    private inferMime;
+    private inferKind;
+    private buildWorkspaceRelativePath;
+    private collectStructuredMedia;
+    archiveStructuredMedia(value: any): Promise<DragonMediaAttachment[]>;
+}
+export {};

package/dist/components/media/MediaRegistryComponent.js

@@ -0,0 +1,141 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export class MediaRegistryComponent {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() { }
+    async stop() { }
+    resolveWorkspaceRoot() {
+        const candidates = [
+            this.options.cfg?.agents?.defaults?.workspace,
+            this.options.cfg?.agents?.default?.workspace,
+            ...(Array.isArray(this.options.cfg?.agents?.list)
+                ? this.options.cfg.agents.list.map((agent) => agent?.workspace)
+                : []),
+            process.env.OPENCLAW_WORKSPACE_ROOT,
+            process.env.DRAGON_OPENCLAW_WORKSPACE_ROOT,
+        ];
+        const found = candidates.find((value) => typeof value === "string" && value.trim());
+        return found ? path.resolve(String(found).trim()) : undefined;
+    }
+    normalizeLocalPath(value) {
+        if (typeof value !== "string")
+            return undefined;
+        const raw = value.trim();
+        if (!raw)
+            return undefined;
+        if (raw.startsWith("file://")) {
+            try {
+                return path.resolve(decodeURIComponent(new URL(raw).pathname));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (!path.isAbsolute(raw))
+            return undefined;
+        return path.resolve(raw);
+    }
+    isPathInside(parent, child) {
+        const rel = path.relative(parent, child);
+        return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
+    }
+    inferMime(filePath, fallback) {
+        if (fallback)
+            return fallback;
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === ".png")
+            return "image/png";
+        if (ext === ".jpg" || ext === ".jpeg")
+            return "image/jpeg";
+        if (ext === ".webp")
+            return "image/webp";
+        if (ext === ".gif")
+            return "image/gif";
+        if (ext === ".svg")
+            return "image/svg+xml";
+        return undefined;
+    }
+    inferKind(mimeType) {
+        if (mimeType?.startsWith("image/"))
+            return "image";
+        if (mimeType?.startsWith("video/"))
+            return "video";
+        if (mimeType?.startsWith("audio/"))
+            return "audio";
+        return "file";
+    }
+    buildWorkspaceRelativePath(sourcePath, workspaceRoot) {
+        const normalized = path.resolve(sourcePath);
+        if (this.isPathInside(workspaceRoot, normalized)) {
+            return path.relative(workspaceRoot, normalized).split(path.sep).join("/");
+        }
+        const marker = `${path.sep}media${path.sep}`;
+        const mediaIndex = normalized.lastIndexOf(marker);
+        if (mediaIndex >= 0) {
+            return path
+                .join("media", normalized.slice(mediaIndex + marker.length))
+                .split(path.sep)
+                .join("/");
+        }
+        return path.join("media", path.basename(normalized)).split(path.sep).join("/");
+    }
+    collectStructuredMedia(value) {
+        const items = [];
+        if (!value || typeof value !== "object")
+            return items;
+        if (Array.isArray(value.attachments))
+            items.push(...value.attachments);
+        if (Array.isArray(value.media))
+            items.push(...value.media);
+        if (Array.isArray(value.mediaUrls)) {
+            items.push(...value.mediaUrls.map((url) => ({ url })));
+        }
+        return items.filter(Boolean);
+    }
+    async archiveStructuredMedia(value) {
+        const workspaceRoot = this.resolveWorkspaceRoot();
+        if (!workspaceRoot)
+            return [];
+        const media = this.collectStructuredMedia(value);
+        const seen = new Set();
+        const attachments = [];
+        for (const item of media) {
+            const sourcePath = this.normalizeLocalPath(item?.path ?? item?.filePath ?? item?.mediaPath ?? item?.url);
+            if (!sourcePath || seen.has(sourcePath))
+                continue;
+            seen.add(sourcePath);
+            try {
+                const stat = await fs.stat(sourcePath);
+                if (!stat.isFile())
+                    continue;
+                const workspacePath = this.buildWorkspaceRelativePath(sourcePath, workspaceRoot);
+                const targetPath = path.resolve(workspaceRoot, workspacePath);
+                if (!this.isPathInside(workspaceRoot, targetPath))
+                    continue;
+                if (path.resolve(sourcePath) !== targetPath) {
+                    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                    await fs.copyFile(sourcePath, targetPath);
+                }
+                const mimeType = this.inferMime(targetPath, item?.mimeType || item?.mime);
+                const kind = item?.kind || item?.type || this.inferKind(mimeType);
+                attachments.push({
+                    type: kind,
+                    kind,
+                    name: item?.name || path.basename(targetPath),
+                    mimeType,
+                    sourcePath,
+                    workspacePath,
+                    path: workspacePath,
+                    size: stat.size,
+                });
+            }
+            catch (error) {
+                this.options.logger?.warn?.(`[dragon channels][media] failed to archive media: source=${sourcePath}, error=${error?.message || error}`);
+            }
+        }
+        return attachments;
+    }
+}

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

@@ -23,6 +23,7 @@ export declare class SseComponent implements IComponent {
         reconnectMs?: number;
         idleTimeoutMs?: number;
     });
+    private logContext;
     start(): Promise<void>;
     stop(): Promise<void>;
     private connect;

package/dist/components/sync/SseComponent.js

@@ -15,15 +15,18 @@ export class SseComponent {
         this.channel = channel;
         this.options = options;
     }
+    logContext() {
+        return `version=${this.options.version}, channelAgent=${this.options.agentId}, account=${this.options.accountId}`;
+    }
     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.logger?.info?.(`[dragon channels][SSE] component start: ${this.logContext()}, 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}`);
+            this.options.logger?.info?.(`[dragon channels][SSE] upstream abort received: ${this.logContext()}`);
             void this.stop();
         }, { once: true });
         this.connect();
@@ -50,7 +53,7 @@ export class SseComponent {
             connected: false,
             lastStopAt: Date.now(),
         });
-        this.options.logger?.info?.(`[dragon channels][SSE] component stopped: agent=${this.options.agentId}, account=${this.options.accountId}`);
+        this.options.logger?.info?.(`[dragon channels][SSE] component stopped: ${this.logContext()}`);
     }
     connect() {
         if (!this.shouldReconnect)
@@ -64,12 +67,12 @@ export class SseComponent {
         });
         const url = `${this.http.options.baseURL}/api/agents/events?${params.toString()}`;
         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}`);
+        logger?.info?.(`[dragon channels][SSE] connect start: connection=${connectionId}, attempt=${this.reconnectAttempts + 1}, ${this.logContext()}, url=${url}`);
         try {
             void this.startSseReader(url, connectionId);
         }
         catch (err) {
-            logger?.error?.(`[dragon channels][SSE] connect init failed: connection=${connectionId}, error=${err.message}`);
+            logger?.error?.(`[dragon channels][SSE] connect init failed: connection=${connectionId}, ${this.logContext()}, error=${err.message}`);
             this.markDisconnected(err?.message || String(err));
             this.scheduleReconnect('init_failed');
         }
@@ -84,7 +87,7 @@ export class SseComponent {
             lastTransportActivityAt: now,
             lastError: null,
         });
-        this.options.logger?.debug?.(`[dragon channels][SSE] transport activity: connection=${connectionId}, reason=${reason}, at=${now}`);
+        this.options.logger?.debug?.(`[dragon channels][SSE] transport activity: connection=${connectionId}, ${this.logContext()}, reason=${reason}, at=${now}`);
         this.armIdleWatchdog(connectionId);
     }
     armIdleWatchdog(connectionId) {
@@ -95,7 +98,7 @@ export class SseComponent {
             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.options.logger?.warn?.(`[dragon channels][SSE] idle timeout: connection=${connectionId}, ${this.logContext()}, idleMs=${idleMs}, timeoutMs=${timeoutMs}; aborting fetch for reconnect`);
             this.markDisconnected(`SSE idle timeout after ${idleMs}ms`);
             this.fetchAbort?.abort();
         }, timeoutMs);
@@ -142,14 +145,14 @@ export class SseComponent {
                 lastError: null,
                 reconnectAttempts: 0,
             });
-            this.options.logger?.info?.(`[dragon channels][SSE] stream established: connection=${connectionId}, agent=${this.options.agentId}, account=${this.options.accountId}`);
+            this.options.logger?.info?.(`[dragon channels][SSE] stream established: connection=${connectionId}, ${this.logContext()}`);
             this.armIdleWatchdog(connectionId);
             const decoder = new TextDecoder();
             let buffer = "";
             while (this.shouldReconnect) {
                 const { value, done } = await reader.read();
                 if (done) {
-                    this.options.logger?.warn?.(`[dragon channels][SSE] stream ended by remote: connection=${connectionId}`);
+                    this.options.logger?.warn?.(`[dragon channels][SSE] stream ended by remote: connection=${connectionId}, ${this.logContext()}`);
                     break;
                 }
                 this.touchTransport(connectionId, 'chunk');
@@ -165,13 +168,13 @@ export class SseComponent {
                     if (cleanLine.startsWith("data: ")) {
                         try {
                             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'}`);
+                            this.options.logger?.debug?.(`[dragon channels][SSE] event received: connection=${connectionId}, ${this.logContext()}, type=${data?.type || 'unknown'}, eventAgent=${data?.agentId || 'unknown'}`);
                             void this.handleEvent(data).catch((err) => {
-                                this.options.logger?.error?.(`[dragon channels][SSE] event handling failed: connection=${connectionId}, error=${err?.message || err}`);
+                                this.options.logger?.error?.(`[dragon channels][SSE] event handling failed: connection=${connectionId}, ${this.logContext()}, error=${err?.message || err}`);
                             });
                         }
                         catch (e) {
-                            this.options.logger?.error?.(`[dragon channels][SSE] event JSON parse failed: connection=${connectionId}, line="${cleanLine}", error=${e?.message || e}`);
+                            this.options.logger?.error?.(`[dragon channels][SSE] event JSON parse failed: connection=${connectionId}, ${this.logContext()}, line="${cleanLine}", error=${e?.message || e}`);
                         }
                     }
                 }
@@ -187,7 +190,7 @@ export class SseComponent {
                 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.options.logger?.warn?.(`[dragon channels][SSE] stream disconnected: connection=${connectionId}, ${this.logContext()}, error=${message}`);
                 this.markDisconnected(message);
                 this.scheduleReconnect(message);
             }
@@ -220,12 +223,12 @@ export class SseComponent {
         // 2. Handle specific types
         if (data.type === 'WORKBENCH_MESSAGE') {
             const { content, sessionId, attachments, id, msgId } = data.payload || {};
-            logger?.info?.(`[dragon channels][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] [SSE] Received from Workbench: ${this.logContext()}, messageAgent=${data?.agentId || 'unknown'}, "${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 channels][Dragon Plugin] Triggering history sync for session: ${sessionId}`);
+            logger?.info?.(`[dragon channels][Dragon Plugin] [SSE] Triggering history sync: ${this.logContext()}, session=${sessionId}`);
             // Handle history sync if needed, but deliverToOpenClaw usually handles normal chat
         }
     }
@@ -244,7 +247,7 @@ export class SseComponent {
             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.options.logger?.info?.(`[dragon channels][SSE] reconnect scheduled: attempt=${this.reconnectAttempts}, delayMs=${delayMs}, reason=${reason}, ${this.logContext()}`);
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = undefined;
             this.options.setStatus?.({

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

@@ -13,6 +13,7 @@ export declare class TelemetryComponent implements IComponent {
         sessionId: string;
         tool_calls?: any[];
         reasoning_content?: string;
+        attachments?: any[];
         source?: string;
         msgId?: string;
     }): Promise<void>;

package/dist/components/telemetry/TelemetryComponent.js

@@ -15,7 +15,7 @@ export class TelemetryComponent {
             const sessionId = payload.sessionId || "default";
             const content = payload.content || "";
             const normalized = content.replace(/\s+/g, "");
-            if (normalized) {
+            if (normalized && !payload.attachments?.length) {
                 const key = `${source}_${sessionId}`;
                 const last = this.lastReplies.get(key);
                 const now = Date.now();

package/dist/index.js

@@ -6,6 +6,7 @@ import { TelemetryComponent } from "./components/telemetry/TelemetryComponent.js
 import { HttpComponent } from "./components/http/HttpComponent.js";
 import { ChannelComponent } from "./components/channel/ChannelComponent.js";
 import { SseComponent } from "./components/sync/SseComponent.js";
+import { MediaRegistryComponent } from "./components/media/MediaRegistryComponent.js";
 import { dragonChannelPluginVersion } from "./version.js";
 const channelId = "dragon";
 const workbenchTargetPrefix = "dragon-workbench:";
@@ -62,6 +63,10 @@ async function getOrCreateContainer(account, ctx) {
         logger
     }));
     const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
+    const mediaRegistry = container.register('mediaRegistry', new MediaRegistryComponent({
+        cfg: ctx.cfg,
+        logger,
+    }));
     // 2. Channel Logic (Centralized)
     const channel = container.register('channel', new ChannelComponent({
         accountId: account.accountId,
@@ -69,7 +74,7 @@ async function getOrCreateContainer(account, ctx) {
         channelRuntime: ctx.channelRuntime,
         cfg: ctx.cfg,
         logger
-    }, telemetry));
+    }, telemetry, mediaRegistry));
     // 3. Sync Infrastructure
     container.register('sse', new SseComponent(http, channel, {
         agentId: account.agentId,
@@ -248,54 +253,21 @@ const plugin = createChatChannelPlugin({
                         };
                     }
                     logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolved: sessionId=${sessionId}, target=${target}, rawTarget=${rawTarget}`);
-                    // 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 channels][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 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 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");
-                                pushMedia(a.mediaUrl, "attachment.mediaUrl");
-                                pushMedia(a.path, "attachment.path");
-                                pushMedia(a.filePath, "attachment.filePath");
-                                pushMedia(a.fileUrl, "attachment.fileUrl");
-                            }
-                        }
-                    }
-                    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 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}`;
-                        if (!text.includes(mediaLine)) {
-                            text = text ? `${text}\n${mediaLine}` : mediaLine;
-                        }
-                    }
                     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: target }
+                        peer: { id: target },
+                        attachments: params.attachments,
+                        media: params.media,
+                        mediaUrls: params.mediaUrls,
                     });
+                    const deliveredMediaUrls = Array.isArray(result.attachments)
+                        ? result.attachments
+                            .map((attachment) => attachment?.sourcePath || attachment?.path || attachment?.url)
+                            .filter((value) => typeof value === 'string' && value.trim())
+                        : (Array.isArray(params.mediaUrls) ? params.mediaUrls : []);
                     logger?.info?.(`[dragon channels][Dragon Plugin] handleAction channel send result: ok=${result.ok}, messageId=${result.messageId || "none"}`);
                     const evidence = {
                         ok: result.ok,
@@ -304,8 +276,8 @@ const plugin = createChatChannelPlugin({
                         // and hasGatewayAgentDeliveredExpectedMedia
                         didSendViaMessagingTool: true,
                         messagingToolSentTexts: text ? [text] : [],
-                        messagingToolSentMediaUrls: sentMediaUrls,
-                        messagingToolSentTargets: [{ to: target, ...(sentMediaUrls.length > 0 ? { mediaUrls: sentMediaUrls } : {}) }],
+                        messagingToolSentMediaUrls: deliveredMediaUrls,
+                        messagingToolSentTargets: [{ to: target, ...(deliveredMediaUrls.length > 0 ? { mediaUrls: deliveredMediaUrls } : {}) }],
                     };
                     logger?.info?.(`[dragon channels][Dragon Plugin] handleAction returning evidence to OpenClaw: didSendViaMessagingTool=${evidence.didSendViaMessagingTool}, sentMediaUrlsCount=${evidence.messagingToolSentMediaUrls.length}`);
                     return evidence;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const dragonChannelPluginVersion = "0.5.35";
+export declare const dragonChannelPluginVersion = "0.5.37";

package/dist/version.js

@@ -1 +1 @@
-export const dragonChannelPluginVersion = "0.5.35";
+export const dragonChannelPluginVersion = "0.5.37";

package/package.json

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