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

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

@@ -2,8 +2,11 @@ import { resolveXYConfig } from "./config.js";
 import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
-import { hasActiveTask } from "./task-manager.js";
+import { 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";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
@@ -156,6 +159,20 @@ export async function monitorXYProvider(opts = {}) {
                 error(`[MONITOR] Failed to handle trigger-event:`, err);
             });
         };
+        const selfEvolutionHandler = (context) => {
+            log(`[MONITOR] Received self-evolution-event, dispatching to handler...`);
+            handleSelfEvolutionEvent(context, runtime);
+        };
+        const selfEvolutionStateGetHandler = (context) => {
+            log(`[MONITOR] Received self-evolution-state-get-event, dispatching to handler...`);
+            handleSelfEvolutionStateGetEvent(context, account, runtime, wsManager).catch((err) => {
+                error(`[MONITOR] Failed to handle self-evolution-state-get-event:`, err);
+            });
+        };
+        const loginTokenEventHandler = (context) => {
+            log(`[MONITOR] Received login-token-event, dispatching to handler...`);
+            handleLoginTokenEvent(context, runtime);
+        };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
@@ -173,6 +190,9 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
             wsManager.off("trigger-event", triggerEventHandler);
+            wsManager.off("self-evolution-event", selfEvolutionHandler);
+            wsManager.off("self-evolution-state-get-event", selfEvolutionStateGetHandler);
+            wsManager.off("login-token-event", loginTokenEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -185,8 +205,36 @@ export async function monitorXYProvider(opts = {}) {
             console.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,
+                    }).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();
@@ -203,6 +251,9 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
         wsManager.on("trigger-event", triggerEventHandler);
+        wsManager.on("self-evolution-event", selfEvolutionHandler);
+        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)...");
         healthCheckInterval = setInterval(() => {

package/dist/src/outbound.js

@@ -174,14 +174,9 @@ export const xyOutbound = {
         }
         // Upload file
         const fileId = await uploadService.uploadFile(mediaUrl);
-        // Check if fileId is empty
+        // Check if fileId is empty (should not happen if uploadFile throws on failure)
         if (!fileId) {
-            console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
-            return {
-                channel: "xiaoyi-channel",
-                messageId: "",
-                chatId: to,
-            };
+            throw new Error(`File upload returned empty fileId for: ${mediaUrl}`);
         }
         console.log(`[xyOutbound.sendMedia] File uploaded:`, {
             fileId,

package/dist/src/provider.d.ts

@@ -1,2 +1,3 @@
-import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-models";
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-model-shared";
+export declare function applySelfEvolutionPrompt(systemPrompt: string | undefined, enabled: boolean): string;
 export declare const xiaoyiProvider: ProviderPlugin;