@ynhcj/xiaoyi-channel 0.0.9 → 0.0.10-next

package/dist/src/formatter.js

@@ -67,6 +67,49 @@ export async function sendA2AResponse(params) {
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+export async function sendReasoningTextUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, append = true } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final: false,
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [
+                {
+                    kind: "reasoningText",
+                    reasoningText: text,
+                },
+            ],
+        },
+    };
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[REASONING_TEXT] 📤 Sending reasoningText update: sessionId=${sessionId}, taskId=${taskId}, text.length=${text.length}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[REASONING_TEXT] ✅ Sent successfully`);
+}
 /**
  * Send an A2A task status update.
  * Follows A2A protocol standard format with nested status object.
@@ -132,6 +175,7 @@ export async function sendCommand(params) {
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
     // Build artifact update with command as data
+    // Wrap command in commands array as per protocol requirement
     const artifact = {
         taskId,
         kind: "artifact-update",
@@ -143,7 +187,9 @@ export async function sendCommand(params) {
             parts: [
                 {
                     kind: "data",
-                    data: command,
+                    data: {
+                        commands: [command],
+                    },
                 },
             ],
         },
@@ -247,3 +293,49 @@ export async function sendTasksCancelResponse(params) {
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
 }
+/**
+ * Send a Trigger response with pushData content.
+ */
+export async function sendTriggerResponse(params) {
+    const { config, sessionId, taskId, messageId, content } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for Trigger
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            taskId: taskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: true,
+            artifact: {
+                artifactId: uuidv4(),
+                parts: [
+                    {
+                        kind: "text",
+                        text: content,
+                    },
+                ],
+            },
+        },
+        error: {
+            code: 0,
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[TRIGGER_RESPONSE] Sending Trigger response: sessionId=${sessionId}, taskId=${taskId}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
+}

package/dist/src/heartbeat.d.ts

@@ -13,12 +13,13 @@ export declare class HeartbeatManager {
     private config;
     private onTimeout;
     private serverName;
+    private onHeartbeatSuccess?;
     private intervalTimer;
     private timeoutTimer;
     private lastPongTime;
     private log;
     private error;
-    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void);
+    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void, onHeartbeatSuccess?: () => void);
     /**
      * Start heartbeat monitoring.
      */

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(() => {

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,9 @@
 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";
+import { handleTriggerEvent } from "./trigger-handler.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,19 +40,36 @@ 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) => {
         // 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!`);
@@ -68,8 +88,8 @@ export async function monitorXYProvider(opts = {}) {
                     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
@@ -77,37 +97,97 @@ export async function monitorXYProvider(opts = {}) {
                     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)}`);
-                activeMessages.delete(messageKey);
-            });
+            // 🔑 核心改造：检测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)}`);
         };
+        const triggerEventHandler = (context) => {
+            log(`[MONITOR] 📌 Received trigger-event, dispatching to handler...`);
+            log(`[MONITOR]   - sessionId: ${context.sessionId}`);
+            log(`[MONITOR]   - taskId: ${context.taskId}`);
+            // 异步处理 Trigger 事件，不阻塞主流程
+            handleTriggerEvent(context, cfg, runtime, accountId).catch((err) => {
+                error(`[MONITOR] Failed to handle trigger-event:`, err);
+            });
+        };
         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);
-            // Don't disconnect the shared wsManager as it may be used elsewhere
-            // wsManager.disconnect();
+            wsManager.off("trigger-event", triggerEventHandler);
+            // ✅ 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");
@@ -126,6 +206,18 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("connected", connectedHandler);
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
+        wsManager.on("trigger-event", triggerEventHandler);
+        // 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/outbound.js

@@ -1,9 +1,44 @@
 import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
-import { getLatestSessionContext } from "./tools/session-manager.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { savePushData } from "./utils/pushdata-manager.js";
+import { getAllPushIds } from "./utils/pushid-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.
@@ -32,8 +67,8 @@ export const xyOutbound = {
         // 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 latest session context
-            const sessionContext = getLatestSessionContext();
+            // 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}`);
@@ -72,17 +107,63 @@ export const xyOutbound = {
             // The push service will handle it based on config
             actualTo = config.defaultSessionId || "";
         }
+        // 1. 持久化推送消息内容，获取 pushDataId
+        console.log(`[xyOutbound.sendText] Saving push data to local storage...`);
+        let pushDataId;
+        try {
+            pushDataId = await savePushData(text);
+            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId}`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
+            // 如果持久化失败，仍然继续发送（不阻塞主流程）
+            pushDataId = "";
+        }
+        // 2. 读取所有 pushId
+        console.log(`[xyOutbound.sendText] Loading all pushIds...`);
+        let pushIdList = [];
+        try {
+            pushIdList = await getAllPushIds();
+            console.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
+        }
+        // 3. 如果 pushIdList 为空，回退到原有逻辑（使用 config pushId）
+        if (pushIdList.length === 0) {
+            console.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
+            pushIdList = [config.pushId];
+        }
         // Create push service
         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;
+        // 4. 遍历所有 pushId，依次发送推送通知
+        console.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
+        let successCount = 0;
+        let failureCount = 0;
+        for (const pushId of pushIdList) {
+            try {
+                console.log(`[xyOutbound.sendText] Sending to pushId: ${pushId.substring(0, 20)}...`);
+                // 传入 pushDataId，使用 kind="data" 格式
+                await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId);
+                successCount++;
+                console.log(`[xyOutbound.sendText] ✅ Sent successfully to pushId: ${pushId.substring(0, 20)}...`);
+            }
+            catch (error) {
+                failureCount++;
+                console.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
+                // 单个 pushId 发送失败不影响其他，继续处理下一个
+            }
+        }
+        console.log(`[xyOutbound.sendText] 📊 Broadcast summary: ${successCount} success, ${failureCount} failures`);
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",
-            messageId: Date.now().toString(),
+            messageId: pushDataId || Date.now().toString(),
             chatId: actualTo,
         };
     },
@@ -111,6 +192,15 @@ export const xyOutbound = {
         }
         // 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,
@@ -119,7 +209,7 @@ export const xyOutbound = {
         // 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";
+        const mimeType = getMimeTypeFromFilename(fileName);
         // Build agent_response message
         const agentResponse = {
             msgType: "agent_response",

package/dist/src/parser.d.ts

@@ -38,6 +38,18 @@ 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;
+/**
+ * Extract Trigger event data from message parts.
+ * Looks for Trigger events with pushDataId in data parts.
+ */
+export declare function extractTriggerData(parts: A2AMessagePart[]): {
+    pushDataId: string;
+} | null;
 /**
  * Validate A2A request structure.
  */

package/dist/src/parser.js

@@ -57,6 +57,43 @@ 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;
+}
+/**
+ * Extract Trigger event data from message parts.
+ * Looks for Trigger events with pushDataId in data parts.
+ */
+export function extractTriggerData(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const events = part.data.events;
+            if (Array.isArray(events)) {
+                for (const event of events) {
+                    if (event.header?.namespace === "Common" && event.header?.name === "Trigger") {
+                        const pushDataId = event.payload?.dataMap?.pushDataId;
+                        if (pushDataId && typeof pushDataId === "string") {
+                            return { pushDataId };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
 /**
  * Validate A2A request structure.
  */

package/dist/src/push.d.ts

@@ -5,11 +5,23 @@ 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.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
      */
-    sendPush(content: string, title: string, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string, pushDataId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */