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

package/dist/src/formatter.js

@@ -1,15 +1,12 @@
 // 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";
 /**
  * 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 log = runtime?.log ?? console.log;
-    const errorFn = runtime?.error ?? console.error;
     // Build artifact update event
     const artifact = {
         taskId,
@@ -48,7 +45,7 @@ export async function sendA2AResponse(params) {
             code: errorCode,
             message: errorMessage ?? "任务执行异常，请重试",
         };
-        log(`[A2A_RESPONSE] ⚠️ Including error code: ${errorCode}`);
+        logger.log(`[A2A_RESPONSE] ⚠️ Including error code: ${errorCode}`);
     }
     // Send via WebSocket
     const wsManager = getXYWebSocketManager(config);
@@ -60,13 +57,13 @@ export async function sendA2AResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
-    log(`[A2A_RESPONSE]   - append: ${append}`);
-    log(`[A2A_RESPONSE]   - final: ${final}`);
-    log(`[A2A_RESPONSE]   - text: ${text.length <= 10 ? text : text.slice(0, 5) + '***' + text.slice(-5)}`);
-    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    logger.log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
+    logger.log(`[A2A_RESPONSE]   - append: ${append}`);
+    logger.log(`[A2A_RESPONSE]   - final: ${final}`);
+    logger.log(`[A2A_RESPONSE]   - text: ${text.length <= 10 ? text : text.slice(0, 5) + '***' + text.slice(-5)}`);
+    logger.log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+    logger.log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
 /**
  * Send an A2A artifact-update with reasoningText part.
@@ -75,9 +72,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",
@@ -115,9 +109,6 @@ export async function sendReasoningTextUpdate(params) {
  */
 export async function sendStatusUpdate(params) {
     const { config, sessionId, taskId, messageId, text, state } = params;
-    const runtime = getXYRuntime();
-    const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
     // Build status update event following A2A protocol standard
     const statusUpdate = {
         taskId,
@@ -152,9 +143,9 @@ export async function sendStatusUpdate(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    log(`[A2A_STATUS]   - taskId: ${taskId}`);
-    log(`[A2A_STATUS]   - text: "${text}"`);
+    logger.log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    logger.log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    logger.log(`[A2A_STATUS]   - text: "${text}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
 /**
@@ -162,9 +153,6 @@ 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;
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
@@ -201,18 +189,15 @@ export async function sendCommand(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
+    logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
     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 +223,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 +256,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 +297,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/login-token-handler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 处理 LoginTokenEvent.ClawAutoLogin 事件
+ * 将 clientId 和当前时间戳写入 .xiaoyitoken.json 文件
+ *
+ * @param context - 事件上下文，包含 event 对象
+ * @param runtime - 运行时环境
+ */
+export declare function handleLoginTokenEvent(context: any, runtime: any): void;

package/dist/src/login-token-handler.js

@@ -0,0 +1,60 @@
+// Login Token 事件处理器
+// 监听 LoginTokenEvent.ClawAutoLogin 事件，将 clientId 写入 .xiaoyitoken.json
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+/**
+ * 处理 LoginTokenEvent.ClawAutoLogin 事件
+ * 将 clientId 和当前时间戳写入 .xiaoyitoken.json 文件
+ *
+ * @param context - 事件上下文，包含 event 对象
+ * @param runtime - 运行时环境
+ */
+export function handleLoginTokenEvent(context, runtime) {
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    try {
+        const clientId = context.event?.payload?.clientId;
+        if (!clientId || typeof clientId !== "string") {
+            error("[LOGIN_TOKEN_HANDLER] invalid payload: missing clientId");
+            return;
+        }
+        log(`[LOGIN_TOKEN_HANDLER] received login token event, clientId=${clientId}`);
+        // Ensure directory exists
+        const dir = dirname(TOKEN_FILE_PATH);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        let tokens = [];
+        if (existsSync(TOKEN_FILE_PATH)) {
+            try {
+                const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                tokens = JSON.parse(content);
+                if (!Array.isArray(tokens)) {
+                    tokens = [];
+                }
+            }
+            catch {
+                tokens = [];
+            }
+        }
+        // Check if clientId already exists
+        const now = String(Date.now());
+        const existing = tokens.find((t) => t.clientId === clientId);
+        if (existing) {
+            // Update timestamp
+            existing.timestamp = now;
+            log(`[LOGIN_TOKEN_HANDLER] updated timestamp for clientId=${clientId}`);
+        }
+        else {
+            // Insert new entry
+            tokens.push({ clientId, timestamp: now });
+            log(`[LOGIN_TOKEN_HANDLER] inserted new entry for clientId=${clientId}`);
+        }
+        writeFileSync(TOKEN_FILE_PATH, JSON.stringify(tokens, null, 2), "utf-8");
+        log(`[LOGIN_TOKEN_HANDLER] wrote token file: ${TOKEN_FILE_PATH}`);
+    }
+    catch (err) {
+        error("[LOGIN_TOKEN_HANDLER] failed to handle event:", err);
+    }
+}

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,10 +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.
@@ -47,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);
@@ -137,7 +143,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) {
@@ -156,16 +162,30 @@ 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
-            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);
@@ -173,20 +193,53 @@ 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();
             // ✅ 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,
+                    }).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,15 +256,24 @@ 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)...");
+        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();

package/dist/src/outbound.js

@@ -4,6 +4,7 @@ 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";
+import { logger } from "./utils/logger.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -57,7 +58,7 @@ export const xyOutbound = {
     resolveTarget: ({ cfg, to, accountId, mode }) => {
         // If no target provided, use default marker for push delivery
         if (!to || to.trim() === "") {
-            console.log(`[xyOutbound.resolveTarget] No target specified, using default push marker`);
+            logger.log(`[xyOutbound.resolveTarget] No target specified, using default push marker`);
             return {
                 ok: true,
                 to: DEFAULT_PUSH_MARKER,
@@ -66,24 +67,24 @@ export const xyOutbound = {
         const trimmedTo = to.trim();
         // If the target doesn't contain "::", try to enhance it with taskId from session context
         if (!trimmedTo.includes("::")) {
-            console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
+            logger.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
             // Try to get the current session context
             const sessionContext = getCurrentSessionContext();
             if (sessionContext && sessionContext.sessionId === trimmedTo) {
                 const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
-                console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
+                logger.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
                 return {
                     ok: true,
                     to: enhancedTarget,
                 };
             }
             else {
-                console.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
+                logger.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
                 // Still return the original target, but it may fail in sendMedia
             }
         }
         // Otherwise, use the provided target (either already in correct format or for sendText)
-        console.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
+        logger.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
         return {
             ok: true,
             to: trimmedTo,
@@ -95,36 +96,36 @@ export const xyOutbound = {
         // Handle default push marker (for cron jobs without explicit target)
         let actualTo = to;
         if (to === DEFAULT_PUSH_MARKER) {
-            console.log(`[xyOutbound.sendText] Using default push delivery (no specific target)`);
+            logger.log(`[xyOutbound.sendText] Using default push delivery (no specific target)`);
             // For push notifications, we don't need a specific target
             // The push service will handle it based on config
             actualTo = config.defaultSessionId || "";
         }
         // 1. 持久化推送消息内容，获取 pushDataId
-        console.log(`[xyOutbound.sendText] Saving push data to local storage...`);
+        logger.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.substring(0, 20)}`);
+            logger.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId.substring(0, 20)}`);
         }
         catch (error) {
-            console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
+            logger.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
             // 如果持久化失败，仍然继续发送（不阻塞主流程）
             pushDataId = "";
         }
         // 2. 读取所有 pushId
-        console.log(`[xyOutbound.sendText] Loading all pushIds...`);
+        logger.log(`[xyOutbound.sendText] Loading all pushIds...`);
         let pushIdList = [];
         try {
             pushIdList = await getAllPushIds();
-            console.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
+            logger.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
         }
         catch (error) {
-            console.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
+            logger.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`);
+            logger.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
             pushIdList = [config.pushId];
         }
         // Create push service
@@ -134,7 +135,7 @@ export const xyOutbound = {
         // Truncate push content to max length 1000
         const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
         // 4. 遍历所有 pushId，依次发送推送通知
-        console.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
+        logger.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
         let successCount = 0;
         let failureCount = 0;
         for (const pushId of pushIdList) {
@@ -142,11 +143,11 @@ export const xyOutbound = {
                 // 传入 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)}...`);
+                logger.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);
+                logger.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
                 // 单个 pushId 发送失败不影响其他，继续处理下一个
             }
         }
@@ -178,7 +179,7 @@ export const xyOutbound = {
         if (!fileId) {
             throw new Error(`File upload returned empty fileId for: ${mediaUrl}`);
         }
-        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+        logger.log(`[xyOutbound.sendMedia] File uploaded:`, {
             fileId,
             sessionId,
             taskId,
@@ -222,7 +223,7 @@ export const xyOutbound = {
         const { getXYWebSocketManager } = await import("./client.js");
         const wsManager = getXYWebSocketManager(config);
         await wsManager.sendMessage(sessionId, agentResponse);
-        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        logger.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",

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;