@efengx/openclaw-channel-dragon 0.5.17 → 0.5.19

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/sync/SseComponent.d.ts

@@ -10,6 +10,7 @@ export declare class SseComponent implements IComponent {
     private reconnectTimer;
     constructor(http: HttpComponent, channel: ChannelComponent, options: {
         agentId: string;
+        version: string;
         logger?: any;
     });
     start(): Promise<void>;

package/dist/components/sync/SseComponent.js

@@ -24,7 +24,7 @@ export class SseComponent {
             return;
         const { agentId, logger } = this.options;
         const url = `${this.http.options.baseURL}/api/agents/events`;
-        logger?.info?.(`[Dragon Plugin] Connecting to Orchestrator SSE: ${url}`);
+        logger?.info?.(`[Dragon Plugin] v${this.options.version} connecting to Orchestrator SSE: ${url} (agent=${agentId})`);
         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.

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/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 { dragonChannelPluginVersion } from "./version.js";
 const channelId = "dragon";
 let cachedRuntime;
 const containers = new Map();
@@ -15,6 +16,7 @@ async function getOrCreateContainer(account, ctx) {
         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}`);
     // 1. Core Infrastructure
     const http = container.register('http', new HttpComponent({
         baseURL: account.orchestratorUrl,
@@ -33,6 +35,7 @@ async function getOrCreateContainer(account, ctx) {
     // 3. Sync Infrastructure
     container.register('sse', new SseComponent(http, channel, {
         agentId: account.agentId,
+        version: dragonChannelPluginVersion,
         logger
     }));
     await container.startAll();

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const dragonChannelPluginVersion = "0.5.19";

package/dist/version.js

@@ -0,0 +1 @@
+export const dragonChannelPluginVersion = "0.5.19";

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.17",
+  "version": "0.5.19",
   "enabledByDefault": true,
   "activation": {
     "onCapabilities": ["hook"]

package/package.json

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