@ynhcj/xiaoyi 2.5.6 → 2.5.7

package/dist/file-download.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Download a file from URL to local path.
+ */
+export declare function downloadFile(url: string, destPath: string): Promise<void>;
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+export declare function downloadFilesFromParts(fileParts: Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>, tempDir?: string): Promise<Array<{
+    path: string;
+    name: string;
+    mimeType: string;
+}>>;

package/dist/file-download.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+exports.downloadFilesFromParts = downloadFilesFromParts;
+// File download utilities
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_js_1 = require("./xy-utils/logger.js");
+/**
+ * Download a file from URL to local path.
+ */
+async function downloadFile(url, destPath) {
+    logger_js_1.logger.debug(`Downloading file from ${url} to ${destPath}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 30000); // 30 seconds timeout
+    try {
+        const response = await (0, node_fetch_1.default)(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await promises_1.default.writeFile(destPath, buffer);
+        logger_js_1.logger.debug(`File downloaded successfully: ${destPath}`);
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            logger_js_1.logger.error(`Download timeout (30s) for ${url}`);
+            throw new Error(`Download timeout after 30 seconds`);
+        }
+        logger_js_1.logger.error(`Failed to download file from ${url}:`, error);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_channel") {
+    // Create temp directory if it doesn't exist
+    await promises_1.default.mkdir(tempDir, { recursive: true });
+    const downloadedFiles = [];
+    for (const filePart of fileParts) {
+        const { name, mimeType, uri } = filePart;
+        // Generate safe file name
+        const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+        const destPath = path_1.default.join(tempDir, `${Date.now()}_${safeName}`);
+        try {
+            await downloadFile(uri, destPath);
+            downloadedFiles.push({
+                path: destPath,
+                name,
+                mimeType,
+            });
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to download file ${name}:`, error);
+            // Continue with other files
+        }
+    }
+    return downloadedFiles;
+}

package/dist/heartbeat.d.ts

@@ -0,0 +1,39 @@
+import WebSocket from "ws";
+export interface HeartbeatConfig {
+    interval: number;
+    timeout: number;
+    message: string;
+}
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+export declare class HeartbeatManager {
+    private ws;
+    private config;
+    private onTimeout;
+    private serverName;
+    private onHeartbeatSuccess?;
+    private intervalTimer;
+    private timeoutTimer;
+    private lastPongTime;
+    private log;
+    private error;
+    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void, onHeartbeatSuccess?: () => void);
+    /**
+     * Start heartbeat monitoring.
+     */
+    start(): void;
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop(): void;
+    /**
+     * Send a heartbeat ping.
+     */
+    private sendHeartbeat;
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy(): boolean;
+}

