@ynhcj/xiaoyi-channel 0.0.26-beta → 0.0.26-next

package/dist/src/cspl/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function filterText(text: string): string;
+export declare function validateAndTruncateText(text: string, maxLength: number): {
+    text: string;
+    truncated: boolean;
+};
+export declare function extractResultText(event: any, toolName: string): string;
+export declare function processText(resultText: string): string;
+export declare function parseSecurityResult(response: any): {
+    status: "ACCEPT" | "REJECT";
+};

package/dist/src/cspl/utils.js

@@ -0,0 +1,57 @@
+// CSPL Hook 工具函数
+import { MAX_TEXT_LENGTH, regex } from "./constants.js";
+export function filterText(text) {
+    if (!text)
+        return "";
+    return text.replace(new RegExp(regex.source, "g"), "");
+}
+export function validateAndTruncateText(text, maxLength) {
+    if (text.length > maxLength) {
+        const halfMaxLength = Math.floor(maxLength / 2);
+        const startText = text.substring(0, halfMaxLength);
+        const endText = text.substring(text.length - halfMaxLength);
+        return { text: startText + endText, truncated: true };
+    }
+    return { text, truncated: false };
+}
+export function extractResultText(event, toolName) {
+    const resultTexts = [];
+    if (toolName === "web_fetch") {
+        if (event.result?.details?.text) {
+            resultTexts.push(event.result.details.text);
+        }
+        return resultTexts.length > 0 ? resultTexts.join("; ") : "";
+    }
+    if (event.result?.content && Array.isArray(event.result.content)) {
+        for (const item of event.result.content) {
+            if (item?.text) {
+                resultTexts.push(item.text);
+            }
+        }
+    }
+    return resultTexts.length > 0 ? resultTexts.join("; ") : "";
+}
+export function processText(resultText) {
+    const questionText = filterText(resultText);
+    const { text: finalText } = validateAndTruncateText(questionText, MAX_TEXT_LENGTH);
+    return finalText;
+}
+export function parseSecurityResult(response) {
+    if (response === null || response === undefined) {
+        throw new Error("Response is null or undefined");
+    }
+    if (!response.data || typeof response.data !== "object") {
+        throw new Error("Response.data is missing or not an object");
+    }
+    const securityResult = response.data.securityResult;
+    if (typeof securityResult !== "string") {
+        throw new Error("Response.data.securityResult is missing or not a string");
+    }
+    if (securityResult !== securityResult.trim()) {
+        throw new Error("Response.data.securityResult contains leading or trailing spaces");
+    }
+    if (securityResult !== "ACCEPT" && securityResult !== "REJECT") {
+        throw new Error(`Response.data.securityResult must be "ACCEPT" or "REJECT". Actual: "${securityResult}"`);
+    }
+    return { status: securityResult };
+}

package/dist/src/file-upload.d.ts

@@ -12,6 +12,11 @@ export declare class XYFileUploadService {
      * Returns the objectId (as fileId) for use in A2A messages.
      */
     uploadFile(filePath: string, objectType?: string): Promise<string>;
+    /**
+     * Upload a file and return its publicly accessible URL.
+     * Uses completeAndQuery endpoint to get the file URL directly.
+     */
+    uploadFileAndGetUrl(filePath: string, objectType?: string): Promise<string>;
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/file-upload.js

@@ -105,6 +105,98 @@ export class XYFileUploadService {
             return "";
         }
     }
