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

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,6 +1,9 @@
 import { resolveXYConfig } from "./config.js";
+import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.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
@@ -104,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,
         };
     },
@@ -129,94 +176,81 @@ export const xyOutbound = {
             mediaUrl,
             mediaLocalRoots,
         });
-        // 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
+        // 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 = {
+            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: "",
+            messageId: fileId,
             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

@@ -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.
  */