@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/runtime.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XiaoYiRuntime = void 0;
 exports.getXiaoYiRuntime = getXiaoYiRuntime;
 exports.setXiaoYiRuntime = setXiaoYiRuntime;
-const websocket_1 = require("./websocket");
+const websocket_js_1 = require("./websocket.js");
 /**
  * Default timeout configuration
  */
@@ -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}`);
     }
@@ -58,7 +64,7 @@ class XiaoYiRuntime {
             return;
         }
         this.config = config;
-        const manager = new websocket_1.XiaoYiWebSocketManager(config);
+        const manager = new websocket_js_1.XiaoYiWebSocketManager(config);
         // Setup basic event handlers (message handling is done in channel.ts)
         manager.on("error", (error) => {
             console.error("XiaoYi channel error:", error);
@@ -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

@@ -1,3 +1,69 @@
+export interface A2AJsonRpcRequest {
+    jsonrpc: "2.0";
+    method: string;
+    params: A2ARequestParams;
+    id: string;
+}
+export interface A2ARequestParams {
+    id: string;
+    sessionId: string;
+    agentLoginSessionId?: string;
+    message: A2AMessage;
+}
+export interface A2AMessage {
+    role: "user" | "assistant" | "system";
+    parts: A2AMessagePart[];
+}
+export type A2AMessagePart = A2ATextPart | A2AFilePart | A2ADataPart;
+export interface A2ATextPart {
+    kind: "text";
+    text: string;
+}
+export interface A2AFilePart {
+    kind: "file";
+    file: {
+        name: string;
+        mimeType: string;
+        uri: string;
+    };
+}
+export interface A2ADataPart {
+    kind: "data";
+    data: {
+        event?: A2ADataEvent;
+        variables?: {
+            systemVariables?: {
+                push_id?: string;
+            };
+        };
+        [key: string]: any;
+    };
+}
+export interface A2ADataEvent {
+    intentName: string;
+    outputs: Record<string, any>;
+    status: "success" | "failed";
+}
+export interface A2AReasoningTextPart {
+    kind: "reasoningText";
+    reasoningText: string;
+}
+export interface A2ACommandPart {
+    kind: "command";
+    command: A2ACommand;
+}
+export interface A2ACommand {
+    header: {
+        namespace: string;
+        name: string;
+    };
+    payload: Record<string, any>;
+}
+export type A2AArtifactPart = A2ATextPart | A2ADataPart | A2ACommandPart | A2AReasoningTextPart;
+export interface A2AArtifact {
+    artifactId: string;
+    parts: A2AArtifactPart[];
+}
 export interface A2ARequestMessage {
     agentId: string;
     jsonrpc: "2.0";
@@ -75,8 +141,9 @@ export interface A2ATaskArtifactUpdateEvent {
     artifact: {
         artifactId: string;
         parts: Array<{
-            kind: "text" | "file" | "data";
+            kind: "text" | "file" | "data" | "reasoningText";
             text?: string;
+            reasoningText?: string;
             file?: {
                 name: string;
                 mimeType: string;
@@ -152,6 +219,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 +252,7 @@ export interface InternalWebSocketConfig {
     ak: string;
     sk: string;
     enableStreaming?: boolean;
+    sessionCleanupTimeoutMs?: number;
 }
 export type ServerId = 'server1' | 'server2';
 export interface ServerConnectionState {
@@ -184,3 +261,20 @@ 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;
+}
+export interface SessionBinding {
+    sessionId: string;
+    server: ServerIdentifier;
+    boundAt: number;
+}
+export type ServerIdentifier = 'server1' | 'server2';

package/dist/websocket.d.ts

@@ -1,23 +1,33 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState } from "./types";
+import { A2AResponseMessage, OutboundWebSocketMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState, SessionCleanupState } from "./types.js";
 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?;
     private heartbeatTimeout2?;
     private appHeartbeatInterval?;
+    private heartbeat1?;
+    private heartbeat2?;
     private reconnectTimeout1?;
     private reconnectTimeout2?;
     private stableConnectionTimer1?;
     private stableConnectionTimer2?;
     private static readonly STABLE_CONNECTION_THRESHOLD;
     private activeTasks;
+    private onHealthEvent?;
     constructor(config: XiaoYiChannelConfig);
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     * This callback is invoked on heartbeat success to update lastEventAt.
+     */
+    setHealthEventCallback(callback: () => void): void;
     /**
      * Check if URL is wss + IP format (skip certificate verification)
      */
@@ -91,6 +101,14 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * TODO: 实现实际的推送消息发送逻辑
      */
     sendPushMessage(sessionId: string, message: string): Promise<void>;
+    /**
+     * Send an outbound WebSocket message directly.
+     * This is a low-level method that sends a pre-formatted OutboundWebSocketMessage.
+     *
+     * @param sessionId - Session ID for routing
+     * @param message - Pre-formatted outbound message
+     */
+    sendMessage(sessionId: string, message: OutboundWebSocketMessage): Promise<void>;
     /**
      * Send tasks cancel response to specific server
      */
@@ -176,4 +194,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;
 }