@ynhcj/xiaoyi-channel 0.0.9 → 0.0.11-beta

package/dist/src/bot.js

@@ -1,10 +1,11 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
 import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { configManager } from "./utils/config-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -55,6 +56,18 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // Extract and update push_id if present
+        const pushId = extractPushId(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -83,6 +96,18 @@ export async function handleXYMessage(params) {
             agentId: route.accountId,
         });
         log(`[BOT] ✅ Session registered for tools`);
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void sendStatusUpdate({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         const fileParts = extractFileParts(parsed.parts);
@@ -99,7 +124,7 @@ export async function handleXYMessage(params) {
         messageBody = `${speaker}: ${messageBody}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
-            channel: "XY",
+            channel: "xiaoyi-channel",
             from: speaker,
             timestamp: new Date(),
             envelope: envelopeOptions,
@@ -180,6 +205,7 @@ export async function handleXYMessage(params) {
         log(`xy: dispatch complete (session=${parsed.sessionId})`);
     }
     catch (err) {
+        // ✅ Only log error, don't re-throw to prevent gateway restart
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
         log(`[BOT] ❌ Error occurred, attempting cleanup...`);
@@ -208,7 +234,7 @@ export async function handleXYMessage(params) {
             log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
             // Ignore cleanup errors
         }
-        throw err;
+        // ❌ Don't re-throw: message processing error should not affect gateway stability
     }
 }
 /**

package/dist/src/channel.js

@@ -5,6 +5,10 @@ import { xyOnboardingAdapter } from "./onboarding.js";
 import { locationTool } from "./tools/location-tool.js";
 import { noteTool } from "./tools/note-tool.js";
 import { searchNoteTool } from "./tools/search-note-tool.js";
+import { modifyNoteTool } from "./tools/modify-note-tool.js";
+import { calendarTool } from "./tools/calendar-tool.js";
+import { searchCalendarTool } from "./tools/search-calendar-tool.js";
+import { searchContactTool } from "./tools/search-contact-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -22,6 +26,7 @@ export const xyPlugin = {
     agentPrompt: {
         messageToolHints: () => [
             "- xiaoyi targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `default`",
+            "- If the user requests a file, you can call the message tool with the xiaoyi-channel channel to return it. Note: sendMedia requires a text reply."
         ],
     },
     capabilities: {
@@ -43,7 +48,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();
@@ -79,6 +84,7 @@ export const xyPlugin = {
                 runtime: context.runtime,
                 abortSignal: context.abortSignal,
                 accountId: context.accountId,
+                setStatus: context.setStatus,
             });
         },
     },

package/dist/src/client.d.ts

@@ -10,6 +10,11 @@ export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
  * Reuses existing managers if config matches.
  */
 export declare function getXYWebSocketManager(config: XYChannelConfig): XYWebSocketManager;
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export declare function removeXYWebSocketManager(config: XYChannelConfig): void;
 /**
  * Clear all cached WebSocket managers.
  */
@@ -18,3 +23,13 @@ export declare function clearXYWebSocketManagers(): void;
  * Get the number of cached managers.
  */
 export declare function getCachedManagerCount(): number;
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export declare function diagnoseAllManagers(): void;
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export declare function cleanupOrphanConnections(): number;

package/dist/src/client.js

@@ -34,6 +34,23 @@ export function getXYWebSocketManager(config) {
     log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export function removeXYWebSocketManager(config) {
+    const cacheKey = `${config.apiKey}-${config.agentId}`;
+    const manager = wsManagerCache.get(cacheKey);
+    if (manager) {
+        console.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        manager.disconnect();
+        wsManagerCache.delete(cacheKey);
+        console.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+    }
+    else {
+        console.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+    }
+}
 /**
  * Clear all cached WebSocket managers.
  */
@@ -51,3 +68,80 @@ export function clearXYWebSocketManagers() {
 export function getCachedManagerCount() {
     return wsManagerCache.size;
 }
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export function diagnoseAllManagers() {
+    console.log("========================================");
+    console.log("📊 WebSocket Manager Global Diagnostics");
+    console.log("========================================");
+    console.log(`Total cached managers: ${wsManagerCache.size}`);
+    console.log("");
+    if (wsManagerCache.size === 0) {
+        console.log("ℹ️  No managers in cache");
+        console.log("========================================");
+        return;
+    }
+    let orphanCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        console.log(`📌 Manager: ${key}`);
+        console.log(`   Shutting down: ${diag.isShuttingDown}`);
+        console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
+        // Server 1
+        console.log(`   🔌 Server1:`);
+        console.log(`      - Exists: ${diag.server1.exists}`);
+        console.log(`      - ReadyState: ${diag.server1.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server1.stateConnected}/${diag.server1.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server1.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server1.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server1.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server1.hasReconnectTimer}`);
+        if (diag.server1.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        // Server 2
+        console.log(`   🔌 Server2:`);
+        console.log(`      - Exists: ${diag.server2.exists}`);
+        console.log(`      - ReadyState: ${diag.server2.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server2.stateConnected}/${diag.server2.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server2.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server2.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server2.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server2.hasReconnectTimer}`);
+        if (diag.server2.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        console.log("");
+    });
+    if (orphanCount > 0) {
+        console.log(`⚠️  Total orphan connections found: ${orphanCount}`);
+        console.log(`💡 Suggestion: These connections should be cleaned up`);
+    }
+    else {
+        console.log(`✅ No orphan connections found`);
+    }
+    console.log("========================================");
+}
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export function cleanupOrphanConnections() {
+    let cleanedCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        if (diag.server1.isOrphan || diag.server2.isOrphan) {
+            console.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            manager.disconnect();
+            cleanedCount++;
+        }
+    });
+    if (cleanedCount > 0) {
+        console.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+    }
+    return cleanedCount;
+}

package/dist/src/file-download.js

@@ -8,8 +8,10 @@ import { logger } from "./utils/logger.js";
  */
 export async function downloadFile(url, destPath) {
     logger.debug(`Downloading file from ${url} to ${destPath}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 30000); // 30 seconds timeout
     try {
-        const response = await fetch(url);
+        const response = await fetch(url, { signal: controller.signal });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
@@ -19,9 +21,16 @@ export async function downloadFile(url, destPath) {
         logger.debug(`File downloaded successfully: ${destPath}`);
     }
     catch (error) {
+        if (error.name === 'AbortError') {
+            logger.error(`Download timeout (30s) for ${url}`);
+            throw new Error(`Download timeout after 30 seconds`);
+        }
         logger.error(`Failed to download file from ${url}:`, error);
         throw error;
     }
+    finally {
+        clearTimeout(timeout);
+    }
 }
 /**
  * Download files from A2A file parts.

package/dist/src/formatter.d.ts

@@ -20,6 +20,23 @@ export interface SendA2AResponseParams {
  * Send an A2A artifact update response.
  */
 export declare function sendA2AResponse(params: SendA2AResponseParams): Promise<void>;
+/**
+ * Parameters for sending a reasoning text update (intermediate, streamed).
+ */
+export interface SendReasoningTextUpdateParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    append?: boolean;
+}
+/**
+ * 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 declare function sendReasoningTextUpdate(params: SendReasoningTextUpdateParams): Promise<void>;
 /**
  * Parameters for sending a status update.
  */

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],
+                    },
                 },
             ],
         },

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,5 +1,5 @@
 import { resolveXYConfig } from "./config.js";
-import { getXYWebSocketManager } from "./client.js";
+import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
@@ -37,19 +37,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 +85,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
@@ -88,26 +105,48 @@ export async function monitorXYProvider(opts = {}) {
                 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 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();
+            // ✅ 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 +165,17 @@ export async function monitorXYProvider(opts = {}) {
         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/outbound.js

@@ -4,6 +4,39 @@ import { XYPushService } from "./push.js";
 import { getLatestSessionContext } 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.
@@ -76,8 +109,10 @@ 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 {
@@ -111,6 +146,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 +163,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,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.
  */