@ynhcj/xiaoyi-channel 0.0.2 → 0.0.3-next

package/dist/src/heartbeat.js

@@ -9,17 +9,20 @@ export class HeartbeatManager {
     config;
     onTimeout;
     serverName;
+    onHeartbeatSuccess;
     intervalTimer = null;
     timeoutTimer = null;
     lastPongTime = 0;
     // Logging functions following feishu pattern
     log;
     error;
-    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn) {
+    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn, onHeartbeatSuccess // ✅ 新增：心跳成功回调
+    ) {
         this.ws = ws;
         this.config = config;
         this.onTimeout = onTimeout;
         this.serverName = serverName;
+        this.onHeartbeatSuccess = onHeartbeatSuccess;
         this.log = logFn ?? console.log;
         this.error = errorFn ?? console.error;
     }
@@ -36,6 +39,8 @@ export class HeartbeatManager {
                 clearTimeout(this.timeoutTimer);
                 this.timeoutTimer = null;
             }
+            // ✅ Report health: heartbeat successful
+            this.onHeartbeatSuccess?.();
         });
         // Start interval timer
         this.intervalTimer = setInterval(() => {
@@ -67,9 +72,12 @@ export class HeartbeatManager {
         }
         try {
             // Send application-level heartbeat message
+            console.log(`[WS-${this.serverName}-SEND] Sending heartbeat frame:`, this.config.message);
             this.ws.send(this.config.message);
+            console.log(`[WS-${this.serverName}-SEND] Heartbeat message sent, size: ${this.config.message.length} bytes`);
             // Send protocol-level ping
             this.ws.ping();
+            console.log(`[WS-${this.serverName}-SEND] Protocol-level ping sent`);
             // Setup timeout timer
             this.timeoutTimer = setTimeout(() => {
                 this.error(`Heartbeat timeout for ${this.serverName}`);

package/dist/src/monitor.d.ts

@@ -4,6 +4,11 @@ export type MonitorXYOpts = {
     runtime?: RuntimeEnv;
     abortSignal?: AbortSignal;
     accountId?: string;
+    setStatus?: (status: {
+        lastEventAt?: number;
+        lastInboundAt?: number;
+        connected?: boolean;
+    }) => void;
 };
 /**
  * Monitor XY channel WebSocket connections.

package/dist/src/monitor.js

@@ -1,6 +1,8 @@
 import { resolveXYConfig } from "./config.js";
-import { getXYWebSocketManager } from "./client.js";
+import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
+import { parseA2AMessage } from "./parser.js";
+import { hasActiveTask } from "./task-manager.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -37,69 +39,173 @@ export async function monitorXYProvider(opts = {}) {
         throw new Error(`XY account is disabled`);
     }
     const accountId = opts.accountId ?? "default";
+    // Create trackEvent function to report health to OpenClaw framework
+    const trackEvent = opts.setStatus
+        ? () => {
+            opts.setStatus({ lastEventAt: Date.now(), lastInboundAt: Date.now() });
+        }
+        : undefined;
+    // 🔍 Diagnose WebSocket managers before gateway start
+    console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    diagnoseAllManagers();
     // Get WebSocket manager (cached)
     const wsManager = getXYWebSocketManager(account);
+    // ✅ Set health event callback for heartbeat reporting
+    if (trackEvent) {
+        wsManager.setHealthEventCallback(trackEvent);
+    }
     // Track logged servers to avoid duplicate logs
     const loggedServers = new Set();
+    // Track active message processing to detect duplicates
+    const activeMessages = new Set();
     // Create session queue for ordered message processing
     const enqueue = createSessionQueue();
+    // Health check interval
+    let healthCheckInterval = null;
     return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            log("XY gateway: cleaning up...");
-            wsManager.disconnect();
-            loggedServers.clear();
-        };
-        const handleAbort = () => {
-            log("XY gateway: abort signal received, stopping");
-            cleanup();
-            log("XY gateway stopped");
-            resolve();
-        };
-        if (opts.abortSignal?.aborted) {
-            cleanup();
-            resolve();
-            return;
-        }
-        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
-        // Setup event handlers
+        // Event handlers (defined early so they can be referenced in cleanup)
         const messageHandler = (message, sessionId, serverId) => {
+            const messageKey = `${sessionId}::${message.id}`;
+            log(`[MONITOR-HANDLER] ####### messageHandler triggered: serverId=${serverId}, sessionId=${sessionId}, messageId=${message.id} #######`);
+            // ✅ Report health: received a message
+            trackEvent?.();
+            // Check for duplicate message handling
+            if (activeMessages.has(messageKey)) {
+                error(`[MONITOR-HANDLER] ⚠️ WARNING: Duplicate message detected! messageKey=${messageKey}, this may cause duplicate dispatchers!`);
+            }
+            activeMessages.add(messageKey);
+            log(`[MONITOR-HANDLER] 📝 Active messages count: ${activeMessages.size}, messageKey: ${messageKey}`);
             const task = async () => {
                 try {
+                    log(`[MONITOR-HANDLER] 🚀 Starting handleXYMessage for messageKey=${messageKey}`);
                     await handleXYMessage({
                         cfg,
                         runtime,
                         message,
                         accountId, // ✅ Pass accountId ("default")
                     });
+                    log(`[MONITOR-HANDLER] ✅ Completed handleXYMessage for messageKey=${messageKey}`);
                 }
                 catch (err) {
+                    // ✅ Only log error, don't re-throw to prevent gateway restart
                     error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
-                    throw err;
+                }
+                finally {
+                    // Remove from active messages when done
+                    activeMessages.delete(messageKey);
+                    log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
                 }
             };
-            void enqueue(sessionId, task).catch((err) => {
-                // Error already logged in task, this is for queue failures
-                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
-            });
+            // 🔑 核心改造：检测steer模式
+            // 需要提前解析消息以获取sessionId
+            try {
+                const parsed = parseA2AMessage(message);
+                const steerMode = cfg.messages?.queue?.mode === "steer";
+                const hasActiveRun = hasActiveTask(parsed.sessionId);
+                if (steerMode && hasActiveRun) {
+                    // Steer模式且有活跃任务：不入队列，直接并发执行
+                    log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
+                    log(`[MONITOR-HANDLER]   - sessionId: ${parsed.sessionId}`);
+                    log(`[MONITOR-HANDLER]   - Bypassing queue to allow message insertion`);
+                    void task().catch((err) => {
+                        error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+                else {
+                    // 正常模式：入队列串行执行
+                    log(`[MONITOR-HANDLER] 📋 NORMAL MODE: Enqueuing for messageKey=${messageKey}`);
+                    void enqueue(sessionId, task).catch((err) => {
+                        error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+            }
+            catch (parseErr) {
+                // 解析失败，回退到正常队列模式
+                error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
+                void enqueue(sessionId, task).catch((err) => {
+                    error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                    activeMessages.delete(messageKey);
+                });
+            }
         };
         const connectedHandler = (serverId) => {
             if (!loggedServers.has(serverId)) {
                 log(`XY gateway: ${serverId} connected`);
                 loggedServers.add(serverId);
             }
+            // ✅ Report health: connection established
+            trackEvent?.();
+            opts.setStatus?.({ connected: true });
         };
         const disconnectedHandler = (serverId) => {
             console.warn(`XY gateway: ${serverId} disconnected`);
             loggedServers.delete(serverId);
+            // ✅ Report disconnection status (only if all servers disconnected)
+            if (loggedServers.size === 0) {
+                opts.setStatus?.({ connected: false });
+            }
         };
         const errorHandler = (err, serverId) => {
             error(`XY gateway: ${serverId} error: ${String(err)}`);
         };
-        // Register event handlers
+        const cleanup = () => {
+            log("XY gateway: cleaning up...");
+            // 🔍 Diagnose before cleanup
+            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
+            diagnoseAllManagers();
+            // Stop health check interval
+            if (healthCheckInterval) {
+                clearInterval(healthCheckInterval);
+                healthCheckInterval = null;
+                console.log("⏸️  Stopped periodic health check");
+            }
+            // Remove event handlers to prevent duplicate calls on gateway restart
+            wsManager.off("message", messageHandler);
+            wsManager.off("connected", connectedHandler);
+            wsManager.off("disconnected", disconnectedHandler);
+            wsManager.off("error", errorHandler);
+            // ✅ Disconnect the wsManager to prevent connection leaks
+            // This is safe because each gateway lifecycle should have clean connections
+            wsManager.disconnect();
+            // ✅ Remove manager from cache to prevent reusing dirty state
+            removeXYWebSocketManager(account);
+            loggedServers.clear();
+            activeMessages.clear();
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+            // 🔍 Diagnose after cleanup
+            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
+            diagnoseAllManagers();
+        };
+        const handleAbort = () => {
+            log("XY gateway: abort signal received, stopping");
+            cleanup();
+            log("XY gateway stopped");
+            resolve();
+        };
+        if (opts.abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        // Register event handlers (handlers are defined above in cleanup scope)
         wsManager.on("message", messageHandler);
         wsManager.on("connected", connectedHandler);
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
+        // Start periodic health check (every 5 minutes)
+        console.log("🏥 Starting periodic health check (every 5 minutes)...");
+        healthCheckInterval = setInterval(() => {
+            console.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
+            diagnoseAllManagers();
+            // Auto-cleanup orphan connections
+            const cleaned = cleanupOrphanConnections();
+            if (cleaned > 0) {
+                console.log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+            }
+        }, 5 * 60 * 1000); // 5 minutes
         // Connect to WebSocket servers
         wsManager.connect()
             .then(() => {

package/dist/src/onboarding.js

@@ -1,10 +1,10 @@
-const channel = "xy";
+const channel = "xiaoyi-channel";
 /**
  * Check if XY channel is properly configured with required fields
  */
 function isXYConfigured(cfg) {
     try {
-        const xyConfig = cfg.channels?.xy;
+        const xyConfig = cfg.channels?.["xiaoyi-channel"];
         if (!xyConfig) {
             return false;
         }
@@ -26,7 +26,7 @@ function isXYConfigured(cfg) {
  */
 async function getStatus({ cfg }) {
     const configured = isXYConfigured(cfg);
-    const xyConfig = cfg.channels?.xy;
+    const xyConfig = cfg.channels?.["xiaoyi-channel"];
     const statusLines = [];
     if (configured) {
         const wsUrl1 = xyConfig?.wsUrl1 || "ws://localhost:8765/ws/link";
@@ -49,7 +49,7 @@ async function getStatus({ cfg }) {
  */
 async function configure({ cfg, prompter, }) {
     // Note current configuration status
-    const currentConfig = cfg.channels?.xy;
+    const currentConfig = cfg.channels?.["xiaoyi-channel"];
     const isUpdate = Boolean(currentConfig);
     await prompter.note([
         "XY Channel - 小艺 A2A 协议配置",
@@ -117,7 +117,7 @@ async function configure({ cfg, prompter, }) {
         ...cfg,
         channels: {
             ...cfg.channels,
-            xy: {
+            "xiaoyi-channel": {
                 enabled: true,
                 wsUrl1: wsUrl1.trim(),
                 wsUrl2: wsUrl2.trim(),
@@ -164,8 +164,8 @@ export const xyOnboardingAdapter = {
         ...cfg,
         channels: {
             ...cfg.channels,
-            xy: {
-                ...(cfg.channels?.xy || {}),
+            "xiaoyi-channel": {
+                ...(cfg.channels?.["xiaoyi-channel"] || {}),
                 enabled: false,
             },
         },

package/dist/src/outbound.js

@@ -1,8 +1,41 @@
 import { resolveXYConfig } from "./config.js";
-import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
+// File extension to MIME type mapping
+const FILE_TYPE_TO_MIME_TYPE = {
+    txt: "text/plain",
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+};
+/**
+ * Get MIME type from file extension
+ */
+function getMimeTypeFromFilename(filename) {
+    const extension = filename.split(".").pop()?.toLowerCase();
+    if (extension && FILE_TYPE_TO_MIME_TYPE[extension]) {
+        return FILE_TYPE_TO_MIME_TYPE[extension];
+    }
+    return "text/plain"; // Default fallback
+}
 /**
  * Outbound adapter for sending messages from OpenClaw to XY.
  * Uses Push service for direct message delivery.
@@ -14,6 +47,9 @@ export const xyOutbound = {
      * Resolve delivery target for XY channel.
      * When no target is specified (e.g., in cron jobs with announce mode),
      * returns a default marker that will be handled by sendText.
+     *
+     * For message tool calls, if only sessionId is provided, it will look up
+     * the active session context to construct the full "sessionId::taskId" format.
      */
     resolveTarget: ({ cfg, to, accountId, mode }) => {
         // If no target provided, use default marker for push delivery
@@ -24,11 +60,30 @@ export const xyOutbound = {
                 to: DEFAULT_PUSH_MARKER,
             };
         }
-        // Otherwise, use the provided target
-        console.log(`[xyOutbound.resolveTarget] Using provided target:`, to);
+        const trimmedTo = to.trim();
+        // If the target doesn't contain "::", try to enhance it with taskId from session context
+        if (!trimmedTo.includes("::")) {
+            console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
+            // Try to get the current session context
+            const sessionContext = getCurrentSessionContext();
+            if (sessionContext && sessionContext.sessionId === trimmedTo) {
+                const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
+                console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
+                return {
+                    ok: true,
+                    to: enhancedTarget,
+                };
+            }
+            else {
+                console.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
+                // Still return the original target, but it may fail in sendMedia
+            }
+        }
+        // Otherwise, use the provided target (either already in correct format or for sendText)
+        console.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
         return {
             ok: true,
-            to: to.trim(),
+            to: trimmedTo,
         };
     },
     sendText: async ({ cfg, to, text, accountId }) => {
@@ -53,12 +108,14 @@ export const xyOutbound = {
         const pushService = new XYPushService(config);
         // Extract title (first 57 chars or first line)
         const title = text.split("\n")[0].slice(0, 57);
-        // Send push message
-        await pushService.sendPush(text, title, actualTo);
+        // Truncate push content to max length 1000
+        const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
+        // Send push message (content, title, data, sessionId)
+        await pushService.sendPush(pushText, title, undefined, actualTo);
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
-            channel: "xy",
+            channel: "xiaoyi-channel",
             messageId: Date.now().toString(),
             chatId: actualTo,
         };
@@ -72,72 +129,94 @@ export const xyOutbound = {
             mediaUrl,
             mediaLocalRoots,
         });
-        // Parse to: "sessionId::taskId"
-        const parts = to.split("::");
-        if (parts.length !== 2) {
-            throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
-        }
-        const [sessionId, taskId] = parts;
-        // Resolve configuration
-        const config = resolveXYConfig(cfg);
-        // Create upload service
-        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-        // Validate mediaUrl
-        if (!mediaUrl) {
-            throw new Error("mediaUrl is required for sendMedia");
-        }
-        // Upload file
-        const fileId = await uploadService.uploadFile(mediaUrl);
-        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
-            fileId,
-            sessionId,
-            taskId,
-        });
-        // Get filename and mime type from mediaUrl
-        // mediaUrl may be a local file path or URL
-        const fileName = mediaUrl.split("/").pop() || "unknown";
-        const mimeType = text?.match(/\[ MediaType: ([^\]]+)\]/)?.[1] || "application/octet-stream";
-        // Build agent_response message
-        const agentResponse = {
-            msgType: "agent_response",
-            agentId: config.agentId,
-            sessionId: sessionId,
-            taskId: taskId,
-            msgDetail: JSON.stringify({
-                jsonrpc: "2.0",
-                id: taskId,
-                result: {
-                    kind: "artifact-update",
-                    append: true,
-                    lastChunk: false,
-                    final: false,
-                    artifact: {
-                        artifactId: taskId,
-                        parts: [
-                            {
-                                kind: "file",
-                                file: {
-                                    name: fileName,
-                                    mimeType: mimeType,
-                                    fileId: fileId,
-                                },
-                            },
-                        ],
-                    },
-                },
-                error: { code: 0 },
-            }),
-        };
-        // Get WebSocket manager and send message
-        const { getXYWebSocketManager } = await import("./client.js");
-        const wsManager = getXYWebSocketManager(config);
-        await wsManager.sendMessage(sessionId, agentResponse);
-        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
-        // Return message info
+        // All sendMedia processing logic has been disabled
+        // Use send_file_to_user tool instead for file transfers to user device
+        console.log(`[xyOutbound.sendMedia] Processing disabled, use send_file_to_user tool`);
+        // Return empty message info
         return {
-            channel: "xy",
-            messageId: fileId,
+            channel: "xiaoyi-channel",
+            messageId: "",
             chatId: to,
         };
+        // // Parse to: "sessionId::taskId"
+        // const parts = to.split("::");
+        // if (parts.length !== 2) {
+        //   throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
+        // }
+        // const [sessionId, taskId] = parts;
+        // // Resolve configuration
+        // const config = resolveXYConfig(cfg);
+        // // Create upload service
+        // const uploadService = new XYFileUploadService(
+        //   config.fileUploadUrl,
+        //   config.apiKey,
+        //   config.uid
+        // );
+        // // Validate mediaUrl
+        // if (!mediaUrl) {
+        //   throw new Error("mediaUrl is required for sendMedia");
+        // }
+        // // Upload file
+        // const fileId = await uploadService.uploadFile(mediaUrl);
+        // // Check if fileId is empty
+        // if (!fileId) {
+        //   console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
+        //   return {
+        //     channel: "xiaoyi-channel",
+        //     messageId: "",
+        //     chatId: to,
+        //   };
+        // }
+        // console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+        //   fileId,
+        //   sessionId,
+        //   taskId,
+        // });
+        // // Get filename and mime type from mediaUrl
+        // // mediaUrl may be a local file path or URL
+        // const fileName = mediaUrl.split("/").pop() || "unknown";
+        // const mimeType = getMimeTypeFromFilename(fileName);
+        // // Build agent_response message
+        // const agentResponse: OutboundWebSocketMessage = {
+        //   msgType: "agent_response",
+        //   agentId: config.agentId,
+        //   sessionId: sessionId,
+        //   taskId: taskId,
+        //   msgDetail: JSON.stringify({
+        //     jsonrpc: "2.0",
+        //     id: taskId,
+        //     result: {
+        //       kind: "artifact-update",
+        //       append: true,
+        //       lastChunk: false,
+        //       final: false,
+        //       artifact: {
+        //         artifactId: taskId,
+        //         parts: [
+        //           {
+        //             kind: "file",
+        //             file: {
+        //               name: fileName,
+        //               mimeType: mimeType,
+        //               fileId: fileId,
+        //             },
+        //           },
+        //         ],
+        //       },
+        //     },
+        //     error: { code: 0 },
+        //   }),
+        // };
+        // // Get WebSocket manager and send message
+        // const { getXYWebSocketManager } = await import("./client.js");
+        // const wsManager = getXYWebSocketManager(config);
+        // await wsManager.sendMessage(sessionId, agentResponse);
+        // console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        // // Return message info
+        // return {
+        //   channel: "xiaoyi-channel",
+        //   messageId: fileId,
+        //   chatId: to,
+        // };
     },
 };

package/dist/src/parser.d.ts

@@ -38,6 +38,11 @@ export declare function isClearContextMessage(method: string): boolean;
  * Check if message is a tasks/cancel request.
  */
 export declare function isTasksCancelMessage(method: string): boolean;
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export declare function extractPushId(parts: A2AMessagePart[]): string | null;
 /**
  * Validate A2A request structure.
  */

package/dist/src/parser.js

@@ -57,6 +57,21 @@ export function isClearContextMessage(method) {
 export function isTasksCancelMessage(method) {
     return method === "tasks/cancel" || method === "tasks_cancel";
 }
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export function extractPushId(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const pushId = part.data.variables?.systemVariables?.push_id;
+            if (pushId && typeof pushId === "string") {
+                return pushId;
+            }
+        }
+    }
+    return null;
+}
 /**
  * Validate A2A request structure.
  */

package/dist/src/push.d.ts

@@ -5,11 +5,17 @@ import type { XYChannelConfig } from "./types.js";
  */
 export declare class XYPushService {
     private config;
+    private readonly DEFAULT_PUSH_URL;
+    private readonly REQUEST_FROM;
     constructor(config: XYChannelConfig);
+    /**
+     * Generate a random trace ID for request tracking.
+     */
+    private generateTraceId;
     /**
      * Send a push message to a user session.
      */
-    sendPush(content: string, title: string, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */