@efengx/openclaw-channel-dragon 0.3.7 → 0.4.3

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

@@ -0,0 +1,16 @@
+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: {
+        port: number;
+        token: string;
+        agentId: string;
+        gatewayPort: number;
+        gatewayToken: string;
+        logger?: any;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/components/bridge/BridgeComponent.js

@@ -0,0 +1,44 @@
+import { connectToDragonBridge } from "../../ws.js";
+export class BridgeComponent {
+    options;
+    client;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        const { port, token, agentId, gatewayPort, gatewayToken, logger } = this.options;
+        this.client = connectToDragonBridge({
+            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/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

@@ -0,0 +1,20 @@
+import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
+export declare class PollingComponent implements IComponent {
+    private http;
+    private options;
+    private pollInterval;
+    constructor(http: HttpComponent, 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>;
+    private consumePendingMessages;
+    private startLoop;
+    private connectOnce;
+    private connectHttp2;
+}

package/dist/components/sync/PollingComponent.js

@@ -0,0 +1,143 @@
+import * as http2 from "node:http2";
+export class PollingComponent {
+    http;
+    options;
+    pollInterval = null;
+    constructor(http, options) {
+        this.http = http;
+        this.options = options;
+    }
+    async start() {
+        this.startLoop();
+        // Safety: Periodic polling fallback every 60 seconds
+        this.pollInterval = setInterval(() => {
+            void this.consumePendingMessages();
+        }, 60_000);
+    }
+    async stop() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    async consumePendingMessages() {
+        const { agentId, logger, deliverToOpenClaw } = 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?.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);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            logger?.error?.(`dragon channel: [RECOVERY] Polling failed: ${e.message}`);
+        }
+    }
+    async startLoop() {
+        const { logger, abortSignal } = this.options;
+        let attempt = 0;
+        while (!abortSignal.aborted) {
+            try {
+                attempt += 1;
+                logger?.debug?.(`dragon channel: SSE connecting (attempt ${attempt})`);
+                await this.connectOnce();
+            }
+            catch (e) {
+                if (e?.name === 'AbortError')
+                    break;
+                logger?.error?.(`dragon channel: SSE loop error: ${e?.message || e}`);
+                const delayMs = Math.min(10_000, 500 + attempt * 500);
+                await new Promise((r) => setTimeout(r, delayMs));
+            }
+        }
+    }
+    async connectOnce() {
+        const { agentId, logger, abortSignal, deliverToOpenClaw } = this.options;
+        const ssePath = `/api/agents/events`;
+        void this.consumePendingMessages();
+        const handleSseText = async (chunkText, bufRef) => {
+            bufRef.buf += chunkText;
+            let idx;
+            while ((idx = bufRef.buf.indexOf('\n\n')) >= 0) {
+                const raw = bufRef.buf.slice(0, idx);
+                bufRef.buf = bufRef.buf.slice(idx + 2);
+                if (!raw.trim() || raw.trim().startsWith(':'))
+                    continue;
+                const dataLines = raw
+                    .split('\n')
+                    .filter((l) => l.startsWith('data:'))
+                    .map((l) => l.slice('data:'.length).trim());
+                if (!dataLines.length)
+                    continue;
+                const dataStr = dataLines.join('\n');
+                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);
+                    }
+                }
+                catch (e) { }
+            }
+        };
+        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)
+            // 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)
+            throw new Error(`Orchestrator SSE failed: ${res.status}`);
+        const body = res.body;
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        const bufRef = { buf: '' };
+        while (!abortSignal.aborted) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            await handleSseText(decoder.decode(value, { stream: true }), bufRef);
+        }
+    }
+    async connectHttp2(sseUrl, handleSseText) {
+        const { logger, abortSignal } = this.options;
+        const u = new URL(sseUrl);
+        const origin = `${u.protocol}//${u.host}`;
+        const pathWithQuery = `${u.pathname}${u.search || ''}`;
+        const bufRef = { buf: '' };
+        return new Promise((resolve, reject) => {
+            const session = http2.connect(origin);
+            let done = false;
+            const finish = (err) => {
+                if (done)
+                    return;
+                done = true;
+                try {
+                    session.close();
+                }
+                catch { }
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            };
+            abortSignal?.addEventListener?.('abort', () => finish({ name: 'AbortError' }));
+            session.on('error', (err) => finish(err));
+            const req = session.request({ ':method': 'GET', ':path': pathWithQuery, accept: 'text/event-stream' });
+            req.setEncoding('utf8');
+            req.on('data', (chunk) => handleSseText(chunk, bufRef));
+            req.on('end', () => finish());
+            req.end();
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
+export declare class TelemetryComponent implements IComponent {
+    private http;
+    private agentId;
+    constructor(http: HttpComponent, agentId: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reportReply(payload: {
+        content: string;
+        sessionId: string;
+        tool_calls?: any[];
+        reasoning_content?: string;
+    }): Promise<void>;
+    reportEvent(stream: string, data: any, ts: number): Promise<void>;
+}

package/dist/components/telemetry/TelemetryComponent.js

@@ -0,0 +1,54 @@
+export class TelemetryComponent {
+    http;
+    agentId;
+    constructor(http, agentId) {
+        this.http = http;
+        this.agentId = agentId;
+    }
+    async start() { }
+    async stop() { }
+    async reportReply(payload) {
+        try {
+            await this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(payload),
+            });
+        }
+        catch (e) {
+            // Error logged by HttpComponent
+        }
+    }
+    async reportEvent(stream, data, ts) {
+        try {
+            let telemetryPayload = null;
+            if (stream === "thinking") {
+                telemetryPayload = { content: "", ts, metadata: { isTelemetry: true, reasoning_content: data, stream: "thinking" } };
+            }
+            else if (stream === "tool" || stream === "item") {
+                const toolName = data?.name || data?.title || "unknown tool";
+                telemetryPayload = {
+                    content: data?.output ? `[Tool Result] ${toolName}` : `[Tool Call] ${toolName}...`,
+                    ts,
+                    metadata: {
+                        isTelemetry: true,
+                        toolName,
+                        toolInput: data?.input,
+                        toolOutput: data?.output || data?.summary,
+                        status: data?.output ? "completed" : "running",
+                        stream: "tool"
+                    }
+                };
+            }
+            if (telemetryPayload) {
+                this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(telemetryPayload),
+                }).catch(() => { });
+            }
+        }
+        catch (e) {
+        }
+    }
+}