package/dist/heartbeat.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatManager = void 0;
+// Heartbeat management for WebSocket connections
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+class HeartbeatManager {
+    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn, onHeartbeatSuccess // ✅ 心跳成功回调，向 OpenClaw 报告健康状态
+    ) {
+        this.ws = ws;
+        this.config = config;
+        this.onTimeout = onTimeout;
+        this.serverName = serverName;
+        this.onHeartbeatSuccess = onHeartbeatSuccess;
+        this.intervalTimer = null;
+        this.timeoutTimer = null;
+        this.lastPongTime = 0;
+        this.log = logFn ?? console.log;
+        this.error = errorFn ?? console.error;
+    }
+    /**
+     * Start heartbeat monitoring.
+     */
+    start() {
+        this.stop(); // Clear any existing timers
+        this.lastPongTime = Date.now();
+        // Setup ping/pong for protocol-level heartbeat
+        this.ws.on("pong", () => {
+            this.lastPongTime = Date.now();
+            if (this.timeoutTimer) {
+                clearTimeout(this.timeoutTimer);
+                this.timeoutTimer = null;
+            }
+            // ✅ Report health: heartbeat successful - notify OpenClaw framework
+            this.onHeartbeatSuccess?.();
+            this.log(`[${this.serverName}] Heartbeat pong received, health reported to OpenClaw`);
+        });
+        // Start interval timer
+        this.intervalTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.config.interval);
+        this.log(`[${this.serverName}] Heartbeat started: interval=${this.config.interval}ms, timeout=${this.config.timeout}ms`);
+    }
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop() {
+        if (this.intervalTimer) {
+            clearInterval(this.intervalTimer);
+            this.intervalTimer = null;
+        }
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = null;
+        }
+        // Remove pong listener
+        this.ws.off("pong", () => { });
+        this.log(`[${this.serverName}] Heartbeat stopped`);
+    }
+    /**
+     * Send a heartbeat ping.
+     */
+    sendHeartbeat() {
+        if (this.ws.readyState !== ws_1.default.OPEN) {
+            console.warn(`[${this.serverName}] Cannot send heartbeat: WebSocket not open`);
+            return;
+        }
+        try {
+            // Send application-level heartbeat message
+            this.log(`[${this.serverName}] Sending heartbeat frame:`, this.config.message.substring(0, 100));
+            this.ws.send(this.config.message);
+            // Send protocol-level ping
+            this.ws.ping();
+            this.log(`[${this.serverName}] Protocol-level ping sent`);
+            // Setup timeout timer
+            this.timeoutTimer = setTimeout(() => {
+                this.error(`[${this.serverName}] Heartbeat timeout - no pong received`);
+                this.onTimeout();
+            }, this.config.timeout);
+        }
+        catch (error) {
+            this.error(`[${this.serverName}] Failed to send heartbeat:`, error);
+        }
+    }
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy() {
+        if (this.lastPongTime === 0) {
+            return true; // Not started yet
+        }
+        const timeSinceLastPong = Date.now() - this.lastPongTime;
+        return timeSinceLastPong < this.config.interval + this.config.timeout;
+    }
+}
+exports.HeartbeatManager = HeartbeatManager;

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const channel_1 = require("./channel");
-const runtime_1 = require("./runtime");
+const channel_js_1 = require("./channel.js");
+const runtime_js_1 = require("./runtime.js");
 /**
  * XiaoYi Channel Plugin for OpenClaw
  *
@@ -30,10 +30,10 @@ const plugin = {
     register(api) {
         console.log("XiaoYi: register() called - START");
         // Set runtime for managing WebSocket connections
-        (0, runtime_1.setXiaoYiRuntime)(api.runtime);
+        (0, runtime_js_1.setXiaoYiRuntime)(api.runtime);
         console.log("XiaoYi: setXiaoYiRuntime() completed");
         // Clean up any existing connections from previous plugin loads
-        const runtime = require("./runtime").getXiaoYiRuntime();
+        const runtime = require("./runtime.js").getXiaoYiRuntime();
         console.log(`XiaoYi: Got runtime instance: ${runtime.getInstanceId()}, isConnected: ${runtime.isConnected()}`);
         if (runtime.isConnected()) {
             console.log("XiaoYi: Cleaning up existing connection from previous load");
@@ -41,7 +41,7 @@ const plugin = {
         }
         // Register the channel plugin
         console.log("XiaoYi: About to call registerChannel()");
-        api.registerChannel({ plugin: channel_1.xiaoyiPlugin });
+        api.registerChannel({ plugin: channel_js_1.xiaoyiPlugin });
         console.log("XiaoYi: registerChannel() completed");
         console.log("XiaoYi channel plugin registered - END");
     },

package/dist/push.d.ts

@@ -1,4 +1,4 @@
-import { XiaoYiChannelConfig } from "./types";
+import { XiaoYiChannelConfig } from "./types.js";
 /**
  * Push message sending service
  * Sends notifications to XiaoYi clients via webhook API

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
-import { XiaoYiWebSocketManager } from "./websocket";
-import { XiaoYiChannelConfig } from "./types";
+import { XiaoYiWebSocketManager } from "./websocket.js";
+import { XiaoYiChannelConfig } from "./types.js";
 /**
  * Timeout configuration
  */

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
  */
@@ -64,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);

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;
@@ -205,3 +272,9 @@ export interface SessionCleanupState {
     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,5 +1,5 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState, SessionCleanupState } from "./types";
+import { A2AResponseMessage, OutboundWebSocketMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState, SessionCleanupState } from "./types.js";
 export declare class XiaoYiWebSocketManager extends EventEmitter {
     private ws1;
     private ws2;
@@ -13,13 +13,21 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
     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)
      */
@@ -93,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
      */