+    /**
+     * Upload a file and return its publicly accessible URL.
+     * Uses completeAndQuery endpoint to get the file URL directly.
+     */
+    async uploadFileAndGetUrl(filePath, objectType = "TEMPORARY_MATERIAL_DOC") {
+        console.log(`[XY File Upload] Starting file upload with URL retrieval: ${filePath}`);
+        try {
+            // Read file
+            const fileBuffer = await fs.readFile(filePath);
+            const fileName = path.basename(filePath);
+            const fileSha256 = calculateSHA256(fileBuffer);
+            const fileSize = fileBuffer.length;
+            // Phase 1: Prepare
+            console.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
+            const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectType,
+                    fileName,
+                    fileSha256,
+                    fileSize,
+                    fileOwnerInfo: {
+                        uid: this.uid,
+                        teamId: this.uid,
+                    },
+                    useEdge: false,
+                }),
+            });
+            if (!prepareResp.ok) {
+                throw new Error(`Prepare failed: HTTP ${prepareResp.status}`);
+            }
+            const prepareData = await prepareResp.json();
+            console.log(`[XY File Upload] Prepare response:`, JSON.stringify(prepareData, null, 2));
+            if (prepareData.code !== "0") {
+                throw new Error(`Prepare failed: ${prepareData.desc}`);
+            }
+            const { objectId, draftId, uploadInfos } = prepareData;
+            console.log(`[XY File Upload] Prepare complete: objectId=${objectId}, draftId=${draftId}`);
+            // Phase 2: Upload
+            console.log(`[XY File Upload] Phase 2: Upload file data`);
+            const uploadInfo = uploadInfos[0]; // Single-part upload
+            const uploadResp = await fetch(uploadInfo.url, {
+                method: uploadInfo.method,
+                headers: uploadInfo.headers,
+                body: fileBuffer,
+            });
+            console.log(`[XY File Upload] Upload response status: ${uploadResp.status}`);
+            if (!uploadResp.ok) {
+                const uploadErrorText = await uploadResp.text();
+                console.log(`[XY File Upload] Upload error response:`, uploadErrorText);
+                throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
+            }
+            console.log(`[XY File Upload] Upload complete`);
+            // Phase 3: CompleteAndQuery - get file URL
+            console.log(`[XY File Upload] Phase 3: CompleteAndQuery to get file URL`);
+            const completeResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/completeAndQuery`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectId,
+                    draftId,
+                }),
+            });
+            if (!completeResp.ok) {
+                throw new Error(`CompleteAndQuery failed: HTTP ${completeResp.status}`);
+            }
+            const completeData = await completeResp.json();
+            console.log(`[XY File Upload] CompleteAndQuery response:`, JSON.stringify(completeData, null, 2));
+            // Extract file URL from response
+            const fileUrl = completeData?.fileDetailInfo?.url || "";
+            if (!fileUrl) {
+                throw new Error("No file URL returned from completeAndQuery");
+            }
+            console.log(`[XY File Upload] File upload successful: ${fileName} → URL=${fileUrl}`);
+            return fileUrl;
+        }
+        catch (error) {
+            console.error(`[XY File Upload] File upload with URL retrieval failed for ${filePath}:`, error);
+            throw error;
+        }
+    }
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/formatter.d.ts

@@ -92,3 +92,17 @@ export interface SendTasksCancelResponseParams {
  * Send a tasks/cancel response.
  */
 export declare function sendTasksCancelResponse(params: SendTasksCancelResponseParams): Promise<void>;
+/**
+ * Parameters for sending a Trigger response.
+ */
+export interface SendTriggerResponseParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    content: string;
+}
+/**
+ * Send a Trigger response with pushData content.
+ */
+export declare function sendTriggerResponse(params: SendTriggerResponseParams): Promise<void>;

package/dist/src/formatter.js

@@ -52,18 +52,11 @@ export async function sendA2AResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
-    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
-    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
-    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
     log(`[A2A_RESPONSE]   - append: ${append}`);
     log(`[A2A_RESPONSE]   - final: ${final}`);
-    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - text: ${text}`);
     log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
-    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
-    log(JSON.stringify(outboundMessage, null, 2));
-    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
-    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
@@ -106,9 +99,7 @@ export async function sendReasoningTextUpdate(params) {
         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.
@@ -154,15 +145,10 @@ export async function sendStatusUpdate(params) {
     };
     // 📋 Log complete response body
     log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
     log(`[A2A_STATUS]   - taskId: ${taskId}`);
     log(`[A2A_STATUS]   - messageId: ${messageId}`);
     log(`[A2A_STATUS]   - state: ${state}`);
     log(`[A2A_STATUS]   - text: "${text}"`);
-    log(`[A2A_STATUS] 📦 Complete outbound message:`);
-    log(JSON.stringify(outboundMessage, null, 2));
-    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
-    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_STATUS] ✅ Status update sent successfully`);
 }
@@ -210,15 +196,7 @@ export async function sendCommand(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
-    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
-    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
-    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
-    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
-    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
-    log(JSON.stringify(outboundMessage, null, 2));
-    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
-    log(JSON.stringify(jsonRpcResponse, null, 2));
+    log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }
@@ -293,3 +271,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.js

@@ -72,18 +72,14 @@ 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}`);
                 this.onTimeout();
             }, this.config.timeout);
-            this.log(`[DEBUG] Heartbeat sent for ${this.serverName}`);
         }
         catch (error) {
             this.error(`Failed to send heartbeat for ${this.serverName}:`, error);

package/dist/src/monitor.js

@@ -3,6 +3,7 @@ import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, r
 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.
@@ -150,6 +151,15 @@ export async function monitorXYProvider(opts = {}) {
         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
@@ -166,6 +176,7 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("connected", connectedHandler);
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
+            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();
@@ -195,6 +206,7 @@ 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(() => {

package/dist/src/onboarding.d.ts

@@ -1,6 +1,5 @@
-import type { ChannelOnboardingAdapter } from "openclaw/plugin-sdk";
 /**
- * XY Channel Onboarding Adapter
- * Implements the ChannelOnboardingAdapter interface for OpenClaw's onboarding system
+ * XY Channel Onboarding Adapter (DISABLED - not currently used)
+ * NOTE: This is kept for future reference. Xiaoyi uses simple single-account config.
  */
-export declare const xyOnboardingAdapter: ChannelOnboardingAdapter;
+export declare const xyOnboardingAdapter: any;

package/dist/src/onboarding.js

@@ -152,8 +152,8 @@ async function configure({ cfg, prompter, }) {
     };
 }
 /**
- * XY Channel Onboarding Adapter
- * Implements the ChannelOnboardingAdapter interface for OpenClaw's onboarding system
+ * XY Channel Onboarding Adapter (DISABLED - not currently used)
+ * NOTE: This is kept for future reference. Xiaoyi uses simple single-account config.
  */
 export const xyOnboardingAdapter = {
     channel,

package/dist/src/outbound.d.ts

@@ -1,6 +1,7 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+type ChannelOutboundAdapter = any;
 /**
  * Outbound adapter for sending messages from OpenClaw to XY.
  * Uses Push service for direct message delivery.
  */
 export declare const xyOutbound: ChannelOutboundAdapter;
+export {};

package/dist/src/outbound.js

@@ -1,7 +1,9 @@
 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
@@ -65,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}`);
@@ -105,19 +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);
         // 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);
+        // 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)}...`);
+                // 传入 pushId 和 pushDataId，使用 kind="data" 格式
+                await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId, pushId);
+                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,
         };
     },

