@ynhcj/xiaoyi 0.0.1-beta

package/dist/types.d.ts

@@ -0,0 +1,280 @@
+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";
+    id: string;
+    method: "message/stream";
+    deviceId?: string;
+    conversationId?: string;
+    sessionId?: string;
+    params: {
+        id: string;
+        sessionId?: string;
+        agentLoginSessionId?: string;
+        message: {
+            kind?: string;
+            messageId?: string;
+            role: "user" | "agent";
+            parts: Array<{
+                kind: "text" | "file" | "data";
+                text?: string;
+                file?: {
+                    name: string;
+                    mimeType: string;
+                    bytes?: string;
+                    uri?: string;
+                };
+                data?: any;
+            }>;
+        };
+    };
+}
+export interface A2AResponseMessage {
+    sessionId: string;
+    messageId: string;
+    timestamp: number;
+    agentId: string;
+    sender: {
+        id: string;
+        name?: string;
+        type: "agent";
+    };
+    content: {
+        type: "text" | "image" | "audio" | "video" | "file";
+        text?: string;
+        mediaUrl?: string;
+        fileName?: string;
+        fileSize?: number;
+        mimeType?: string;
+    };
+    context?: {
+        conversationId?: string;
+        threadId?: string;
+        replyToMessageId?: string;
+    };
+    status: "success" | "error" | "processing";
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface A2AJsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string;
+    result?: A2ATaskArtifactUpdateEvent | A2ATaskStatusUpdateEvent | A2AClearContextResult | A2ATasksCancelResult;
+    error?: {
+        code: number | string;
+        message: string;
+    };
+}
+export interface A2ATaskArtifactUpdateEvent {
+    taskId: string;
+    kind: "artifact-update";
+    append?: boolean;
+    lastChunk?: boolean;
+    final: boolean;
+    artifact: {
+        artifactId: string;
+        parts: Array<{
+            kind: "text" | "file" | "data" | "reasoningText";
+            text?: string;
+            reasoningText?: string;
+            file?: {
+                name: string;
+                mimeType: string;
+                bytes?: string;
+                uri?: string;
+            };
+            data?: any;
+        }>;
+    };
+}
+export interface A2ATaskStatusUpdateEvent {
+    taskId: string;
+    kind: "status-update";
+    final: boolean;
+    status: {
+        message: {
+            role: "agent";
+            parts: Array<{
+                kind: "text";
+                text: string;
+            }>;
+        };
+        state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+    };
+}
+export interface A2AClearContextResult {
+    status: {
+        state: "cleared" | "failed" | "unknown";
+    };
+}
+export interface A2ATasksCancelResult {
+    id: string;
+    status: {
+        state: "canceled" | "failed" | "unknown";
+    };
+}
+export interface A2AWebSocketMessage {
+    type: "message" | "heartbeat" | "auth" | "error";
+    data: A2ARequestMessage | A2AResponseMessage | any;
+}
+export type OutboundMessageType = "clawd_bot_init" | "agent_response" | "heartbeat";
+export interface OutboundWebSocketMessage {
+    msgType: OutboundMessageType;
+    agentId: string;
+    sessionId?: string;
+    taskId?: string;
+    msgDetail?: string;
+}
+export interface A2AClearMessage {
+    agentId: string;
+    sessionId: string;
+    id: string;
+    action: "clear";
+    timestamp: number;
+}
+export interface A2ATasksCancelMessage {
+    agentId: string;
+    sessionId: string;
+    id: string;
+    action?: "tasks/cancel";
+    method?: "tasks/cancel";
+    taskId?: string;
+    jsonrpc?: "2.0";
+    conversationId?: string;
+    timestamp?: number;
+}
+export interface XiaoYiChannelConfig {
+    enabled: boolean;
+    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
+    ak: string;
+    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;
+    sk: string;
+    timestamp: number;
+    signature: string;
+}
+export interface WebSocketConnectionState {
+    connected: boolean;
+    authenticated: boolean;
+    lastHeartbeat: number;
+    lastAppHeartbeat: number;
+    reconnectAttempts: number;
+    maxReconnectAttempts: number;
+}
+export declare const DEFAULT_WS_URL_1 = "wss://hag.cloud.huawei.com/openclaw/v1/ws/link";
+export declare const DEFAULT_WS_URL_2 = "wss://116.63.174.231/openclaw/v1/ws/link";
+export interface InternalWebSocketConfig {
+    wsUrl1: string;
+    wsUrl2: string;
+    agentId: string;
+    ak: string;
+    sk: string;
+    enableStreaming?: boolean;
+    sessionCleanupTimeoutMs?: number;
+}
+export type ServerId = 'server1' | 'server2';
+export interface ServerConnectionState {
+    connected: boolean;
+    ready: boolean;
+    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/types.js

@@ -0,0 +1,8 @@
+"use strict";
+// A2A Message Structure Types
+// Based on: https://developer.huawei.com/consumer/cn/doc/service/message-stream-0000002505761434
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WS_URL_2 = exports.DEFAULT_WS_URL_1 = void 0;
+// Dual server configuration
+exports.DEFAULT_WS_URL_1 = "wss://hag.cloud.huawei.com/openclaw/v1/ws/link";
+exports.DEFAULT_WS_URL_2 = "wss://116.63.174.231/openclaw/v1/ws/link";

package/dist/websocket.d.ts

@@ -0,0 +1,219 @@
+import { EventEmitter } from "events";
+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 reconnectTimeout1?;
+    private reconnectTimeout2?;
+    private stableConnectionTimer1?;
+    private stableConnectionTimer2?;
+    private static readonly STABLE_CONNECTION_THRESHOLD;
+    private activeTasks;
+    constructor(config: XiaoYiChannelConfig);
+    /**
+     * Check if URL is wss + IP format (skip certificate verification)
+     */
+    private isWssWithIp;
+    /**
+     * Resolve configuration with defaults and backward compatibility
+     */
+    private resolveConfig;
+    /**
+     * Connect to both WebSocket servers
+     */
+    connect(): Promise<void>;
+    /**
+     * Connect to server 1
+     */
+    private connectToServer1;
+    /**
+     * Connect to server 2
+     */
+    private connectToServer2;
+    /**
+     * Disconnect from all servers
+     */
+    disconnect(): void;
+    /**
+     * Send init message to specific server
+     */
+    private sendInitMessage;
+    /**
+     * Setup WebSocket event handlers for specific server
+     */
+    private setupWebSocketHandlers;
+    /**
+     * Extract sessionId from message based on method type
+     * Different methods have sessionId in different locations:
+     * - message/stream: sessionId in params, fallback to top-level sessionId
+     * - tasks/cancel: sessionId at top level
+     * - clearContext: sessionId at top level
+     */
+    private extractSessionId;
+    /**
+     * Handle incoming message from specific server
+     */
+    private handleIncomingMessage;
+    /**
+     * Send A2A response message with automatic routing
+     */
+    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string, isFinal?: boolean, append?: boolean): Promise<void>;
+    /**
+     * Send clear context response to specific server
+     */
+    sendClearContextResponse(requestId: string, sessionId: string, success?: boolean, targetServer?: ServerId): Promise<void>;
+    /**
+     * Send status update (for intermediate status messages, e.g., timeout warnings)
+     * This uses "status-update" event type which keeps the conversation active
+     */
+    sendStatusUpdate(taskId: string, sessionId: string, message: string, targetServer?: ServerId): Promise<void>;
+    /**
+     * Send PUSH message (主动推送) via HTTP API
+     *
+     * This is used when SubAgent completes execution and needs to push results to user
+     * independently of the original A2A request-response flow.
+     *
+     * Unlike sendResponse (which responds to a specific request via WebSocket), push messages are
+     * sent through HTTP API asynchronously.
+     *
+     * @param sessionId - User's session ID
+     * @param message - Message content to push
+     *
+     * Reference: 华为小艺推送消息 API
+     * 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
+     */
+    sendTasksCancelResponse(requestId: string, sessionId: string, success?: boolean, targetServer?: ServerId): Promise<void>;
+    /**
+     * Handle clearContext method
+     */
+    private handleClearContext;
+    /**
+     * Handle clear message (legacy format)
+     */
+    private handleClearMessage;
+    /**
+     * Handle tasks/cancel message
+     */
+    private handleTasksCancelMessage;
+    /**
+     * Convert A2AResponseMessage to JSON-RPC 2.0 format
+     */
+    private convertToJsonRpcFormat;
+    /**
+     * Check if at least one server is ready
+     */
+    isReady(): boolean;
+    /**
+     * Get combined connection state
+     */
+    getState(): WebSocketConnectionState;
+    /**
+     * Get individual server states
+     */
+    getServerStates(): {
+        server1: ServerConnectionState;
+        server2: ServerConnectionState;
+    };
+    /**
+     * Start protocol-level heartbeat for specific server
+     */
+    private startProtocolHeartbeat;
+    /**
+     * Clear protocol heartbeat for specific server
+     */
+    private clearProtocolHeartbeat;
+    /**
+     * Start application-level heartbeat (shared across both servers)
+     */
+    private startAppHeartbeat;
+    /**
+     * Schedule reconnection for specific server
+     */
+    private scheduleReconnect;
+    /**
+     * Clear all timers
+     */
+    private clearTimers;
+    /**
+     * Schedule a connection stability check
+     * Only reset reconnect counter after connection has been stable for threshold time
+     */
+    private scheduleStableConnectionCheck;
+    /**
+     * Clear the connection stability check timer
+     */
+    private clearStableConnectionCheck;
+    /**
+     * Type guard for A2A request messages
+     * sessionId can be in params OR at top level (fallback)
+     */
+    private isA2ARequestMessage;
+    /**
+     * Get active tasks
+     */
+    getActiveTasks(): Map<string, any>;
+    /**
+     * Remove task from active tasks
+     */
+    removeActiveTask(taskId: string): void;
+    /**
+     * Get server for a specific session
+     */
+    getServerForSession(sessionId: string): ServerId | undefined;
+    /**
+     * 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;
+}