@ynhcj/xiaoyi 2.5.4 → 2.5.6

package/dist/config-schema.d.ts

@@ -8,8 +8,10 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     /** Whether this channel is enabled */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** WebSocket URL for A2A connection */
-    wsUrl: z.ZodOptional<z.ZodString>;
+    /** First WebSocket server URL */
+    wsUrl1: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Second WebSocket server URL */
+    wsUrl2: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     /** Access Key for authentication */
     ak: z.ZodOptional<z.ZodString>;
     /** Secret Key for authentication */
@@ -18,27 +20,25 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     agentId: z.ZodOptional<z.ZodString>;
     /** Enable debug logging */
     debug: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** Enable streaming responses (default: false) */
-    enableStreaming: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     /** Multi-account configuration */
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;
 }, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;

package/dist/config-schema.js

@@ -10,9 +10,11 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     /** Account name (optional display name) */
     name: zod_1.z.string().optional(),
     /** Whether this channel is enabled */
-    enabled: zod_1.z.boolean().optional().default(true),
-    /** WebSocket URL for A2A connection */
-    wsUrl: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean().optional().default(false),
+    /** First WebSocket server URL */
+    wsUrl1: zod_1.z.string().optional().default("wss://hag.cloud.huawei.com/openclaw/v1/ws/link"),
+    /** Second WebSocket server URL */
+    wsUrl2: zod_1.z.string().optional().default("wss://116.63.174.231/openclaw/v1/ws/link"),
     /** Access Key for authentication */
     ak: zod_1.z.string().optional(),
     /** Secret Key for authentication */
@@ -21,8 +23,6 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     agentId: zod_1.z.string().optional(),
     /** Enable debug logging */
     debug: zod_1.z.boolean().optional().default(false),
-    /** Enable streaming responses (default: false) */
-    enableStreaming: zod_1.z.boolean().optional().default(false),
     /** Multi-account configuration */
     accounts: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });

package/dist/index.d.ts

@@ -14,13 +14,10 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 declare const plugin: {
     id: string;

package/dist/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const plugin_sdk_1 = require("openclaw/plugin-sdk");
 const channel_1 = require("./channel");
 const runtime_1 = require("./runtime");
 /**
@@ -18,19 +17,16 @@ const runtime_1 = require("./runtime");
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 const plugin = {
     id: "xiaoyi",
     name: "XiaoYi Channel",
     description: "XiaoYi channel plugin with A2A protocol support",
-    configSchema: (0, plugin_sdk_1.emptyPluginConfigSchema)(),
+    configSchema: undefined,
     register(api) {
         console.log("XiaoYi: register() called - START");
         // Set runtime for managing WebSocket connections

package/dist/push.d.ts

@@ -0,0 +1,28 @@
+import { XiaoYiChannelConfig } from "./types";
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+export declare class XiaoYiPushService {
+    private config;
+    private readonly pushUrl;
+    constructor(config: XiaoYiChannelConfig);
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    private generateSignature;
+    /**
+     * Generate UUID
+     */
+    private generateUUID;
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    sendPush(text: string, pushText: string): Promise<boolean>;
+}