package/dist/src/parser.d.ts

@@ -43,6 +43,13 @@ export declare function isTasksCancelMessage(method: string): boolean;
  * 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

@@ -72,6 +72,28 @@ export function extractPushId(parts) {
     }
     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

@@ -14,8 +14,15 @@ export declare class XYPushService {
     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
+     * @param pushId - Push ID to use (required)
      */
-    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string, pushDataId?: string, pushId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */

package/dist/src/push.js

@@ -1,7 +1,6 @@
 // Push message service for scheduled tasks
 import fetch from "node-fetch";
 import { randomUUID } from "crypto";
-import { configManager } from "./utils/config-manager.js";
 /**
  * Service for sending push messages to users.
  * Used for outbound messages and scheduled tasks.
@@ -21,27 +20,27 @@ export class XYPushService {
     }
     /**
      * 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
+     * @param pushId - Push ID to use (required)
      */
-    async sendPush(content, title, data, sessionId) {
+    async sendPush(content, title, data, sessionId, pushDataId, pushId) {
         const pushUrl = this.config.pushUrl || this.DEFAULT_PUSH_URL;
         const traceId = this.generateTraceId();
-        // Get dynamic pushId for the session (falls back to config pushId)
-        const dynamicPushId = configManager.getPushId(sessionId);
-        const pushId = dynamicPushId || this.config.pushId;
+        // Use provided pushId or fall back to config pushId
+        const actualPushId = pushId || this.config.pushId;
         console.log(`[PUSH] 📤 Preparing to send push message`);
         console.log(`[PUSH]   - Title: "${title}"`);
         console.log(`[PUSH]   - Content length: ${content.length} chars`);
         console.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
         console.log(`[PUSH]   - Trace ID: ${traceId}`);
         console.log(`[PUSH]   - Push URL: ${pushUrl}`);
-        if (dynamicPushId) {
-            console.log(`[PUSH]   - Using dynamic pushId (from session): ${pushId.substring(0, 20)}...`);
-            console.log(`[PUSH]   - Full dynamic pushId: ${pushId}`);
-        }
-        else {
-            console.log(`[PUSH]   - Using config pushId (fallback): ${pushId.substring(0, 20)}...`);
-            console.log(`[PUSH]   - Full config pushId: ${pushId}`);
-        }
+        console.log(`[PUSH]   - Using pushId: ${actualPushId.substring(0, 20)}...`);
+        console.log(`[PUSH]   - Full pushId: ${actualPushId}`);
         console.log(`[PUSH]   - API ID: ${this.config.apiId}`);
         console.log(`[PUSH]   - UID: ${this.config.uid}`);
         try {
@@ -51,18 +50,27 @@ export class XYPushService {
                 result: {
                     id: randomUUID(),
                     apiId: this.config.apiId,
-                    pushId: pushId, // Use dynamic pushId
+                    pushId: actualPushId,
                     pushText: title,
                     kind: "task",
                     artifacts: [
                         {
                             artifactId: randomUUID(),
-                            parts: [
-                                {
-                                    kind: "text",
-                                    text: content,
-                                },
-                            ],
+                            parts: pushDataId
+                                ? [
+                                    {
+                                        kind: "data",
+                                        data: {
+                                            pushDataId: pushDataId,
+                                        },
+                                    },
+                                ]
+                                : [
+                                    {
+                                        kind: "text",
+                                        text: content,
+                                    },
+                                ],
                         },
                     ],
                 },
@@ -114,14 +122,14 @@ export class XYPushService {
             console.log(`[PUSH] ✅ Push message sent successfully`);
             console.log(`[PUSH]   - Title: "${title}"`);
             console.log(`[PUSH]   - Trace ID: ${traceId}`);
-            console.log(`[PUSH]   - Used pushId: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Used pushId: ${actualPushId.substring(0, 20)}...`);
             console.log(`[PUSH]   - Response:`, result);
         }
         catch (error) {
             console.log(`[PUSH] ❌ Failed to send push message`);
             console.log(`[PUSH]   - Trace ID: ${traceId}`);
             console.log(`[PUSH]   - Target URL: ${pushUrl}`);
-            console.log(`[PUSH]   - Push ID: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Push ID: ${actualPushId.substring(0, 20)}...`);
             if (error instanceof Error) {
                 console.log(`[PUSH]   - Error name: ${error.name}`);
                 console.log(`[PUSH]   - Error message: ${error.message}`);