@efengx/openclaw-channel-dragon 0.4.0 → 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/http/HttpComponent.d.ts

@@ -0,0 +1,13 @@
+import { IComponent } from "../../core/IComponent.js";
+export interface HttpOptions {
+    baseURL: string;
+    authToken?: string;
+    logger?: any;
+}
+export declare class HttpComponent implements IComponent {
+    private options;
+    constructor(options: HttpOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+}

package/dist/components/http/HttpComponent.js

@@ -0,0 +1,27 @@
+export class HttpComponent {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        this.options.logger?.info?.(`[Dragon-Channel] HttpComponent started for ${this.options.baseURL}`);
+    }
+    async stop() { }
+    async fetch(path, init) {
+        const url = `${this.options.baseURL}${path}`;
+        const headers = {
+            ...(init?.headers || {}),
+        };
+        if (this.options.authToken) {
+            headers['Authorization'] = `Bearer ${this.options.authToken}`;
+        }
+        const res = await fetch(url, {
+            ...init,
+            headers
+        });
+        if (!res.ok && res.status !== 404) {
+            this.options.logger?.warn?.(`[Dragon-Channel] HTTP Request failed: ${res.status} ${url}`);
+        }
+        return res;
+    }
+}

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

@@ -1,14 +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(options: {
+    constructor(http: HttpComponent, channel: ChannelComponent, options: {
         agentId: string;
-        orchestratorUrl: 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,8 +1,12 @@
 import * as http2 from "node:http2";
 export class PollingComponent {
+    http;
+    channel;
     options;
     pollInterval = null;
-    constructor(options) {
+    constructor(http, channel, options) {
+        this.http = http;
+        this.channel = channel;
         this.options = options;
     }
     async start() {
@@ -19,17 +23,16 @@ export class PollingComponent {
         }
     }
     async consumePendingMessages() {
-        const { agentId, orchestratorUrl, logger, deliverToOpenClaw } = this.options;
+        const { agentId, logger } = this.options;
         try {
-            const pollUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/poll`;
-            const res = await fetch(pollUrl);
+            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?.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);
                     }
                 }
             }
@@ -39,7 +42,7 @@ export class PollingComponent {
         }
     }
     async startLoop() {
-        const { agentId, orchestratorUrl, logger, abortSignal } = this.options;
+        const { logger, abortSignal } = this.options;
         let attempt = 0;
         while (!abortSignal.aborted) {
             try {
@@ -57,8 +60,8 @@ export class PollingComponent {
         }
     }
     async connectOnce() {
-        const { agentId, orchestratorUrl, logger, abortSignal, deliverToOpenClaw } = this.options;
-        const sseUrl = `${orchestratorUrl}/api/agents/events`;
+        const { agentId, logger, abortSignal } = this.options;
+        const ssePath = `/api/agents/events`;
         void this.consumePendingMessages();
         const handleSseText = async (chunkText, bufRef) => {
             bufRef.buf += chunkText;
@@ -78,19 +81,17 @@ 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) { }
             }
         };
-        const res = await fetch(sseUrl, {
+        const res = await this.http.fetch(ssePath, {
             signal: abortSignal,
             headers: { Accept: 'text/event-stream' },
         });
         if (res.status === 404) {
-            // HTTP/2 fallback logic (simplified for brevity here, original has full impl)
-            await this.connectHttp2(sseUrl, handleSseText);
             return;
         }
         if (!res.ok)

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

@@ -1,11 +1,9 @@
 import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
 export declare class TelemetryComponent implements IComponent {
-    private options;
-    constructor(options: {
-        agentId: string;
-        orchestratorUrl: string;
-        logger?: any;
-    });
+    private http;
+    private agentId;
+    constructor(http: HttpComponent, agentId: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     reportReply(payload: {

package/dist/components/telemetry/TelemetryComponent.js

@@ -1,28 +1,26 @@
 export class TelemetryComponent {
-    options;
-    constructor(options) {
-        this.options = options;
+    http;
+    agentId;
+    constructor(http, agentId) {
+        this.http = http;
+        this.agentId = agentId;
     }
     async start() { }
     async stop() { }
     async reportReply(payload) {
-        const { agentId, orchestratorUrl, logger } = this.options;
         try {
-            const replyUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/reply`;
-            await fetch(replyUrl, {
+            await this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(payload),
             });
         }
         catch (e) {
-            logger?.error?.(`dragon channel: failed to post reply to orchestrator: ${e.message}`);
+            // Error logged by HttpComponent
         }
     }
     async reportEvent(stream, data, ts) {
-        const { agentId, orchestratorUrl, logger } = this.options;
         try {
-            const telemetryUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/reply`;
             let telemetryPayload = null;
             if (stream === "thinking") {
                 telemetryPayload = { content: "", ts, metadata: { isTelemetry: true, reasoning_content: data, stream: "thinking" } };
@@ -43,15 +41,14 @@ export class TelemetryComponent {
                 };
             }
             if (telemetryPayload) {
-                void fetch(telemetryUrl, {
+                this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(telemetryPayload),
-                }).catch(e => logger?.error?.(`[Dragon] Failed to sync telemetry: ${e.message}`));
+                }).catch(() => { });
             }
         }
         catch (e) {
-            logger?.error?.(`[Dragon] Telemetry resolution failed: ${e.message}`);
         }
     }
 }

package/dist/index.js

@@ -5,16 +5,24 @@ import { ServiceContainer } from "./core/ServiceContainer.js";
 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 || "",
@@ -23,73 +31,20 @@ async function getOrCreateContainer(account, ctx) {
         gatewayToken: account.gatewayToken || "",
         logger
     }));
-    const telemetry = container.register('telemetry', new TelemetryComponent({
+    // 2. Channel Logic (Centralized)
+    const channel = container.register('channel', new ChannelComponent({
+        accountId: account.accountId,
         agentId: account.agentId,
-        orchestratorUrl: account.orchestratorUrl,
+        channelRuntime: ctx.channelRuntime,
+        cfg: ctx.cfg,
         logger
-    }));
-    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({
+    }, bridge, telemetry));
+    // 3. Polling Infrastructure
+    container.register('polling', new PollingComponent(http, channel, {
         agentId: account.agentId,
-        orchestratorUrl: account.orchestratorUrl,
         accountId: account.accountId,
         abortSignal: ctx.abortSignal,
-        logger,
-        deliverToOpenClaw
+        logger
     }));
     await container.startAll();
     containers.set(key, container);
@@ -110,6 +65,7 @@ const base = createChannelPluginBase({
                 accountId,
                 agentId: accountConfig.agentId || accountId,
                 orchestratorUrl: accountConfig.orchestratorUrl || "http://127.0.0.1:4000",
+                orchestratorAuthToken: accountConfig.orchestratorAuthToken || accountConfig.authToken,
                 bridgePort: accountConfig.bridgePort,
                 bridgeToken: accountConfig.bridgeToken,
                 gatewayPort: accountConfig.gatewayPort,
@@ -133,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);
             },
         }),
     },
@@ -165,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.0",
+  "version": "0.4.4",
   "description": "Dragon workbench channel for OpenClaw",
   "author": "feng xiang <ofengx@gmail.com>",
   "type": "module",