package/dist/push.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XiaoYiPushService = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+class XiaoYiPushService {
+    constructor(config) {
+        this.pushUrl = "https://hag.cloud.huawei.com/open-ability-agent/v1/agent-webhook";
+        this.config = config;
+    }
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured() {
+        return Boolean(this.config.apiId?.trim() &&
+            this.config.pushId?.trim() &&
+            this.config.ak?.trim() &&
+            this.config.sk?.trim());
+    }
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    generateSignature(timestamp) {
+        const hmac = crypto.createHmac("sha256", this.config.sk);
+        hmac.update(timestamp);
+        return hmac.digest().toString("base64");
+    }
+    /**
+     * Generate UUID
+     */
+    generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    async sendPush(text, pushText) {
+        if (!this.isConfigured()) {
+            console.log("[PUSH] Push not configured, skipping");
+            return false;
+        }
+        try {
+            const timestamp = Date.now().toString();
+            const signature = this.generateSignature(timestamp);
+            const messageId = this.generateUUID();
+            const payload = {
+                jsonrpc: "2.0",
+                id: messageId,
+                result: {
+                    id: this.generateUUID(),
+                    apiId: this.config.apiId,
+                    pushId: this.config.pushId,
+                    pushText: pushText,
+                    kind: "task",
+                    artifacts: [{
+                            artifactId: this.generateUUID(),
+                            parts: [{
+                                    kind: "text",
+                                    text: text, // Summary text
+                                }]
+                        }],
+                    status: { state: "completed" }
+                }
+            };
+            console.log(`[PUSH] Sending push notification: ${pushText}`);
+            const response = await fetch(this.pushUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "x-hag-trace-id": this.generateUUID(),
+                    "X-Access-Key": this.config.ak,
+                    "X-Sign": signature,
+                    "X-Ts": timestamp,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok) {
+                console.log("[PUSH] Push notification sent successfully");
+                return true;
+            }
+            else {
+                console.error(`[PUSH] Failed: HTTP ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("[PUSH] Error:", error);
+            return false;
+        }
+    }
+}
+exports.XiaoYiPushService = XiaoYiPushService;

package/dist/runtime.d.ts

@@ -23,6 +23,11 @@ export declare class XiaoYiRuntime {
     private timeoutConfig;
     private sessionAbortControllerMap;
     private sessionActiveRunMap;
+    private sessionStartTimeMap;
+    private static readonly SESSION_STALE_TIMEOUT_MS;
+    private sessionTaskTimeoutMap;
+    private sessionPushPendingMap;
+    private taskTimeoutMs;
     constructor();
     getInstanceId(): string;
     /**
@@ -115,6 +120,7 @@ export declare class XiaoYiRuntime {
     } | null;
     /**
      * Check if a session has an active agent run
+     * If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
      * @param sessionId - Session ID
      * @returns true if session is busy
      */
@@ -140,6 +146,46 @@ export declare class XiaoYiRuntime {
      * Clear all AbortControllers
      */
     clearAllAbortControllers(): void;
+    /**
+     * Generate a composite key for session+task combination
+     * This ensures each task has its own push state, even within the same session
+     */
+    private getPushStateKey;
+    /**
+     * Set task timeout time (from configuration)
+     */
+    setTaskTimeout(timeoutMs: number): void;
+    /**
+     * Set a 1-hour task timeout timer for a session
+     * @returns timeout ID
+     */
+    setTaskTimeoutForSession(sessionId: string, taskId: string, callback: (sessionId: string, taskId: string) => void): NodeJS.Timeout;
+    /**
+     * Clear the task timeout timer for a session
+     */
+    clearTaskTimeoutForSession(sessionId: string): void;
+    /**
+     * Check if session+task is waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    isSessionWaitingForPush(sessionId: string, taskId?: string): boolean;
+    /**
+     * Mark session+task as waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    markSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear the waiting push state for a session+task
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    clearSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear all task timeout related state for a session
+     */
+    clearTaskTimeoutState(sessionId: string): void;
 }
 export declare function getXiaoYiRuntime(): XiaoYiRuntime;
 export declare function setXiaoYiRuntime(runtime: any): void;

package/dist/runtime.js

@@ -30,6 +30,12 @@ class XiaoYiRuntime {
         this.sessionAbortControllerMap = new Map();
         // Track if a session has an active agent run (for concurrent request detection)
         this.sessionActiveRunMap = new Map();
+        // Track session start time for timeout detection
+        this.sessionStartTimeMap = new Map();
+        // 1-hour task timeout mechanism
+        this.sessionTaskTimeoutMap = new Map();
+        this.sessionPushPendingMap = new Map();
+        this.taskTimeoutMs = 3600000; // Default 1 hour
         this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
     }
@@ -106,6 +112,10 @@ class XiaoYiRuntime {
         this.clearAllTimeouts();
         // Clear all abort controllers
         this.clearAllAbortControllers();
+        // Clear all task timeout state
+        for (const sessionId of this.sessionTaskTimeoutMap.keys()) {
+            this.clearTaskTimeoutState(sessionId);
+        }
     }
     /**
      * Set timeout configuration
@@ -246,16 +256,35 @@ class XiaoYiRuntime {
         const controller = new AbortController();
         this.sessionAbortControllerMap.set(sessionId, controller);
         this.sessionActiveRunMap.set(sessionId, true);
+        this.sessionStartTimeMap.set(sessionId, Date.now());
         console.log(`[ABORT] Created AbortController for session ${sessionId}`);
         return { controller, signal: controller.signal };
     }
     /**
      * Check if a session has an active agent run
+     * If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
      * @param sessionId - Session ID
      * @returns true if session is busy
      */
     isSessionActive(sessionId) {
-        return this.sessionActiveRunMap.get(sessionId) || false;
+        const isActive = this.sessionActiveRunMap.get(sessionId) || false;
+        if (isActive) {
+            // Check if the session has been active for too long
+            const startTime = this.sessionStartTimeMap.get(sessionId);
+            if (startTime) {
+                const elapsed = Date.now() - startTime;
+                if (elapsed > XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS) {
+                    // Session is stale, auto-cleanup and return false
+                    console.log(`[CONCURRENT] Session ${sessionId} is stale (active for ${elapsed}ms), auto-cleaning`);
+                    this.clearAbortControllerForSession(sessionId);
+                    this.clearTaskIdForSession(sessionId);
+                    this.clearSessionTimeout(sessionId);
+                    this.sessionStartTimeMap.delete(sessionId);
+                    return false;
+                }
+            }
+        }
+        return isActive;
     }
     /**
      * Abort a session's agent run
@@ -294,6 +323,8 @@ class XiaoYiRuntime {
         }
         // Also clear the active run flag
         this.sessionActiveRunMap.delete(sessionId);
+        // Clear the session start time
+        this.sessionStartTimeMap.delete(sessionId);
         console.log(`[CONCURRENT] Session ${sessionId} marked as inactive`);
     }
     /**
@@ -303,8 +334,91 @@ class XiaoYiRuntime {
         this.sessionAbortControllerMap.clear();
         console.log("[ABORT] All AbortControllers cleared");
     }
+    // ==================== PUSH STATE MANAGEMENT HELPERS ====================
+    /**
+     * Generate a composite key for session+task combination
+     * This ensures each task has its own push state, even within the same session
+     */
+    getPushStateKey(sessionId, taskId) {
+        return `${sessionId}:${taskId}`;
+    }
+    // ==================== END PUSH STATE MANAGEMENT HELPERS ====================
+    // ==================== 1-HOUR TASK TIMEOUT METHODS ====================
+    /**
+     * Set task timeout time (from configuration)
+     */
+    setTaskTimeout(timeoutMs) {
+        this.taskTimeoutMs = timeoutMs;
+        console.log(`[TASK TIMEOUT] Task timeout set to ${timeoutMs}ms`);
+    }
+    /**
+     * Set a 1-hour task timeout timer for a session
+     * @returns timeout ID
+     */
+    setTaskTimeoutForSession(sessionId, taskId, callback) {
+        this.clearTaskTimeoutForSession(sessionId);
+        const timeoutId = setTimeout(() => {
+            console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms timeout triggered for session ${sessionId}, task ${taskId}`);
+            callback(sessionId, taskId);
+        }, this.taskTimeoutMs);
+        this.sessionTaskTimeoutMap.set(sessionId, timeoutId);
+        console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms task timeout started for session ${sessionId}`);
+        return timeoutId;
+    }
+    /**
+     * Clear the task timeout timer for a session
+     */
+    clearTaskTimeoutForSession(sessionId) {
+        const timeoutId = this.sessionTaskTimeoutMap.get(sessionId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            this.sessionTaskTimeoutMap.delete(sessionId);
+            console.log(`[TASK TIMEOUT] Timeout cleared for session ${sessionId}`);
+        }
+    }
+    /**
+     * Check if session+task is waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    isSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        return this.sessionPushPendingMap.get(key) === true;
+    }
+    /**
+     * Mark session+task as waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    markSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        this.sessionPushPendingMap.set(key, true);
+        const taskInfo = taskId ? `, task ${taskId}` : '';
+        console.log(`[PUSH] Session ${sessionId}${taskInfo} marked as waiting for push`);
+    }
+    /**
+     * Clear the waiting push state for a session+task
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    clearSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        this.sessionPushPendingMap.delete(key);
+        const taskInfo = taskId ? `, task ${taskId}` : '';
+        console.log(`[PUSH] Session ${sessionId}${taskInfo} cleared from waiting for push`);
+    }
+    /**
+     * Clear all task timeout related state for a session
+     */
+    clearTaskTimeoutState(sessionId) {
+        this.clearTaskTimeoutForSession(sessionId);
+        this.clearSessionWaitingForPush(sessionId);
+        console.log(`[TASK TIMEOUT] All timeout state cleared for session ${sessionId}`);
+    }
 }
 exports.XiaoYiRuntime = XiaoYiRuntime;
+// Maximum time a session can be active before we consider it stale (5 minutes)
+XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS = 5 * 60 * 1000;
 // Global runtime instance - use global object to survive module reloads
 // CRITICAL: Use string key instead of Symbol to ensure consistency across module reloads
 const GLOBAL_KEY = '__xiaoyi_runtime_instance__';

package/dist/types.d.ts

@@ -152,6 +152,15 @@ export interface XiaoYiChannelConfig {
     sk: string;
     agentId: string;
     enableStreaming?: boolean;
+    apiId?: string;
+    pushId?: string;
+    taskTimeoutMs?: number;
+    /**
+     * Session cleanup timeout in milliseconds
+     * When user clears context, old sessions are cleaned up after this timeout
+     * Default: 1 hour (60 * 60 * 1000)
+     */
+    sessionCleanupTimeoutMs?: number;
 }
 export interface AuthCredentials {
     ak: string;
@@ -176,6 +185,7 @@ export interface InternalWebSocketConfig {
     ak: string;
     sk: string;
     enableStreaming?: boolean;
+    sessionCleanupTimeoutMs?: number;
 }
 export type ServerId = 'server1' | 'server2';
 export interface ServerConnectionState {
@@ -184,3 +194,14 @@ export interface ServerConnectionState {
     lastHeartbeat: number;
     reconnectAttempts: number;
 }
+/**
+ * Session cleanup state for delayed cleanup
+ */
+export interface SessionCleanupState {
+    sessionId: string;
+    serverId: ServerId;
+    markedForCleanupAt: number;
+    cleanupTimeoutId?: NodeJS.Timeout;
+    reason: 'user_cleared' | 'timeout' | 'error';
+    accumulatedText?: string;
+}

package/dist/websocket.d.ts

@@ -1,11 +1,13 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState } from "./types";
+import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState, SessionCleanupState } from "./types";
 export declare class XiaoYiWebSocketManager extends EventEmitter {
     private ws1;
     private ws2;
     private state1;
     private state2;
     private sessionServerMap;
+    private sessionCleanupStateMap;
+    private static readonly DEFAULT_CLEANUP_TIMEOUT_MS;
     private auth;
     private config;
     private heartbeatTimeout1?;
@@ -176,4 +178,34 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * Remove session mapping
      */
     removeSession(sessionId: string): void;
+    /**
+     * Mark a session for delayed cleanup
+     * @param sessionId The session ID to mark for cleanup
+     * @param serverId The server ID associated with this session
+     * @param timeoutMs Timeout in milliseconds before forcing cleanup
+     */
+    private markSessionForCleanup;
+    /**
+     * Force cleanup a session immediately
+     * @param sessionId The session ID to cleanup
+     */
+    forceCleanupSession(sessionId: string): void;
+    /**
+     * Check if a session is pending cleanup
+     * @param sessionId The session ID to check
+     * @returns True if session is pending cleanup
+     */
+    isSessionPendingCleanup(sessionId: string): boolean;
+    /**
+     * Get cleanup state for a session
+     * @param sessionId The session ID to check
+     * @returns Cleanup state if exists, undefined otherwise
+     */
+    getSessionCleanupState(sessionId: string): SessionCleanupState | undefined;
+    /**
+     * Update accumulated text for a pending cleanup session
+     * @param sessionId The session ID
+     * @param text The accumulated text
+     */
+    updateAccumulatedTextForCleanup(sessionId: string, text: string): void;
 }