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

package/dist/src/file-upload.js

@@ -3,13 +3,14 @@
 import fetch from "node-fetch";
 import fs from "fs/promises";
 import os from "os";
+import { logger } from "./utils/logger.js";
 import path from "path";
 import { calculateSHA256 } from "./utils/crypto.js";
 function isRemoteUrl(filePath) {
     return filePath.startsWith("http://") || filePath.startsWith("https://");
 }
 async function downloadToTempFile(url) {
-    console.log(`[XY File Upload] Downloading remote file: ${url}`);
+    logger.log(`[XY File Upload] Downloading remote file: ${url}`);
     const response = await fetch(url);
     if (!response.ok) {
         throw new Error(`Failed to download remote file: HTTP ${response.status}`);
@@ -18,7 +19,7 @@ async function downloadToTempFile(url) {
     const urlFileName = path.basename(new URL(url).pathname) || "download";
     const tempPath = path.join(os.tmpdir(), `xy-upload-${Date.now()}-${urlFileName}`);
     await fs.writeFile(tempPath, buffer);
-    console.log(`[XY File Upload] Downloaded to temp file: ${tempPath}`);
+    logger.log(`[XY File Upload] Downloaded to temp file: ${tempPath}`);
     return tempPath;
 }
 /**
@@ -39,7 +40,7 @@ export class XYFileUploadService {
      * Returns the objectId (as fileId) for use in A2A messages.
      */
     async uploadFile(filePath, objectType = "TEMPORARY_MATERIAL_DOC") {
-        console.log(`[XY File Upload] Starting file upload: ${filePath}`);
+        logger.log(`[XY File Upload] Starting file upload: ${filePath}`);
         let localFilePath = filePath;
         let isTempFile = false;
         try {
@@ -54,7 +55,7 @@ export class XYFileUploadService {
             const fileSha256 = calculateSHA256(fileBuffer);
             const fileSize = fileBuffer.length;
             // Phase 1: Prepare
-            console.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
+            logger.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
             const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
                 method: "POST",
                 headers: {
@@ -84,7 +85,7 @@ export class XYFileUploadService {
             }
             const { objectId, draftId, uploadInfos } = prepareData;
             // Phase 2: Upload
-            console.log(`[XY File Upload] Phase 2: Upload file data`);
+            logger.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,
@@ -95,9 +96,9 @@ export class XYFileUploadService {
                 const uploadErrorText = await uploadResp.text();
                 throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
             }
-            console.log(`[XY File Upload] Upload complete`);
+            logger.log(`[XY File Upload] Upload complete`);
             // Phase 3: Complete
-            console.log(`[XY File Upload] Phase 3: Complete upload`);
+            logger.log(`[XY File Upload] Phase 3: Complete upload`);
             const completeResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/complete`, {
                 method: "POST",
                 headers: {
@@ -115,11 +116,11 @@ export class XYFileUploadService {
                 throw new Error(`Complete failed: HTTP ${completeResp.status}`);
             }
             const completeData = await completeResp.json();
-            console.log(`[XY File Upload] File upload successful: ${fileName} → objectId=${objectId}`);
+            logger.log(`[XY File Upload] File upload successful: ${fileName} → objectId=${objectId}`);
             return objectId;
         }
         catch (error) {
-            console.error(`[XY File Upload] File upload failed for ${filePath}:`, error);
+            logger.error(`[XY File Upload] File upload failed for ${filePath}:`, error);
             throw error;
         }
         finally {
@@ -150,7 +151,7 @@ export class XYFileUploadService {
             const fileSha256 = calculateSHA256(fileBuffer);
             const fileSize = fileBuffer.length;
             // Phase 1: Prepare
-            console.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
+            logger.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
             const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
                 method: "POST",
                 headers: {
@@ -179,23 +180,23 @@ export class XYFileUploadService {
                 throw new Error(`Prepare failed: ${prepareData.desc}`);
             }
             const { objectId, draftId, uploadInfos } = prepareData;
-            console.log(`[XY File Upload] Prepare complete: objectId=${objectId}, draftId=${draftId}`);
+            logger.log(`[XY File Upload] Prepare complete: objectId=${objectId}, draftId=${draftId}`);
             // Phase 2: Upload
-            console.log(`[XY File Upload] Phase 2: Upload file data`);
+            logger.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}`);
+            logger.log(`[XY File Upload] Upload response status: ${uploadResp.status}`);
             if (!uploadResp.ok) {
                 const uploadErrorText = await uploadResp.text();
                 throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
             }
-            console.log(`[XY File Upload] Upload complete`);
+            logger.log(`[XY File Upload] Upload complete`);
             // Phase 3: CompleteAndQuery - get file URL
-            console.log(`[XY File Upload] Phase 3: CompleteAndQuery to get file URL`);
+            logger.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: {
@@ -218,11 +219,11 @@ export class XYFileUploadService {
             if (!fileUrl) {
                 throw new Error("No file URL returned from completeAndQuery");
             }
-            console.log(`[XY File Upload] File upload successful`);
+            logger.log(`[XY File Upload] File upload successful`);
             return fileUrl;
         }
         catch (error) {
-            console.error(`[XY File Upload] File upload with URL retrieval failed for ${filePath}:`, error);
+            logger.error(`[XY File Upload] File upload with URL retrieval failed for ${filePath}:`, error);
             throw error;
         }
         finally {
@@ -249,7 +250,7 @@ export class XYFileUploadService {
                 });
             }
             catch (error) {
-                console.error(`[XY File Upload] Failed to upload ${filePath}, skipping:`, error);
+                logger.error(`[XY File Upload] Failed to upload ${filePath}, skipping:`, error);
                 // Continue with other files
             }
         }

package/dist/src/formatter.d.ts

@@ -17,6 +17,7 @@ export interface SendA2AResponseParams {
     }>;
     errorCode?: number | string;
     errorMessage?: string;
+    runtime?: any;
 }
 /**
  * Send an A2A artifact update response.
@@ -49,6 +50,7 @@ export interface SendStatusUpdateParams {
     messageId: string;
     text: string;
     state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+    runtime?: any;
 }
 /**
  * Send an A2A task status update.

package/dist/src/formatter.js

@@ -1,15 +1,14 @@
 // OpenClaw → A2A format conversion
 import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
-import { getXYRuntime } from "./runtime.js";
+import { logger } from "./utils/logger.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 /**
  * Send an A2A artifact update response.
  */
 export async function sendA2AResponse(params) {
-    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage } = params;
-    const runtime = getXYRuntime();
+    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage, runtime } = params;
     const log = runtime?.log ?? console.log;
-    const errorFn = runtime?.error ?? console.error;
     // Build artifact update event
     const artifact = {
         taskId,
@@ -75,9 +74,6 @@ export async function sendA2AResponse(params) {
  */
 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",
@@ -114,13 +110,15 @@ export async function sendReasoningTextUpdate(params) {
  * Follows A2A protocol standard format with nested status object.
  */
 export async function sendStatusUpdate(params) {
-    const { config, sessionId, taskId, messageId, text, state } = params;
-    const runtime = getXYRuntime();
+    const { config, sessionId, taskId, messageId, text, state, runtime } = params;
     const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
+    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
+    // fall back to closure-captured values
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build status update event following A2A protocol standard
     const statusUpdate = {
-        taskId,
+        taskId: currentTaskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
@@ -139,7 +137,7 @@ export async function sendStatusUpdate(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: statusUpdate,
     };
     // Send via WebSocket
@@ -148,12 +146,12 @@ export async function sendStatusUpdate(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
     log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - taskId: ${currentTaskId}`);
     log(`[A2A_STATUS]   - text: "${text}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
@@ -162,13 +160,14 @@ export async function sendStatusUpdate(params) {
  */
 export async function sendCommand(params) {
     const { config, sessionId, taskId, messageId, command } = params;
-    const runtime = getXYRuntime();
-    const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
+    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
+    // fall back to closure-captured values
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
-        taskId,
+        taskId: currentTaskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -188,7 +187,7 @@ export async function sendCommand(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -197,22 +196,19 @@ export async function sendCommand(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
+    logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${currentTaskId}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`[A2A_COMMAND] ✅ Command sent successfully`);
+    logger.log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }
 /**
  * Send a clearContext response.
  */
 export async function sendClearContextResponse(params) {
     const { config, sessionId, messageId } = params;
-    const runtime = getXYRuntime();
-    const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
     // Build JSON-RPC response for clearContext
     const jsonRpcResponse = {
         jsonrpc: "2.0",
@@ -238,16 +234,13 @@ export async function sendClearContextResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent clearContext response: sessionId=${sessionId}`);
+    logger.log(`Sent clearContext response: sessionId=${sessionId}`);
 }
 /**
  * Send a tasks/cancel response.
  */
 export async function sendTasksCancelResponse(params) {
     const { config, sessionId, taskId, messageId } = params;
-    const runtime = getXYRuntime();
-    const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
     // Build JSON-RPC response for tasks/cancel
     // Note: Using any to bypass type check as the response format differs from standard A2A types
     const jsonRpcResponse = {
@@ -274,16 +267,13 @@ export async function sendTasksCancelResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
+    logger.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",
@@ -318,7 +308,7 @@ export async function sendTriggerResponse(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    log(`[TRIGGER_RESPONSE] Sending Trigger response: sessionId=${sessionId}, taskId=${taskId}`);
+    logger.log(`[TRIGGER_RESPONSE] Sending Trigger response: sessionId=${sessionId}, taskId=${taskId}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
+    logger.log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
 }

package/dist/src/heartbeat.js

@@ -67,7 +67,7 @@ export class HeartbeatManager {
      */
     sendHeartbeat() {
         if (this.ws.readyState !== WebSocket.OPEN) {
-            console.warn(`Cannot send heartbeat for ${this.serverName}: WebSocket not open`);
+            this.log(`Cannot send heartbeat for ${this.serverName}: WebSocket not open`);
             return;
         }
         try {

package/dist/src/message-queue.d.ts

@@ -0,0 +1,17 @@
+import type { OutboundWebSocketMessage } from "./types.js";
+/**
+ * Simple message queue for buffering outbound WebSocket messages
+ * during disconnection and reconnection stabilization period.
+ */
+export declare class MessageQueue {
+    private items;
+    private log;
+    constructor(log?: (msg: string, ...args: any[]) => void);
+    /** Enqueue a message. Drops oldest if over limit. */
+    enqueue(message: OutboundWebSocketMessage): void;
+    /** Flush all queued messages by calling sendFn for each, then clear. */
+    flush(sendFn: (message: OutboundWebSocketMessage) => void): void;
+    /** Clear all queued messages without sending. */
+    clear(): void;
+    get size(): number;
+}

package/dist/src/message-queue.js

@@ -0,0 +1,51 @@
+const MAX_QUEUE_SIZE = 1000;
+/**
+ * Simple message queue for buffering outbound WebSocket messages
+ * during disconnection and reconnection stabilization period.
+ */
+export class MessageQueue {
+    items = [];
+    log;
+    constructor(log) {
+        this.log = log ?? console.log;
+    }
+    /** Enqueue a message. Drops oldest if over limit. */
+    enqueue(message) {
+        if (this.items.length >= MAX_QUEUE_SIZE) {
+            this.log(`[MessageQueue] Queue full (${MAX_QUEUE_SIZE}), dropping oldest message`);
+            this.items.shift();
+        }
+        this.items.push(message);
+        this.log(`[MessageQueue] Enqueued message, queue size: ${this.items.length}`);
+    }
+    /** Flush all queued messages by calling sendFn for each, then clear. */
+    flush(sendFn) {
+        const count = this.items.length;
+        if (count === 0) {
+            this.log("[MessageQueue] Queue empty, nothing to flush");
+            return;
+        }
+        this.log(`[MessageQueue] Flushing ${count} queued messages`);
+        for (const msg of this.items) {
+            try {
+                sendFn(msg);
+            }
+            catch (err) {
+                this.log(`[MessageQueue] Error flushing message: ${err}`);
+            }
+        }
+        this.items = [];
+        this.log(`[MessageQueue] Flush complete`);
+    }
+    /** Clear all queued messages without sending. */
+    clear() {
+        const count = this.items.length;
+        this.items = [];
+        if (count > 0) {
+            this.log(`[MessageQueue] Cleared ${count} messages`);
+        }
+    }
+    get size() {
+        return this.items.length;
+    }
+}

package/dist/src/monitor.js

@@ -1,12 +1,14 @@
 import { resolveXYConfig } from "./config.js";
-import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
+import { getXYWebSocketManager, setClientRuntime, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
-import { hasActiveTask } from "./task-manager.js";
+import { hasActiveTask, getAllActiveTaskBindings } from "./task-manager.js";
+import { sendA2AResponse } from "./formatter.js";
 import { handleTriggerEvent } from "./trigger-handler.js";
 import { handleSelfEvolutionEvent, handleSelfEvolutionStateGetEvent } from "./self-evolution-handler.js";
 import { handleLoginTokenEvent } from "./login-token-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
+import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./tools/session-manager.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -49,8 +51,10 @@ export async function monitorXYProvider(opts = {}) {
             opts.setStatus({ lastEventAt: Date.now(), lastInboundAt: Date.now() });
         }
         : undefined;
+    // ✅ Set runtime for WebSocket manager logging before creating/getting manager
+    setClientRuntime(runtime);
     // 🔍 Diagnose WebSocket managers before gateway start
-    console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
     diagnoseAllManagers();
     // Get WebSocket manager (cached)
     const wsManager = getXYWebSocketManager(account);
@@ -64,6 +68,12 @@ export async function monitorXYProvider(opts = {}) {
     const activeMessages = new Set();
     // Create session queue for ordered message processing
     const enqueue = createSessionQueue();
+    // Global gate that serializes dispatch initialization across sessions.
+    // When a new session starts dispatching, it acquires this gate and holds it
+    // until agent setup (agentTools + wrapStreamFn) is complete, then releases it.
+    // This prevents lastRegisteredKey races when multiple sessions initialize
+    // concurrently.
+    let globalDispatchInitGate = Promise.resolve();
     // Health check interval
     let healthCheckInterval = null;
     return new Promise((resolve, reject) => {
@@ -79,6 +89,11 @@ export async function monitorXYProvider(opts = {}) {
             }
             activeMessages.add(messageKey);
             const task = async () => {
+                // Wait for the previous session's init to complete (global gate),
+                // then acquire the gate for this session's init.
+                await globalDispatchInitGate;
+                let releaseGate;
+                globalDispatchInitGate = new Promise((r) => { releaseGate = r; });
                 try {
                     await handleXYMessage({
                         cfg,
@@ -86,10 +101,12 @@ export async function monitorXYProvider(opts = {}) {
                         message,
                         accountId, // ✅ Pass accountId ("default")
                         webSocketSessionId: sessionId, // ✅ 传递 WebSocket 层级的 sessionId
+                        onInitComplete: () => releaseGate(),
                     });
                 }
                 catch (err) {
                     // ✅ Only log error, don't re-throw to prevent gateway restart
+                    releaseGate();
                     error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
                 }
                 finally {
@@ -139,7 +156,7 @@ export async function monitorXYProvider(opts = {}) {
             opts.setStatus?.({ connected: true });
         };
         const disconnectedHandler = (serverId) => {
-            console.warn(`XY gateway: ${serverId} disconnected`);
+            log(`XY gateway: ${serverId} disconnected`);
             loggedServers.delete(serverId);
             // ✅ Report disconnection status (only if all servers disconnected)
             if (loggedServers.size === 0) {
@@ -164,7 +181,7 @@ export async function monitorXYProvider(opts = {}) {
         };
         const selfEvolutionStateGetHandler = (context) => {
             log(`[MONITOR] Received self-evolution-state-get-event, dispatching to handler...`);
-            handleSelfEvolutionStateGetEvent(context, cfg, runtime, wsManager).catch((err) => {
+            handleSelfEvolutionStateGetEvent(context, account, runtime, wsManager).catch((err) => {
                 error(`[MONITOR] Failed to handle self-evolution-state-get-event:`, err);
             });
         };
@@ -175,13 +192,13 @@ export async function monitorXYProvider(opts = {}) {
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
-            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
+            log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
             diagnoseAllManagers();
             // Stop health check interval
             if (healthCheckInterval) {
                 clearInterval(healthCheckInterval);
                 healthCheckInterval = null;
-                console.log("⏸️  Stopped periodic health check");
+                log("⏸️  Stopped periodic health check");
             }
             // Remove event handlers to prevent duplicate calls on gateway restart
             wsManager.off("message", messageHandler);
@@ -197,15 +214,46 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.disconnect();
             // ✅ Remove manager from cache to prevent reusing dirty state
             removeXYWebSocketManager(account);
+            // Clean up all active sessions
+            cleanupAllSessions();
             loggedServers.clear();
             activeMessages.clear();
-            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages and sessions`);
             // 🔍 Diagnose after cleanup
-            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
+            log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
             diagnoseAllManagers();
         };
-        const handleAbort = () => {
-            log("XY gateway: abort signal received, stopping");
+        const handleAbort = async () => {
+            log("XY gateway: abort signal received, sending notifications before stopping");
+            // 📤 Send restart notification to all active sessions before disconnecting
+            try {
+                const activeBindings = getAllActiveTaskBindings();
+                if (activeBindings.length > 0) {
+                    const config = resolveXYConfig(cfg);
+                    const notificationText = "Gateway即将重启，重启期间可能短暂出现\u201c环境异常\u201d提示，请稍候并耐心重试~";
+                    log(`[MONITOR] 📤 Sending restart notifications to ${activeBindings.length} active session(s)`);
+                    const sendPromises = activeBindings.map(binding => sendA2AResponse({
+                        config,
+                        sessionId: binding.sessionId,
+                        taskId: binding.currentTaskId,
+                        messageId: binding.currentMessageId,
+                        text: notificationText,
+                        append: false,
+                        final: true,
+                        runtime,
+                    }).catch(err => {
+                        error(`[MONITOR] Failed to send restart notification to session ${binding.sessionId}: ${String(err)}`);
+                    }));
+                    await Promise.all(sendPromises);
+                    log(`[MONITOR] ✅ Restart notifications sent to ${activeBindings.length} session(s)`);
+                }
+                else {
+                    log(`[MONITOR] No active sessions, skipping restart notifications`);
+                }
+            }
+            catch (err) {
+                error(`[MONITOR] Error sending restart notifications: ${String(err)}`);
+            }
             cleanup();
             log("XY gateway stopped");
             resolve();
@@ -226,14 +274,20 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("self-evolution-state-get-event", selfEvolutionStateGetHandler);
         wsManager.on("login-token-event", loginTokenEventHandler);
         // Start periodic health check (every 6 hours)
-        console.log("🏥 Starting periodic health check (every 6 hours)...");
+        log("🏥 Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {
-            console.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
+            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`);
+                log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+            }
+            // Cleanup stale sessions (older than 10min TTL)
+            const cleanedSessions = cleanupStaleSessions();
+            const remainingSessions = getActiveSessionCount();
+            if (cleanedSessions > 0 || remainingSessions > 0) {
+                log(`🧹 [HEALTH CHECK] Sessions: cleaned=${cleanedSessions}, active=${remainingSessions}`);
             }
             // Cleanup stale temp files (older than 24 hours)
             void cleanupStaleTempFiles();