package/dist/core/IComponent.d.ts

@@ -0,0 +1,4 @@
+export interface IComponent {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/core/IComponent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ServiceContainer.d.ts

@@ -0,0 +1,9 @@
+import { IComponent } from './IComponent.js';
+export declare class ServiceContainer {
+    private components;
+    private started;
+    register(name: string, component: IComponent): IComponent;
+    get<T extends IComponent>(name: string): T;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+}

package/dist/core/ServiceContainer.js

@@ -0,0 +1,30 @@
+export class ServiceContainer {
+    components = new Map();
+    started = false;
+    register(name, component) {
+        this.components.set(name, component);
+        return component;
+    }
+    get(name) {
+        const component = this.components.get(name);
+        if (!component)
+            throw new Error(`Component ${name} not found`);
+        return component;
+    }
+    async startAll() {
+        if (this.started)
+            return;
+        for (const [name, component] of this.components) {
+            await component.start();
+        }
+        this.started = true;
+    }
+    async stopAll() {
+        if (!this.started)
+            return;
+        for (const [name, component] of this.components) {
+            await component.stop();
+        }
+        this.started = false;
+    }
+}

package/dist/index.js

@@ -1,497 +1,155 @@
-import * as http2 from "node:http2";
-import { defineChannelPluginEntry, createChannelPluginBase, createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { defineChannelPluginEntry, createChatChannelPlugin, createChannelPluginBase } from "openclaw/plugin-sdk/core";
 import { createRawChannelSendResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
-// @ts-ignore
 import * as InfraRuntime from "openclaw/plugin-sdk/infra-runtime";
-// onAgentEvent is now accessed via runtime.events in registerFull
-// const onAgentEvent = (InfraRuntime as any).onAgentEvent;
-import { connectToDragonBridge } from "./ws.js";
-let bridgeClient;
-let cachedRuntime;
-let globalDispatcher;
-console.log("[Dragon] Plugin script is being evaluated by OpenClaw gateway...");
+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";
 const channelId = "dragon";
+let cachedRuntime;
+const containers = new Map();
 const processedMessageIds = new Set();
-async function ensureConnection(account, runtimeLogger) {
-    if (bridgeClient)
-        return;
-    const port = parseInt(account.bridgePort || "18799", 10);
-    const token = account.bridgeToken || "";
-    const client = connectToDragonBridge({
-        port,
-        token,
-        onConnected: () => {
-            runtimeLogger?.info?.("dragon channel: connected to dragon bridge");
-            client.sendJson({
-                type: "hello",
-                channel: channelId,
-                agentId: account.agentId,
-                port: parseInt(account.gatewayPort || "18789", 10),
-                token: account.gatewayToken || "",
-                version: "0.1.27",
-                timestamp: Date.now()
-            });
-        },
-        onDisconnected: () => {
-            runtimeLogger?.info?.("dragon channel: disconnected from dragon bridge");
-        },
-        onMessage: (msg) => {
-            const t = msg?.type;
-            if (t === "ping") {
-                client.sendJson({ type: "pong", t: Date.now() });
-                return;
-            }
-            // Instructions from Dragon Client UI
-            if (t === "hot_control") {
-                const { command } = msg;
-                runtimeLogger?.info?.(`dragon channel: received hot control: ${command}`);
-                // Model switching is now handled directly via local openclaw.json / CLI by Dragon Client
-            }
-        },
-    });
-    bridgeClient = client;
-    runtimeLogger?.info?.(`dragon channel: bridge client initialized on port ${port}`);
-}
-async function startPolling(ctx) {
-    const account = ctx.account;
-    const agentId = account.agentId;
-    const orchestratorUrl = account.orchestratorUrl;
+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;
-    if (!agentId) {
-        logger?.error?.("dragon channel: agentId is missing in config, skipping polling");
-        return;
-    }
-    logger?.info?.(`dragon channel: starting SSE loop for agent ${agentId} at ${orchestratorUrl}`);
-    const replyDispatcher = ctx.channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher;
-    if (typeof replyDispatcher !== 'function') {
-        logger?.error?.("dragon channel: could not find reply.dispatchReplyWithBufferedBlockDispatcher in ctx.channelRuntime");
-        if (ctx.channelRuntime) {
-            logger?.info?.(`dragon channel: channelRuntime keys: ${Object.keys(ctx.channelRuntime).join(', ')}`);
-        }
-        return;
-    }
+    const container = new ServiceContainer();
+    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 bridge = container.register('bridge', new BridgeComponent({
+        port: parseInt(account.bridgePort || "18799", 10),
+        token: account.bridgeToken || "",
+        agentId: account.agentId,
+        gatewayPort: parseInt(account.gatewayPort || "18789", 10),
+        gatewayToken: account.gatewayToken || "",
+        logger
+    }));
+    const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
     const deliverToOpenClaw = async (content, sessionId = 'default', modelId, attachments, messageId) => {
-        const msg = String(content || '').trim();
-        if (!msg && (!attachments || attachments.length === 0))
-            return;
-        // Deduplication check
-        if (messageId && processedMessageIds.has(messageId)) {
+        if (messageId && processedMessageIds.has(messageId))
             return;
-        }
         if (messageId) {
             processedMessageIds.add(messageId);
-            // Keep cache size manageable
             if (processedMessageIds.size > 1000) {
                 const first = processedMessageIds.values().next().value;
                 if (first !== undefined)
                     processedMessageIds.delete(first);
             }
         }
-        // sessionKey format: channel:agentId:direct:peerId
-        // peerId can be the sessionId for multi-session support
+        const replyDispatcher = ctx.channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+        if (typeof replyDispatcher !== 'function')
+            return;
         const sessionKey = `dragon:${account.agentId}:direct:${sessionId}`;
-        logger?.info?.(`dragon channel: [LATENCY_CHECK] Dispatching to OpenClaw core... Session=${sessionId}`);
         await replyDispatcher({
             ctx: {
-                Body: msg,
-                BodyForAgent: msg,
-                BodyForCommands: msg,
+                Body: content,
                 From: sessionId === 'default' ? "workbench-user" : `workbench-user-${sessionId}`,
-                SenderName: "Workbench User",
-                SenderId: "workbench-user",
                 To: account.agentId,
                 ChatType: "direct",
                 Provider: channelId,
                 ChannelId: channelId,
-                Surface: "dragon-workbench",
                 AccountId: account.accountId,
                 SessionKey: sessionKey,
-                CommandSource: "native",
-                CommandAuthorized: true,
                 Timestamp: Date.now(),
                 Model: modelId,
-                Attachments: attachments, // Pass raw attachments for reference
+                Attachments: attachments,
             },
-            // Building OpenClaw-native multi-modal blocks if images are present
-            customBlocks: (attachments || [])
-                .filter((a) => a.type === 'image')
-                .map((a) => ({
-                kind: 'image',
-                data: a.data, // Should be base64 or URL
-                mime: a.mime || 'image/png'
-            })),
             cfg: ctx.cfg,
             dispatcherOptions: {
                 deliver: async (payload) => {
                     const text = payload?.text || "";
-                    const toolCalls = payload?.tool_calls || [];
-                    const reasoning = payload?.reasoning_content || "";
-                    if (!text && !toolCalls.length && !reasoning)
+                    if (!text && !payload?.tool_calls?.length)
                         return;
-                    logger?.info?.(`dragon channel: deliver callback [Session: ${sessionId}]. textLen=${text.length}, toolCalls=${toolCalls.length}, hasReasoning=${!!reasoning}`);
-                    // 1. Send to local bridge (WebSocket) for real-time UI
-                    if (bridgeClient) {
-                        bridgeClient.sendJson({
+                    if (bridge.client) {
+                        bridge.client.sendJson({
                             type: "outbound_text",
                             channel: channelId,
-                            messageId: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
                             text,
-                            tool_calls: toolCalls,
-                            reasoning_content: reasoning,
-                            route: {
-                                agentId: account.agentId,
-                                accountId: account.accountId,
-                                peer: { kind: "direct", id: sessionId },
-                                sessionKey: sessionKey,
-                            },
+                            tool_calls: payload?.tool_calls,
+                            reasoning_content: payload?.reasoning_content,
+                            route: { agentId: account.agentId, accountId: account.accountId, peer: { kind: "direct", id: sessionId }, sessionKey },
                         });
                     }
-                    // 2. Also send to Orchestrator (HTTP POST) for trajectory tracking
-                    try {
-                        const replyUrl = `${orchestratorUrl}/api/agents/${account.agentId}/messages/reply`;
-                        await fetch(replyUrl, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({
-                                content: text,
-                                sessionId,
-                                tool_calls: toolCalls,
-                                reasoning_content: reasoning,
-                            }),
-                        });
-                    }
-                    catch (e) {
-                        logger?.error?.(`dragon channel: failed to post deliver-reply to orchestrator: ${e.message}`);
-                    }
+                    await telemetry.reportReply({
+                        content: text,
+                        sessionId,
+                        tool_calls: payload?.tool_calls,
+                        reasoning_content: payload?.reasoning_content,
+                    });
                 }
             }
         });
     };
-    const consumePendingMessages = async () => {
-        try {
-            const pollUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/poll`;
-            const res = await fetch(pollUrl);
-            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 // Pass DB ID for deduplication
-                        );
-                    }
-                }
-            }
-        }
-        catch (e) {
-            logger?.error?.(`dragon channel: [RECOVERY] Polling failed: ${e.message}`);
-        }
-    };
-    const connectOnce = async () => {
-        const sseUrl = `${orchestratorUrl}/api/agents/events`;
-        // Recovery: Catch up on any messages missed during downtime
-        void consumePendingMessages();
-        const handleSseText = async (chunkText, bufRef) => {
-            // Diagnostic: log first chunk of SSE if it's not a heartbeat comment
-            const isHeartbeat = chunkText.trim().startsWith(':');
-            if (!bufRef.buf && chunkText.trim() && !isHeartbeat) {
-                logger?.info?.(`dragon channel: SSE received first message chunk (len=${chunkText.length})`);
-            }
-            bufRef.buf += chunkText;
-            let idx;
-            while ((idx = bufRef.buf.indexOf('\n\n')) >= 0) {
-                const raw = bufRef.buf.slice(0, idx);
-                bufRef.buf = bufRef.buf.slice(idx + 2);
-                if (!raw.trim() || raw.trim().startsWith(':'))
-                    continue;
-                const dataLines = raw
-                    .split('\n')
-                    .filter((l) => typeof l === 'string' && l.startsWith('data:'))
-                    .map((l) => l.slice('data:'.length).trim());
-                if (!dataLines.length)
-                    continue;
-                const dataStr = dataLines.join('\n');
-                try {
-                    const evt = JSON.parse(dataStr);
-                    if (!evt)
-                        continue;
-                    if (evt.type === 'WORKBENCH_MESSAGE') {
-                        const sendTs = evt.payload?.ts || 0;
-                        const latency = sendTs ? (Date.now() - sendTs) : 'unknown';
-                        // Critical Log: Confirm receipt of SSE message
-                        logger?.info?.(`dragon channel: [SSE] RECEIVED WORKBENCH_MESSAGE. agentId=${evt.agentId} (Current Config: ${agentId}), sessionId=${evt.payload?.sessionId}, latency=${latency}ms`);
-                        if (evt.agentId !== agentId) {
-                            logger?.warn?.(`dragon channel: [SSE] ID Mismatch! Event ID "${evt.agentId}" !== Config ID "${agentId}". Ignoring message.`);
-                            continue;
-                        }
-                        logger?.info?.(`dragon channel: [DEBUG] Received WORKBENCH_MESSAGE via SSE. AgentID=${evt.agentId}, ContentLen=${evt.payload?.content?.length}, Latency=${latency}ms`);
-                        logger?.info?.(`dragon channel: [DEBUG] Payload Content: "${evt.payload?.content?.substring(0, 500)}"`);
-                        logger?.info?.(`dragon channel: [DEBUG] Current Account Config: ${JSON.stringify(account)}`);
-                        await deliverToOpenClaw(String(evt?.payload?.content || ''), String(evt?.payload?.sessionId || 'default'), evt?.payload?.modelId, evt?.payload?.attachments, evt?.payload?.id // Pass DB ID for deduplication
-                        );
-                    }
-                    else if (evt.type === 'FETCH_HISTORY') {
-                        const { sessionId } = evt.payload;
-                        logger?.info?.(`dragon channel: [DEBUG] Received FETCH_HISTORY for session ${sessionId}`);
-                        try {
-                            // Retrieve history from OpenClaw core via channelRuntime
-                            // sessionKey format: dragon:agentId:direct:sessionId
-                            const sessionKey = `dragon:${account.agentId}:direct:${sessionId}`;
-                            // Standard OpenClaw 2026.4.12+ history retrieval API
-                            const history = await ctx.channelRuntime?.history?.getMessages?.({
-                                sessionKey,
-                                limit: 50
-                            }) || [];
-                            logger?.info?.(`dragon channel: [DEBUG] Retrieved ${history.length} messages from OpenClaw core for sync.`);
-                            // Post back to orchestrator
-                            const syncUrl = `${orchestratorUrl}/api/agents/${account.agentId}/messages/sync-context`;
-                            await fetch(syncUrl, {
-                                method: "POST",
-                                headers: { "Content-Type": "application/json" },
-                                body: JSON.stringify({
-                                    sessionId,
-                                    messages: history.map((m) => ({
-                                        role: m.role || (m.from === 'workbench-user' ? 'user' : 'assistant'),
-                                        content: m.body || m.text || '',
-                                        ts: m.timestamp || Date.now()
-                                    }))
-                                }),
-                            });
-                            logger?.info?.(`dragon channel: [DEBUG] Successfully synced ${history.length} messages back to orchestrator.`);
-                        }
-                        catch (e) {
-                            logger?.error?.(`dragon channel: [ERROR] FETCH_HISTORY failed: ${e.message}`);
-                        }
-                    }
-                }
-                catch (e) {
-                    logger?.error?.(`dragon channel: failed to parse SSE data: ${e?.message || e}`, e?.stack);
-                }
-            }
-        };
-        // Diagnostic: log connection attempt
-        logger?.info?.(`dragon channel: connecting to SSE (no-env-diag)...`);
-        // First try: standard fetch (HTTP/1.1 in Node).
-        const res = await fetch(sseUrl, {
-            signal: ctx.abortSignal,
-            headers: { Accept: 'text/event-stream' },
-        });
-        logger?.info?.(`dragon channel: fetch(${sseUrl}) status: ${res.status} ${res.statusText}`);
-        // Some reverse proxy stacks may only route this endpoint over HTTP/2.
-        // If we see a 404 from the edge, fall back to a native HTTP/2 client.
-        if (res.status === 404) {
-            const u = new URL(sseUrl);
-            const origin = `${u.protocol}//${u.host}`;
-            const pathWithQuery = `${u.pathname}${u.search || ''}`;
-            const bufRef = { buf: '' };
-            const decoder = new TextDecoder();
-            await new Promise((resolve, reject) => {
-                const session = http2.connect(origin);
-                let done = false;
-                const finish = (err) => {
-                    if (done)
-                        return;
-                    done = true;
-                    try {
-                        session.close();
-                    }
-                    catch { }
-                    if (err)
-                        reject(err);
-                    else
-                        resolve();
-                };
-                const onAbort = () => finish({ name: 'AbortError' });
-                try {
-                    ctx.abortSignal?.addEventListener?.('abort', onAbort);
-                }
-                catch { }
-                session.on('error', (err) => finish(err));
-                const req = session.request({
-                    ':method': 'GET',
-                    ':path': pathWithQuery,
-                    accept: 'text/event-stream',
-                });
-                req.setEncoding('utf8');
-                req.on('response', (headers) => {
-                    const status = Number(headers[':status'] || 0);
-                    if (status !== 200) {
-                        finish(new Error(`Orchestrator SSE failed: ${status}`));
-                        return;
-                    }
-                });
-                req.on('data', async (chunk) => {
-                    try {
-                        await handleSseText(chunk, bufRef);
-                    }
-                    catch (e) {
-                        finish(e);
-                    }
-                });
-                req.on('end', () => finish());
-                req.on('close', () => finish());
-                req.end();
-            });
-            return;
-        }
-        if (!res.ok)
-            throw new Error(`Orchestrator SSE failed: ${res.status}`);
-        const body = res.body;
-        if (!body || typeof body.getReader !== 'function') {
-            throw new Error('Orchestrator SSE: response body not readable');
-        }
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        const bufRef = { buf: '' };
-        while (!ctx.abortSignal.aborted) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            await handleSseText(decoder.decode(value, { stream: true }), bufRef);
-        }
-    };
-    let attempt = 0;
-    // Safety: Periodic polling fallback every 60 seconds
-    const pollInterval = setInterval(() => {
-        void consumePendingMessages();
-    }, 60_000);
-    while (!ctx.abortSignal.aborted) {
-        try {
-            attempt += 1;
-            logger?.info?.(`dragon channel: SSE connecting (attempt ${attempt})`);
-            await connectOnce();
-        }
-        catch (e) {
-            if (e?.name === 'AbortError')
-                break;
-            logger?.error?.(`dragon channel: SSE loop error: ${e?.message || e}`, e?.stack);
-            // reconnect delay (cap 10s)
-            const delayMs = Math.min(10_000, 500 + attempt * 500);
-            await new Promise((r) => setTimeout(r, delayMs));
-        }
-    }
-    clearInterval(pollInterval);
-    logger?.info?.({ agentId }, "dragon channel: SSE loop terminated");
+    container.register('polling', new PollingComponent(http, {
+        agentId: account.agentId,
+        accountId: account.accountId,
+        abortSignal: ctx.abortSignal,
+        logger,
+        deliverToOpenClaw
+    }));
+    await container.startAll();
+    containers.set(key, container);
+    return container;
 }
 const base = createChannelPluginBase({
     id: channelId,
-    meta: {
-        label: "Dragon Workbench",
-        selectionLabel: "Dragon Workbench",
-        docsPath: "https://github.com/efengx/dragon",
-        blurb: "Real-time communication bridge between OpenClaw and Dragon Workbench.",
-    },
-    capabilities: {
-        chatTypes: ["direct", "group"],
-    },
+    meta: { label: "Dragon Workbench", selectionLabel: "Dragon Workbench" },
+    capabilities: { chatTypes: ["direct", "group"] },
     setup: {
-        async validate(_ctx) {
-            return { ok: true };
-        },
-        async finalize(ctx) {
-            const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
-            await ensureConnection(ctx.account, logger);
-            return { ok: true };
-        },
+        validate: async () => ({ ok: true }),
+        finalize: async () => ({ ok: true })
     },
     config: {
-        listAccountIds: (cfg) => {
-            const channelConfig = cfg.channels?.[channelId];
-            if (!channelConfig?.accounts)
-                return ["default"];
-            return Object.keys(channelConfig.accounts);
-        },
         resolveAccount: (cfg, accountId = "default") => {
             const accountConfig = cfg.channels?.[channelId]?.accounts?.[accountId] || {};
-            const agentId = accountConfig.agentId || accountId;
-            const orchestratorUrl = accountConfig.orchestratorUrl || "http://127.0.0.1:4000";
-            const bridgePort = accountConfig.bridgePort || "18799";
-            const bridgeToken = accountConfig.bridgeToken || "";
-            const gatewayPort = accountConfig.gatewayPort || "18789";
-            const gatewayToken = accountConfig.gatewayToken || "";
-            const now = Date.now();
-            const lastLog = global.lastDragonAccountLogTime?.[accountId] || 0;
-            if (now - lastLog > 10 * 60 * 1000) {
-                console.log(`[Dragon] Resolved account ${accountId}: agentId=${agentId}, url=${orchestratorUrl}`);
-                if (!global.lastDragonAccountLogTime)
-                    global.lastDragonAccountLogTime = {};
-                global.lastDragonAccountLogTime[accountId] = now;
-            }
             return {
                 accountId,
-                agentId,
-                orchestratorUrl,
-                bridgePort,
-                bridgeToken,
-                gatewayPort,
-                gatewayToken,
+                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,
+                gatewayToken: accountConfig.gatewayToken,
             };
         },
     },
 });
-const gateway = {
-    startAccount: async (ctx) => {
-        const account = ctx.account;
-        const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
-        logger?.info?.(`dragon channel: starting account gateway for agent ${account.agentId} at ${account.orchestratorUrl}`);
-        // Background poll loop - AWAIT it to keep the account active in the gateway
-        try {
-            await startPolling(ctx);
-        }
-        catch (err) {
-            logger?.error?.(`dragon channel: fatal poll error: ${err.message}`, err.stack);
-        }
-    },
-};
 const plugin = createChatChannelPlugin({
     base: {
         ...base,
-        gateway,
+        capabilities: { chatTypes: ["direct", "group"] },
+        gateway: {
+            startAccount: async (ctx) => {
+                const account = base.config.resolveAccount(ctx.cfg, ctx.accountId);
+                await getOrCreateContainer(account, ctx);
+            }
+        },
     },
     outbound: {
         attachedResults: createRawChannelSendResultAdapter({
             channel: channelId,
             async sendText(ctx) {
-                const text = ctx?.text ?? ctx?.payload?.text ?? "";
-                const messageId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-                const account = ctx.account;
-                const agentId = account?.agentId;
-                const orchestratorUrl = account?.orchestratorUrl;
-                const sessionKey = ctx?.ctx?.SessionKey ?? ctx?.sessionKey;
-                const logger = cachedRuntime?.logger ?? cachedRuntime?.log;
-                logger?.info?.(`dragon channel: sendText invoked. agentId=${agentId}, orchestratorUrl=${orchestratorUrl}, text="${text.substring(0, 30)}..."`);
-                // 1. Send to local bridge (WebSocket)
-                if (bridgeClient) {
-                    bridgeClient.sendJson({
+                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,
-                        messageId,
                         text,
-                        route: {
-                            agentId,
-                            accountId: ctx?.accountId,
-                            peer: ctx?.peer,
-                            sessionKey,
-                        },
+                        route: { agentId: account.agentId, accountId: account.accountId, peer: ctx?.peer, sessionKey: ctx?.ctx?.SessionKey },
                     });
                 }
-                // 2. Send to Orchestrator (HTTP POST)
-                if (agentId && orchestratorUrl) {
-                    try {
-                        const replyUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/reply`;
-                        logger?.info?.(`dragon channel: posting reply to ${replyUrl}`);
-                        const res = await fetch(replyUrl, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ content: text }),
-                        });
-                        logger?.info?.(`dragon channel: reply post status: ${res.status}`);
-                    }
-                    catch (e) {
-                        logger?.error?.(`dragon channel: failed to post reply to orchestrator: ${e.message}`);
-                    }
-                }
-                return { ok: true, messageId };
+                await telemetry.reportReply({ content: text, sessionId: ctx?.peer?.id || 'default' });
+                return { ok: true, messageId: Date.now().toString() };
             },
         }),
     },
@@ -500,145 +158,35 @@ const entry = defineChannelPluginEntry({
     id: channelId,
     name: "Dragon Workbench Channel",
     description: "Connect OpenClaw to the Dragon agent-client workbench chat.",
-    configSchema: {
-        type: "object",
-        properties: {
-            enabled: { type: "boolean" },
-            activated: { type: "boolean" }
-        }
-    },
     plugin,
     registerFull(api) {
-        console.log("[Dragon] registerFull() hook called by OpenClaw gateway");
         cachedRuntime = api.runtime;
-        // Subscribe to real-time events (thinking, tool calls, etc.)
-        // v2026.4.12+ : runtime.events.onAgentEvent
         const agentEventHandler = api.runtime?.events?.onAgentEvent || InfraRuntime.onAgentEvent;
         if (typeof agentEventHandler === 'function') {
-            agentEventHandler((evt) => {
-                const logger = cachedRuntime?.logger ?? cachedRuntime?.log;
-                // Filter by sessionKey to ensure we only send events belonging to this channel
+            agentEventHandler(async (evt) => {
                 const sessionKey = evt.sessionKey;
                 if (!sessionKey || !sessionKey.startsWith(`${channelId}:`))
                     return;
-                // Extract details
-                const { stream, data, runId } = evt;
-                // Debug log for troubleshooting missing tool calls
-                logger?.debug?.(`[Dragon] Received agent event: stream=${stream}, runId=${runId}, dataKeys=${Object.keys(data || {})}`);
-                // We care about certain streams for the UI "Thinking" status
-                if (stream === "thinking" || stream === "tool" || stream === "item" || stream === "plan") {
-                    // Extract agentId from sessionKey "dragon:agent-xxx:..."
-                    const agentId = sessionKey.split(':')[1] || "";
-                    const accountId = sessionKey.split(':')[2] || "default";
-                    const logger = cachedRuntime?.logger ?? cachedRuntime?.log;
-                    // 1. Report to Orchestrator (Async) for Web UI / Trajectory
-                    try {
-                        const cfg = api.runtime?.cfg;
-                        if (cfg) {
-                            const account = entry.resolveAccount(cfg, accountId);
-                            if (account?.orchestratorUrl) {
-                                const telemetryUrl = `${account.orchestratorUrl}/api/agents/${agentId}/messages/reply`;
-                                // Decide what to send to orchestrator
-                                let telemetryPayload = null;
-                                if (stream === "thinking") {
-                                    telemetryPayload = {
-                                        content: "", // Content can be empty for pure reasoning update
-                                        ts: evt.ts,
-                                        metadata: { isTelemetry: true, reasoning_content: data, stream: "thinking" }
-                                    };
-                                }
-                                else if (stream === "tool" || (stream === "item" && data?.kind === "tool")) {
-                                    const toolName = data?.name || data?.title || "unknown tool";
-                                    if (data?.status === "completed" || data?.phase === "end" || data?.output) {
-                                        telemetryPayload = {
-                                            content: `[Tool Result] ${toolName}`,
-                                            ts: evt.ts,
-                                            metadata: {
-                                                isTelemetry: true,
-                                                toolName: toolName,
-                                                toolInput: data?.input,
-                                                toolOutput: data?.output || data?.summary,
-                                                toolCallId: data?.toolCallId || runId,
-                                                status: "completed",
-                                                stream: "tool"
-                                            }
-                                        };
-                                    }
-                                    else {
-                                        // Initial tool call info
-                                        telemetryPayload = {
-                                            content: `[Tool Call] ${toolName}...`,
-                                            ts: evt.ts,
-                                            metadata: {
-                                                isTelemetry: true,
-                                                toolName: toolName,
-                                                toolInput: data?.input,
-                                                status: "running",
-                                                stream: "tool"
-                                            }
-                                        };
-                                    }
-                                }
-                                else if (stream === "plan") {
-                                    telemetryPayload = {
-                                        content: data?.explanation || `Plan Update: ${data?.title}`,
-                                        ts: evt.ts,
-                                        metadata: {
-                                            isTelemetry: true,
-                                            planTitle: data?.title,
-                                            planSteps: data?.steps,
-                                            stream: "plan"
-                                        }
-                                    };
-                                }
-                                if (telemetryPayload) {
-                                    void fetch(telemetryUrl, {
-                                        method: "POST",
-                                        headers: { "Content-Type": "application/json" },
-                                        body: JSON.stringify(telemetryPayload),
-                                    }).catch(e => logger?.error?.(`[Dragon] Failed to sync telemetry: ${e.message}`));
-                                }
-                            }
-                        }
-                    }
-                    catch (e) {
-                        logger?.error?.(`[Dragon] Telemetry resolution failed: ${e.message}`);
-                    }
-                    // 2. Also send to local bridge (WebSocket)
-                    if (bridgeClient) {
-                        bridgeClient.sendJson({
-                            type: "agent_event",
-                            channel: channelId,
-                            agentId,
-                            runId,
-                            stream,
-                            data,
-                            sessionKey
-                        });
-                    }
+                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);
             });
         }
-        else {
-            console.warn("[Dragon] onAgentEvent not found in runtime. Real-time status updates may be disabled.");
-        }
-        api.registerGatewayMethod("dragon.activate", async ({ respond, payload }) => {
-            const logger = cachedRuntime?.logger ?? cachedRuntime?.log ?? cachedRuntime;
-            // Resolve account for activation
-            const accountId = payload?.accountId || "default";
-            const account = entry.resolveAccount(api.runtime.cfg, accountId);
-            await ensureConnection(account, logger);
-            respond(true, { active: true });
-        });
-        api.registerGatewayMethod("dragon.status", async ({ respond }) => {
-            respond(true, {
-                active: !!bridgeClient,
-                connected: !!bridgeClient,
-            });
-        });
-    },
-    setRuntime: (runtime) => {
-        cachedRuntime = runtime;
-    },
+    }
 });
 export default entry;

package/package.json

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