@efengx/openclaw-channel-dragon 0.5.16 → 0.5.18

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

@@ -15,6 +15,7 @@ export declare class ChannelComponent implements IComponent {
     constructor(options: ChannelOptions, telemetry: TelemetryComponent);
     start(): Promise<void>;
     stop(): Promise<void>;
+    private stringifyProgressDetail;
     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

@@ -10,6 +10,21 @@ export class ChannelComponent {
     }
     async start() { }
     async stop() { }
+    stringifyProgressDetail(value, maxLength = 240) {
+        if (typeof value === 'string') {
+            const text = value.trim();
+            return text ? text.slice(0, maxLength) : undefined;
+        }
+        if (value == null)
+            return undefined;
+        try {
+            const text = JSON.stringify(value);
+            return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+        }
+        catch {
+            return String(value).slice(0, maxLength);
+        }
+    }
     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))
@@ -32,6 +47,11 @@ export class ChannelComponent {
             .catch(() => { })
             .then(async () => {
             logger?.info?.(`[Dragon Plugin] Sending to OpenClaw: "${content.substring(0, 50)}${content.length > 50 ? '...' : ''}" [Session: ${sessionId}]`);
+            const progress = (payload) => this.telemetry.reportProgress({
+                sessionId,
+                msgId: replyMsgId,
+                ...payload,
+            });
             await replyDispatcher({
                 ctx: {
                     Body: content,
@@ -61,7 +81,126 @@ export class ChannelComponent {
                             msgId: replyMsgId,
                         });
                     }
-                }
+                },
+                replyOptions: {
+                    onReplyStart: async () => {
+                        await progress({ kind: 'lifecycle', phase: 'start', status: 'running', title: '开始处理请求' });
+                    },
+                    onAssistantMessageStart: async () => {
+                        await progress({ kind: 'assistant', phase: 'start', status: 'running', title: '开始生成回复' });
+                    },
+                    onPartialReply: async (payload) => {
+                        await progress({
+                            kind: 'assistant_delta',
+                            phase: 'update',
+                            status: 'running',
+                            title: '正在生成回复',
+                            detail: this.stringifyProgressDetail(payload?.delta || payload?.text),
+                            data: { replace: payload?.replace === true },
+                        });
+                    },
+                    onReasoningStream: async (payload) => {
+                        await progress({
+                            kind: 'reasoning',
+                            phase: 'update',
+                            status: 'running',
+                            title: '正在推理',
+                            detail: this.stringifyProgressDetail(payload?.text || payload),
+                        });
+                    },
+                    onReasoningEnd: async () => {
+                        await progress({ kind: 'reasoning', phase: 'end', status: 'completed', title: '推理完成' });
+                    },
+                    onToolStart: async (payload) => {
+                        await progress({
+                            kind: 'tool',
+                            phase: payload?.phase || 'start',
+                            status: 'running',
+                            title: payload?.name ? `调用工具：${payload.name}` : '调用工具',
+                            detail: this.stringifyProgressDetail(payload?.args),
+                            data: payload,
+                        });
+                    },
+                    onToolResult: async (payload) => {
+                        await progress({
+                            kind: 'tool',
+                            phase: 'end',
+                            status: 'completed',
+                            title: '工具执行完成',
+                            detail: this.stringifyProgressDetail(payload?.text || payload),
+                        });
+                    },
+                    onItemEvent: async (payload) => {
+                        await progress({
+                            kind: payload?.kind || 'item',
+                            phase: payload?.phase,
+                            status: payload?.status,
+                            title: payload?.title || payload?.name || '任务步骤更新',
+                            detail: this.stringifyProgressDetail(payload?.progressText || payload?.summary || payload?.meta),
+                            data: payload,
+                        });
+                    },
+                    onPlanUpdate: async (payload) => {
+                        await progress({
+                            kind: 'plan',
+                            phase: payload?.phase || 'update',
+                            status: 'running',
+                            title: payload?.title || '更新执行计划',
+                            detail: this.stringifyProgressDetail(payload?.explanation || payload?.steps),
+                            data: payload,
+                        });
+                    },
+                    onApprovalEvent: async (payload) => {
+                        await progress({
+                            kind: 'approval',
+                            phase: payload?.phase || 'update',
+                            status: payload?.status || 'running',
+                            title: payload?.title || '等待审批',
+                            detail: this.stringifyProgressDetail(payload?.message || payload?.reason || payload?.command),
+                            data: payload,
+                        });
+                    },
+                    onCommandOutput: async (payload) => {
+                        await progress({
+                            kind: 'command',
+                            phase: payload?.phase || 'update',
+                            status: payload?.status || 'running',
+                            title: payload?.title || payload?.name || '命令执行中',
+                            detail: this.stringifyProgressDetail(payload?.output || payload?.cwd),
+                            data: payload,
+                        });
+                    },
+                    onPatchSummary: async (payload) => {
+                        await progress({
+                            kind: 'patch',
+                            phase: payload?.phase || 'end',
+                            status: payload?.status || 'completed',
+                            title: payload?.title || '代码变更完成',
+                            detail: this.stringifyProgressDetail(payload?.summary || {
+                                added: payload?.added,
+                                modified: payload?.modified,
+                                deleted: payload?.deleted,
+                            }),
+                            data: payload,
+                        });
+                    },
+                    onCompactionStart: async () => {
+                        await progress({ kind: 'compaction', phase: 'start', status: 'running', title: '正在压缩上下文' });
+                    },
+                    onCompactionEnd: async () => {
+                        await progress({ kind: 'compaction', phase: 'end', status: 'completed', title: '上下文压缩完成' });
+                    },
+                    onModelSelected: (model) => {
+                        void progress({
+                            kind: 'model',
+                            phase: 'selected',
+                            status: 'completed',
+                            title: '已选择模型',
+                            detail: [model?.provider, model?.model].filter(Boolean).join('/'),
+                            data: model,
+                        });
+                    },
+                },
             });
         })
             .finally(() => {

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

@@ -7,6 +7,7 @@ export declare class TelemetryComponent implements IComponent {
     start(): Promise<void>;
     stop(): Promise<void>;
     private lastReplies;
+    private lastProgress;
     reportReply(payload: {
         content: string;
         sessionId: string;
@@ -16,4 +17,14 @@ export declare class TelemetryComponent implements IComponent {
         msgId?: string;
     }): Promise<void>;
     reportEvent(stream: string, data: any, ts: number): Promise<void>;
+    reportProgress(payload: {
+        sessionId: string;
+        msgId?: string;
+        kind: string;
+        phase?: string;
+        status?: string;
+        title?: string;
+        detail?: string;
+        data?: any;
+    }): Promise<void>;
 }

package/dist/components/telemetry/TelemetryComponent.js

@@ -8,6 +8,7 @@ export class TelemetryComponent {
     async start() { }
     async stop() { }
     lastReplies = new Map();
+    lastProgress = new Map();
     async reportReply(payload) {
         try {
             const source = payload.source || "unknown";
@@ -69,4 +70,36 @@ export class TelemetryComponent {
         catch (e) {
         }
     }
+    async reportProgress(payload) {
+        try {
+            const sessionId = payload.sessionId || "default";
+            const key = `${sessionId}:${payload.kind}:${payload.title || ""}`;
+            const signature = JSON.stringify({
+                phase: payload.phase,
+                status: payload.status,
+                detail: payload.detail,
+                data: payload.data,
+            });
+            const now = Date.now();
+            const last = this.lastProgress.get(key);
+            if (last && last.signature === signature && now - last.timestamp < 1000) {
+                return;
+            }
+            if ((payload.kind === "assistant_delta" || payload.kind === "reasoning") && last && now - last.timestamp < 350) {
+                return;
+            }
+            this.lastProgress.set(key, { signature, timestamp: now });
+            await this.http.fetch(`/api/agents/${this.agentId}/messages/progress`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    ...payload,
+                    sessionId,
+                    ts: now,
+                }),
+            });
+        }
+        catch (e) {
+        }
+    }
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "dragon",
   "name": "Dragon Workbench Channel",
   "description": "Connect OpenClaw to the Dragon agent-client workbench chat.",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "enabledByDefault": true,
   "activation": {
     "onCapabilities": ["hook"]

package/package.json

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

package/dist/components/bridge/BridgeComponent.d.ts

@@ -1,17 +0,0 @@
-import { type DragonBridgeClient } from "../../ws.js";
-import { IComponent } from "../../core/IComponent.js";
-export declare class BridgeComponent implements IComponent {
-    private options;
-    client: DragonBridgeClient | undefined;
-    constructor(options: {
-        host?: string;
-        port: number;
-        token: string;
-        agentId: string;
-        gatewayPort: number;
-        gatewayToken: string;
-        logger?: any;
-    });
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}

package/dist/components/bridge/BridgeComponent.js

@@ -1,45 +0,0 @@
-import { connectToDragonBridge } from "../../ws.js";
-export class BridgeComponent {
-    options;
-    client;
-    constructor(options) {
-        this.options = options;
-    }
-    async start() {
-        const { host, port, token, agentId, gatewayPort, gatewayToken, logger } = this.options;
-        this.client = connectToDragonBridge({
-            host,
-            port,
-            token,
-            onConnected: () => {
-                logger?.info?.("dragon channel: connected to dragon bridge");
-                this.client?.sendJson({
-                    type: "hello",
-                    channel: "dragon",
-                    agentId,
-                    port: gatewayPort,
-                    token: gatewayToken,
-                    version: "0.1.27",
-                    timestamp: Date.now()
-                });
-            },
-            onDisconnected: () => {
-                logger?.info?.("dragon channel: disconnected from dragon bridge");
-            },
-            onMessage: (msg) => {
-                const t = msg?.type;
-                if (t === "ping") {
-                    this.client?.sendJson({ type: "pong", t: Date.now() });
-                    return;
-                }
-                if (t === "hot_control") {
-                    const { command } = msg;
-                    logger?.info?.(`dragon channel: received hot control: ${command}`);
-                }
-            },
-        });
-    }
-    async stop() {
-        // WebSocket close logic if needed
-    }
-}

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

@@ -1,19 +0,0 @@
-import { IComponent } from "../../core/IComponent.js";
-import { HttpComponent } from "../http/HttpComponent.js";
-import { ChannelComponent } from "../channel/ChannelComponent.js";
-export declare class PollingComponent implements IComponent {
-    private http;
-    private channel;
-    private options;
-    private pollInterval;
-    constructor(http: HttpComponent, channel: ChannelComponent, options: {
-        agentId: string;
-        accountId: string;
-        channelRuntime?: any;
-        abortSignal: AbortSignal;
-        logger?: any;
-    });
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private consumePendingMessages;
-}

package/dist/components/sync/PollingComponent.js

@@ -1,42 +0,0 @@
-export class PollingComponent {
-    http;
-    channel;
-    options;
-    pollInterval = null;
-    constructor(http, channel, options) {
-        this.http = http;
-        this.channel = channel;
-        this.options = options;
-    }
-    async start() {
-        // 1. Initial consume
-        void this.consumePendingMessages();
-        // 2. Periodic recovery polling (every 60s)
-        this.pollInterval = setInterval(() => {
-            void this.consumePendingMessages();
-        }, 60_000);
-    }
-    async stop() {
-        if (this.pollInterval)
-            clearInterval(this.pollInterval);
-    }
-    async consumePendingMessages() {
-        const { agentId, logger } = this.options;
-        try {
-            const res = await this.http.fetch(`/api/agents/${agentId}/messages/poll`);
-            if (res.ok) {
-                const data = (await res.json());
-                const messages = data.messages || [];
-                if (messages.length > 0) {
-                    logger?.debug?.(`[Dragon Plugin] [Recovery] Polled ${messages.length} pending messages.`);
-                    for (const m of messages) {
-                        await this.channel.deliverToOpenClaw(String(m.content || ''), String(m.sessionId || 'default'), m.modelId, m.attachments, m.externalId || m.id);
-                    }
-                }
-            }
-        }
-        catch (e) {
-            // Quiet fail for recovery polling
-        }
-    }
-}