@efengx/openclaw-channel-dragon 0.4.3 → 0.4.4

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

@@ -0,0 +1,25 @@
+import { IComponent } from "../../core/IComponent.js";
+import { BridgeComponent } from "../bridge/BridgeComponent.js";
+import { TelemetryComponent } from "../telemetry/TelemetryComponent.js";
+export interface ChannelOptions {
+    accountId: string;
+    agentId: string;
+    channelRuntime: any;
+    cfg: any;
+    logger?: any;
+}
+export declare class ChannelComponent implements IComponent {
+    private options;
+    private bridge;
+    private telemetry;
+    private processedMessageIds;
+    constructor(options: ChannelOptions, bridge: BridgeComponent, telemetry: TelemetryComponent);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    deliverToOpenClaw: (content: string, sessionId?: string, modelId?: string, attachments?: any[], messageId?: string | number) => Promise<void>;
+    handleOutboundText: (ctx: any) => Promise<{
+        ok: boolean;
+        messageId: string;
+    }>;
+    handleAgentEvent: (evt: any) => Promise<void>;
+}

package/dist/components/channel/ChannelComponent.js

@@ -0,0 +1,99 @@
+const channelId = "dragon";
+export class ChannelComponent {
+    options;
+    bridge;
+    telemetry;
+    processedMessageIds = new Set();
+    constructor(options, bridge, telemetry) {
+        this.options = options;
+        this.bridge = bridge;
+        this.telemetry = telemetry;
+    }
+    async start() { }
+    async stop() { }
+    deliverToOpenClaw = async (content, sessionId = 'default', modelId, attachments, messageId) => {
+        if (messageId && this.processedMessageIds.has(messageId))
+            return;
+        if (messageId) {
+            this.processedMessageIds.add(messageId);
+            if (this.processedMessageIds.size > 1000) {
+                const first = this.processedMessageIds.values().next().value;
+                if (first !== undefined)
+                    this.processedMessageIds.delete(first);
+            }
+        }
+        const replyDispatcher = this.options.channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+        if (typeof replyDispatcher !== 'function')
+            return;
+        const { accountId, agentId, cfg, logger } = this.options;
+        const sessionKey = `dragon:${agentId}:direct:${sessionId}`;
+        await replyDispatcher({
+            ctx: {
+                Body: content,
+                From: sessionId === 'default' ? "workbench-user" : `workbench-user-${sessionId}`,
+                To: agentId,
+                ChatType: "direct",
+                Provider: channelId,
+                ChannelId: channelId,
+                AccountId: accountId,
+                SessionKey: sessionKey,
+                Timestamp: Date.now(),
+                Model: modelId,
+                Attachments: attachments,
+            },
+            cfg,
+            dispatcherOptions: {
+                deliver: async (payload) => {
+                    const text = payload?.text || "";
+                    if (!text && !payload?.tool_calls?.length)
+                        return;
+                    if (this.bridge.client) {
+                        this.bridge.client.sendJson({
+                            type: "outbound_text",
+                            channel: channelId,
+                            text,
+                            tool_calls: payload?.tool_calls,
+                            reasoning_content: payload?.reasoning_content,
+                            route: { agentId, accountId, peer: { kind: "direct", id: sessionId }, sessionKey },
+                        });
+                    }
+                    await this.telemetry.reportReply({
+                        content: text,
+                        sessionId,
+                        tool_calls: payload?.tool_calls,
+                        reasoning_content: payload?.reasoning_content,
+                    });
+                }
+            }
+        });
+    };
+    handleOutboundText = async (ctx) => {
+        const text = ctx?.text || "";
+        const { accountId, agentId } = this.options;
+        if (this.bridge.client) {
+            this.bridge.client.sendJson({
+                type: "outbound_text",
+                channel: channelId,
+                text,
+                route: { agentId, accountId, peer: ctx?.peer, sessionKey: ctx?.ctx?.SessionKey },
+            });
+        }
+        await this.telemetry.reportReply({ content: text, sessionId: ctx?.peer?.id || 'default' });
+        return { ok: true, messageId: Date.now().toString() };
+    };
+    handleAgentEvent = async (evt) => {
+        const { agentId, accountId } = this.options;
+        if (this.bridge.client) {
+            this.bridge.client.sendJson({
+                type: "agent_event",
+                channel: channelId,
+                agentId,
+                runId: evt.runId,
+                stream: evt.stream,
+                data: evt.data,
+                sessionKey: evt.sessionKey
+            });
+        }
+        await this.telemetry.reportEvent(evt.stream, evt.data, evt.ts);
+    };
+}

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

