@efengx/openclaw-channel-dragon 0.5.32 → 0.5.33

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

@@ -16,6 +16,8 @@ export declare class ChannelComponent implements IComponent {
     start(): Promise<void>;
     stop(): Promise<void>;
     private normalizeSessionSegment;
+    private encodeWorkbenchTarget;
+    private decodeWorkbenchTarget;
     private resolveOpenClawAgentId;
     private buildOpenClawSessionKey;
     private resolveWorkbenchSessionIdFromOpenClawSessionKey;
@@ -27,6 +29,12 @@ export declare class ChannelComponent implements IComponent {
     handleOutboundText: (ctx: any) => Promise<{
         ok: boolean;
         messageId: string;
+        error: any;
+    } | {
+        ok: boolean;
+        messageId: string;
+        error?: undefined;
     }>;
+    reportTargetProtocolError: (message: string, rawTarget: unknown) => Promise<void>;
     handleAgentEvent: (evt: any) => Promise<void>;
 }

package/dist/components/channel/ChannelComponent.js

@@ -1,5 +1,6 @@
 import { dragonChannelPluginVersion } from "../../version.js";
 const channelId = "dragon";
+const workbenchTargetPrefix = "dragon-workbench:";
 export class ChannelComponent {
     options;
     telemetry;
@@ -20,6 +21,21 @@ export class ChannelComponent {
             .slice(0, 64);
         return normalized || fallback;
     }
+    encodeWorkbenchTarget(sessionId) {
+        const value = String(sessionId || 'default').trim() || 'default';
+        return `${workbenchTargetPrefix}${value}`;
+    }
+    decodeWorkbenchTarget(value) {
+        const target = String(value || '').trim();
+        if (!target.startsWith(workbenchTargetPrefix)) {
+            throw new Error(`Invalid dragon workbench target "${target || '<empty>'}"; expected "${workbenchTargetPrefix}<sessionId>"`);
+        }
+        const sessionId = target.slice(workbenchTargetPrefix.length).trim();
+        if (!sessionId) {
+            throw new Error(`Invalid dragon workbench target "${target}"; sessionId is empty`);
+        }
+        return sessionId;
+    }
     resolveOpenClawAgentId() {
         const agents = this.options.cfg?.agents?.list;
         if (Array.isArray(agents)) {
@@ -136,7 +152,7 @@ export class ChannelComponent {
                     ctx: {
                         Body: content,
                         From: sessionId === 'default' ? "workbench-user" : `workbench-user-${sessionId}`,
-                        To: sessionId === 'default' ? "dragon-workbench" : `dragon-workbench-${sessionId}`,
+                        To: this.encodeWorkbenchTarget(sessionId),
                         ChatType: "direct",
                         Provider: channelId,
                         ChannelId: channelId,
@@ -355,10 +371,34 @@ export class ChannelComponent {
     handleOutboundText = async (ctx) => {
         const text = ctx?.text || "";
         const { logger } = this.options;
-        logger?.info?.(`[dragon channels][Dragon Plugin] Outbound Text (Action): "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`);
-        await this.telemetry.reportReply({ content: text, sessionId: ctx?.peer?.id || "default", source: "channel_outbound" });
+        let sessionId;
+        try {
+            sessionId = this.decodeWorkbenchTarget(ctx?.peer?.id);
+        }
+        catch (error) {
+            const message = error?.message || String(error);
+            logger?.error?.(`[dragon channels][Dragon Plugin] outbound target protocol error: ${message}`);
+            await this.reportTargetProtocolError(message, ctx?.peer?.id);
+            return { ok: false, messageId: Date.now().toString(), error: message };
+        }
+        logger?.info?.(`[dragon channels][Dragon Plugin] Outbound Text (Action): "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}" [Session: ${sessionId}] [RawPeer: ${ctx?.peer?.id || 'none'}]`);
+        await this.telemetry.reportReply({ content: text, sessionId, source: "channel_outbound" });
         return { ok: true, messageId: Date.now().toString() };
     };
+    reportTargetProtocolError = async (message, rawTarget) => {
+        const content = [
+            '⚠️ Dragon channel target 协议错误。',
+            `错误信息：${message}`,
+            `收到的 target：${String(rawTarget || '<empty>')}`,
+            `期望格式：${workbenchTargetPrefix}<sessionId>`,
+        ].join('\n');
+        await this.telemetry.reportReply({
+            content,
+            sessionId: 'default',
+            source: 'target_protocol_error',
+            msgId: `dragon_target_error_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        });
+    };
     handleAgentEvent = async (evt) => {
         const sessionId = evt?.sessionId ||
             this.resolveWorkbenchSessionIdFromOpenClawSessionKey(evt?.sessionKey);

package/dist/components/sync/SseComponent.js

@@ -56,7 +56,13 @@ export class SseComponent {
         if (!this.shouldReconnect)
             return;
         const { agentId, logger } = this.options;
-        const url = `${this.http.options.baseURL}/api/agents/events`;
+        const params = new URLSearchParams({
+            client: 'dragon-channel',
+            agentId,
+            accountId: this.options.accountId,
+            version: this.options.version,
+        });
+        const url = `${this.http.options.baseURL}/api/agents/events?${params.toString()}`;
         const connectionId = `${Date.now()}-${++this.connectionSeq}`;
         logger?.info?.(`[dragon channels][SSE] connect start: connection=${connectionId}, attempt=${this.reconnectAttempts + 1}, version=${this.options.version}, url=${url}, agent=${agentId}, account=${this.options.accountId}`);
         try {

package/dist/index.js

@@ -8,6 +8,7 @@ import { ChannelComponent } from "./components/channel/ChannelComponent.js";
 import { SseComponent } from "./components/sync/SseComponent.js";
 import { dragonChannelPluginVersion } from "./version.js";
 const channelId = "dragon";
+const workbenchTargetPrefix = "dragon-workbench:";
 let cachedRuntime;
 const containers = new Map();
 function isDragonSessionKey(sessionKey) {
@@ -22,6 +23,21 @@ function resolveAccountIdFromSessionKey(sessionKey) {
     }
     return "default";
 }
+function encodeWorkbenchTarget(sessionId) {
+    const value = String(sessionId || "default").trim() || "default";
+    return `${workbenchTargetPrefix}${value}`;
+}
+function decodeWorkbenchTarget(raw) {
+    const target = String(raw || "").trim();
+    if (!target.startsWith(workbenchTargetPrefix)) {
+        throw new Error(`Invalid dragon workbench target "${target || "<empty>"}"; expected "${workbenchTargetPrefix}<sessionId>"`);
+    }
+    const sessionId = target.slice(workbenchTargetPrefix.length).trim();
+    if (!sessionId) {
+        throw new Error(`Invalid dragon workbench target "${target}"; sessionId is empty`);
+    }
+    return sessionId;
+}
 function containerKey(account) {
     return `${account.accountId}:${account.agentId}:${account.orchestratorUrl}`;
 }
@@ -161,25 +177,13 @@ const plugin = createChatChannelPlugin({
             }
         },
         messaging: {
-            targetPrefixes: ["dragon-workbench", "dragon"],
+            targetPrefixes: [workbenchTargetPrefix],
             normalizeTarget: (raw) => {
-                let target = raw || "";
-                for (const prefix of ["dragon-workbench-", "dragon-workbench:", "dragon-", "dragon:"]) {
-                    if (target.startsWith(prefix)) {
-                        target = target.substring(prefix.length);
-                    }
-                }
-                return target ? `dragon-workbench-${target}` : "";
+                return encodeWorkbenchTarget(decodeWorkbenchTarget(raw));
             },
             resolveOutboundSessionRoute: (params) => {
-                let target = params.target || "";
-                for (const prefix of ["dragon-workbench-", "dragon-workbench:", "dragon-", "dragon:"]) {
-                    if (target.startsWith(prefix)) {
-                        target = target.substring(prefix.length);
-                    }
-                }
-                if (!target)
-                    return null;
+                const sessionId = decodeWorkbenchTarget(params.target);
+                const target = encodeWorkbenchTarget(sessionId);
                 return buildChannelOutboundSessionRoute({
                     cfg: params.cfg,
                     agentId: params.agentId,
@@ -187,27 +191,22 @@ const plugin = createChatChannelPlugin({
                     accountId: params.accountId,
                     peer: {
                         kind: "direct",
-                        id: target
+                        id: sessionId
                     },
                     chatType: "direct",
-                    from: `dragon-workbench-${target}`,
-                    to: `dragon-workbench-${target}`
+                    from: target,
+                    to: target
                 });
             },
             targetResolver: {
                 looksLikeId: (raw) => {
-                    return raw.startsWith("dragon-workbench-") || raw.startsWith("session-");
+                    return raw.startsWith(workbenchTargetPrefix);
                 },
-                hint: "<sessionId>",
+                hint: "dragon-workbench:<sessionId>",
                 resolveTarget: async ({ input }) => {
-                    let sessionId = input;
-                    for (const prefix of ["dragon-workbench-", "dragon-workbench:", "dragon-", "dragon:"]) {
-                        if (sessionId.startsWith(prefix)) {
-                            sessionId = sessionId.substring(prefix.length);
-                        }
-                    }
+                    const sessionId = decodeWorkbenchTarget(input);
                     return {
-                        to: `dragon-workbench-${sessionId}`,
+                        to: encodeWorkbenchTarget(sessionId),
                         kind: "direct",
                         display: `Dragon Workbench User (${sessionId})`,
                         source: "normalized"
@@ -227,15 +226,28 @@ const plugin = createChatChannelPlugin({
                     const account = base.config.resolveAccount(cfg, accountId);
                     const container = await getOrCreateContainer(account, ctx);
                     const channel = container.get('channel');
-                    let target = params.to || params.target || ctx.toolContext?.currentChannelId || "default";
-                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolution input: ${target}`);
-                    for (const prefix of ["dragon-workbench-", "dragon-workbench:", "dragon-", "dragon:"]) {
-                        if (target.startsWith(prefix)) {
-                            target = target.substring(prefix.length);
-                        }
+                    const rawTarget = params.to || params.target || ctx.toolContext?.currentChannelId || "default";
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolution input: ${rawTarget}`);
+                    let sessionId;
+                    let target;
+                    try {
+                        sessionId = decodeWorkbenchTarget(rawTarget);
+                        target = encodeWorkbenchTarget(sessionId);
+                    }
+                    catch (error) {
+                        const message = error?.message || String(error);
+                        logger?.error?.(`[dragon channels][Dragon Plugin] handleAction target protocol error: ${message}`);
+                        await channel.reportTargetProtocolError(message, rawTarget);
+                        return {
+                            ok: false,
+                            error: message,
+                            didSendViaMessagingTool: false,
+                            messagingToolSentTexts: [],
+                            messagingToolSentMediaUrls: [],
+                            messagingToolSentTargets: [],
+                        };
                     }
-                    const sessionId = target || "default";
-                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolved: sessionId=${sessionId}, rawTarget=${target}`);
+                    logger?.info?.(`[dragon channels][Dragon Plugin] handleAction target resolved: sessionId=${sessionId}, target=${target}, rawTarget=${rawTarget}`);
                     // Collect ALL media URLs from the params (mirrors what OpenClaw tracks internally
                     // via collectMessagingMediaUrlsFromRecord when the tool call starts, so that
                     // hasGatewayAgentDeliveredExpectedMedia can match them against expectedMediaUrls).
@@ -282,7 +294,7 @@ const plugin = createChatChannelPlugin({
                     logger?.info?.(`[dragon channels][Dragon Plugin] handleAction sending text over channel: text_len=${text.length}, targetSession=${sessionId}`);
                     const result = await channel.handleOutboundText({
                         text,
-                        peer: { id: sessionId }
+                        peer: { id: target }
                     });
                     logger?.info?.(`[dragon channels][Dragon Plugin] handleAction channel send result: ok=${result.ok}, messageId=${result.messageId || "none"}`);
                     const evidence = {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const dragonChannelPluginVersion = "0.5.32";
+export declare const dragonChannelPluginVersion = "0.5.33";

package/dist/version.js

@@ -1 +1 @@
-export const dragonChannelPluginVersion = "0.5.32";
+export const dragonChannelPluginVersion = "0.5.33";

package/package.json

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