@@ -1,15 +1,16 @@
 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, options: {
+    constructor(http: HttpComponent, channel: ChannelComponent, options: {
         agentId: string;
         accountId: string;
         abortSignal: AbortSignal;
         logger?: any;
-        deliverToOpenClaw: (content: string, sessionId?: string, modelId?: string, attachments?: any[], messageId?: string | number) => Promise<void>;
     });
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/components/sync/PollingComponent.js

@@ -1,10 +1,12 @@
 import * as http2 from "node:http2";
 export class PollingComponent {
     http;
+    channel;
     options;
     pollInterval = null;
-    constructor(http, options) {
+    constructor(http, channel, options) {
         this.http = http;
+        this.channel = channel;
         this.options = options;
     }
     async start() {
@@ -21,7 +23,7 @@ export class PollingComponent {
         }
     }
     async consumePendingMessages() {
-        const { agentId, logger, deliverToOpenClaw } = this.options;
+        const { agentId, logger } = this.options;
         try {
             const res = await this.http.fetch(`/api/agents/${agentId}/messages/poll`);
             if (res.ok) {
@@ -30,7 +32,7 @@ export class PollingComponent {
                 if (messages.length > 0) {
                     logger?.info?.(`dragon channel: [RECOVERY] Consuming ${messages.length} pending messages via polling.`);
                     for (const m of messages) {
-                        await deliverToOpenClaw(String(m.content || ''), String(m.sessionId || 'default'), m.modelId, m.attachments, m.id);
+                        await this.channel.deliverToOpenClaw(String(m.content || ''), String(m.sessionId || 'default'), m.modelId, m.attachments, m.id);
                     }
                 }
             }
@@ -58,7 +60,7 @@ export class PollingComponent {
         }
     }
     async connectOnce() {
-        const { agentId, logger, abortSignal, deliverToOpenClaw } = this.options;
+        const { agentId, logger, abortSignal } = this.options;
         const ssePath = `/api/agents/events`;
         void this.consumePendingMessages();
         const handleSseText = async (chunkText, bufRef) => {
@@ -79,7 +81,7 @@ export class PollingComponent {
                 try {
                     const evt = JSON.parse(dataStr);
                     if (evt?.type === 'WORKBENCH_MESSAGE' && evt.agentId === agentId) {
-                        await deliverToOpenClaw(String(evt?.payload?.content || ''), String(evt?.payload?.sessionId || 'default'), evt?.payload?.modelId, evt?.payload?.attachments, evt?.payload?.id);
+                        await this.channel.deliverToOpenClaw(String(evt?.payload?.content || ''), String(evt?.payload?.sessionId || 'default'), evt?.payload?.modelId, evt?.payload?.attachments, evt?.payload?.id);
                     }
                 }
                 catch (e) { }
@@ -90,10 +92,6 @@ export class PollingComponent {
             headers: { Accept: 'text/event-stream' },
         });
         if (res.status === 404) {
-            // HTTP/2 fallback logic (simplified for brevity here, original has full impl)
-            // Note: connectHttp2 should ideally also use HttpComponent logic, but it uses raw node http2
-            // We'll pass the auth token to it manually if needed.
-            // await this.connectHttp2(ssePath, handleSseText);
             return;
         }
         if (!res.ok)

package/dist/index.js

@@ -6,21 +6,23 @@ import { BridgeComponent } from "./components/bridge/BridgeComponent.js";
 import { PollingComponent } from "./components/sync/PollingComponent.js";
 import { TelemetryComponent } from "./components/telemetry/TelemetryComponent.js";
 import { HttpComponent } from "./components/http/HttpComponent.js";
+import { ChannelComponent } from "./components/channel/ChannelComponent.js";
 const channelId = "dragon";
 let cachedRuntime;
 const containers = new Map();
-const processedMessageIds = new Set();
 async function getOrCreateContainer(account, ctx) {
     const key = `${account.agentId}:${account.orchestratorUrl}`;
     if (containers.has(key))
         return containers.get(key);
     const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
     const container = new ServiceContainer();
+    // 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,
         logger
     }));
+    const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
     const bridge = container.register('bridge', new BridgeComponent({
         port: parseInt(account.bridgePort || "18799", 10),
         token: account.bridgeToken || "",
@@ -29,68 +31,20 @@ async function getOrCreateContainer(account, ctx) {
         gatewayToken: account.gatewayToken || "",
         logger
     }));
-    const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
-    const deliverToOpenClaw = async (content, sessionId = 'default', modelId, attachments, messageId) => {
-        if (messageId && processedMessageIds.has(messageId))
-            return;
-        if (messageId) {
-            processedMessageIds.add(messageId);
-            if (processedMessageIds.size > 1000) {
-                const first = processedMessageIds.values().next().value;
-                if (first !== undefined)
-                    processedMessageIds.delete(first);
-            }
-        }
-        const replyDispatcher = ctx.channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher;
-        if (typeof replyDispatcher !== 'function')
-            return;
-        const sessionKey = `dragon:${account.agentId}:direct:${sessionId}`;
-        await replyDispatcher({
-            ctx: {
-                Body: content,
-                From: sessionId === 'default' ? "workbench-user" : `workbench-user-${sessionId}`,
-                To: account.agentId,
-                ChatType: "direct",
-                Provider: channelId,
-                ChannelId: channelId,
-                AccountId: account.accountId,
-                SessionKey: sessionKey,
-                Timestamp: Date.now(),
-                Model: modelId,
-                Attachments: attachments,
-            },
-            cfg: ctx.cfg,
-            dispatcherOptions: {
-                deliver: async (payload) => {
-                    const text = payload?.text || "";
-                    if (!text && !payload?.tool_calls?.length)
-                        return;
-                    if (bridge.client) {
-                        bridge.client.sendJson({
-                            type: "outbound_text",
-                            channel: channelId,
-                            text,
-                            tool_calls: payload?.tool_calls,
-                            reasoning_content: payload?.reasoning_content,
-                            route: { agentId: account.agentId, accountId: account.accountId, peer: { kind: "direct", id: sessionId }, sessionKey },
-                        });
-                    }
-                    await telemetry.reportReply({
-                        content: text,
-                        sessionId,
-                        tool_calls: payload?.tool_calls,
-                        reasoning_content: payload?.reasoning_content,
-                    });
-                }
-            }
-        });
-    };
-    container.register('polling', new PollingComponent(http, {
+    // 2. Channel Logic (Centralized)
+    const channel = container.register('channel', new ChannelComponent({
+        accountId: account.accountId,
+        agentId: account.agentId,
+        channelRuntime: ctx.channelRuntime,
+        cfg: ctx.cfg,
+        logger
+    }, bridge, telemetry));
+    // 3. Polling Infrastructure
+    container.register('polling', new PollingComponent(http, channel, {
         agentId: account.agentId,
         accountId: account.accountId,
         abortSignal: ctx.abortSignal,
-        logger,
-        deliverToOpenClaw
+        logger
     }));
     await container.startAll();
     containers.set(key, container);
@@ -135,21 +89,10 @@ const plugin = createChatChannelPlugin({
         attachedResults: createRawChannelSendResultAdapter({
             channel: channelId,
             async sendText(ctx) {
-                const text = ctx?.text || "";
                 const account = base.config.resolveAccount(ctx.cfg, ctx.accountId);
                 const container = await getOrCreateContainer(account, ctx);
-                const bridge = container.get('bridge');
-                const telemetry = container.get('telemetry');
-                if (bridge.client) {
-                    bridge.client.sendJson({
-                        type: "outbound_text",
-                        channel: channelId,
-                        text,
-                        route: { agentId: account.agentId, accountId: account.accountId, peer: ctx?.peer, sessionKey: ctx?.ctx?.SessionKey },
-                    });
-                }
-                await telemetry.reportReply({ content: text, sessionId: ctx?.peer?.id || 'default' });
-                return { ok: true, messageId: Date.now().toString() };
+                const channel = container.get('channel');
+                return await channel.handleOutboundText(ctx);
             },
         }),
     },
@@ -167,24 +110,15 @@ const entry = defineChannelPluginEntry({
                 const sessionKey = evt.sessionKey;
                 if (!sessionKey || !sessionKey.startsWith(`${channelId}:`))
                     return;
-                const agentId = sessionKey.split(':')[1] || "";
                 const accountId = sessionKey.split(':')[2] || "default";
                 const account = base.config.resolveAccount(api.runtime.cfg, accountId);
-                const container = await getOrCreateContainer(account, { cfg: api.runtime.cfg, abortSignal: new AbortController().signal });
-                const bridge = container.get('bridge');
-                const telemetry = container.get('telemetry');
-                if (bridge.client) {
-                    bridge.client.sendJson({
-                        type: "agent_event",
-                        channel: channelId,
-                        agentId,
-                        runId: evt.runId,
-                        stream: evt.stream,
-                        data: evt.data,
-                        sessionKey
-                    });
-                }
-                await telemetry.reportEvent(evt.stream, evt.data, evt.ts);
+                const container = await getOrCreateContainer(account, {
+                    cfg: api.runtime.cfg,
+                    abortSignal: new AbortController().signal,
+                    channelRuntime: api.runtime.channelRuntime // Ensure runtime is passed
+                });
+                const channel = container.get('channel');
+                await channel.handleAgentEvent(evt);
             });
         }
     }

package/package.json

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