@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/xy-formatter.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendA2AResponse = sendA2AResponse;
+exports.sendReasoningTextUpdate = sendReasoningTextUpdate;
+exports.sendStatusUpdate = sendStatusUpdate;
+exports.sendCommand = sendCommand;
+exports.sendClearContextResponse = sendClearContextResponse;
+exports.sendTasksCancelResponse = sendTasksCancelResponse;
+// OpenClaw → A2A format conversion
+const uuid_1 = require("uuid");
+const xy_client_js_1 = require("./xy-client.js");
+const runtime_js_1 = require("./runtime.js");
+/**
+ * Send an A2A artifact update response.
+ */
+async function sendA2AResponse(params) {
+    const { config, sessionId, taskId, messageId, text, append, final, files } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build artifact update event
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final,
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [],
+        },
+    };
+    // Add text part (even if empty string, to maintain parts structure)
+    if (text !== undefined) {
+        artifact.artifact.parts.push({
+            kind: "text",
+            text,
+        });
+    }
+    // Add file parts if provided
+    if (files && files.length > 0) {
+        artifact.artifact.parts.push({
+            kind: "data",
+            data: { fileInfo: files },
+        });
+    }
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
+    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
+    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
+    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE]   - append: ${append}`);
+    log(`[A2A_RESPONSE]   - final: ${final}`);
+    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+}
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+async function sendReasoningTextUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, append = true } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final: false,
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [
+                {
+                    kind: "reasoningText",
+                    reasoningText: text,
+                },
+            ],
+        },
+    };
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[REASONING_TEXT] 📤 Sending reasoningText update: sessionId=${sessionId}, taskId=${taskId}, text.length=${text.length}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[REASONING_TEXT] ✅ Sent successfully`);
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+async function sendStatusUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, state } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build status update event following A2A protocol standard
+    const statusUpdate = {
+        taskId,
+        kind: "status-update",
+        final: false, // Status updates should not end the stream
+        status: {
+            message: {
+                role: "agent",
+                parts: [
+                    {
+                        kind: "text",
+                        text,
+                    },
+                ],
+            },
+            state,
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: statusUpdate,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
+    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - messageId: ${messageId}`);
+    log(`[A2A_STATUS]   - state: ${state}`);
+    log(`[A2A_STATUS]   - text: "${text}"`);
+    log(`[A2A_STATUS] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_STATUS] ✅ Status update sent successfully`);
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+async function sendCommand(params) {
+    const { config, sessionId, taskId, messageId, command } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    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 = {
+        taskId,
+        kind: "artifact-update",
+        append: false,
+        lastChunk: true,
+        final: false, // Commands are not final
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [
+                {
+                    kind: "data",
+                    data: {
+                        commands: [command],
+                    },
+                },
+            ],
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
+    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
+    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
+    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
+    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
+    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_COMMAND] ✅ Command sent successfully`);
+}
+/**
+ * Send a clearContext response.
+ */
+async function sendClearContextResponse(params) {
+    const { config, sessionId, messageId } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for clearContext
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            status: {
+                state: "cleared",
+            },
+        },
+        error: {
+            code: 0,
+            // Note: Using any to bypass type check as the response format differs from standard A2A types
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId: sessionId, // Use sessionId as taskId for clearContext
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent clearContext response: sessionId=${sessionId}`);
+}
+/**
+ * Send a tasks/cancel response.
+ */
+async function sendTasksCancelResponse(params) {
+    const { config, sessionId, taskId, messageId } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    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 = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            id: taskId,
+            status: {
+                state: "canceled",
+            },
+        },
+        error: {
+            code: 0,
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
+}

package/dist/xy-monitor.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+export type MonitorXYOpts = {
+    config?: any;
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    accountId?: string;
+    setStatus?: (status: {
+        lastEventAt?: number;
+        lastInboundAt?: number;
+        connected?: boolean;
+    }) => void;
+};
+/**
+ * Monitor XY channel WebSocket connections.
+ * Keeps the connection alive until abortSignal is triggered.
+ */
+export declare function monitorXYProvider(opts?: MonitorXYOpts): Promise<void>;

package/dist/xy-monitor.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monitorXYProvider = monitorXYProvider;
+const xy_config_js_1 = require("./xy-config.js");
+const xy_client_js_1 = require("./xy-client.js");
+const xy_bot_js_1 = require("./xy-bot.js");
+/**
+ * Per-session serial queue that ensures messages from the same session are processed
+ * in arrival order while allowing different sessions to run concurrently.
+ * Following feishu/monitor.account.ts pattern.
+ */
+function createSessionQueue() {
+    const queues = new Map();
+    return (sessionId, task) => {
+        const prev = queues.get(sessionId) ?? Promise.resolve();
+        const next = prev.then(task, task);
+        queues.set(sessionId, next);
+        void next.finally(() => {
+            if (queues.get(sessionId) === next) {
+                queues.delete(sessionId);
+            }
+        });
+        return next;
+    };
+}
+/**
+ * Monitor XY channel WebSocket connections.
+ * Keeps the connection alive until abortSignal is triggered.
+ */
+async function monitorXYProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg) {
+        throw new Error("Config is required for XY monitor");
+    }
+    const runtime = opts.runtime;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const account = (0, xy_config_js_1.resolveXYConfig)(cfg);
+    if (!account.enabled) {
+        throw new Error(`XY account is disabled`);
+    }
+    const accountId = opts.accountId ?? "default";
+    // Create trackEvent function to report health to OpenClaw framework
+    const trackEvent = opts.setStatus
+        ? () => {
+            opts.setStatus({ lastEventAt: Date.now(), lastInboundAt: Date.now() });
+        }
+        : undefined;
+    // 🔍 Diagnose WebSocket managers before gateway start
+    // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    // diagnoseAllManagers();
+    // Get WebSocket manager (cached)
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(account);
+    // ✅ Set health event callback for heartbeat reporting
+    // This ensures OpenClaw's health-monitor sees activity and doesn't trigger stale-socket restarts
+    if (trackEvent) {
+        wsManager.setHealthEventCallback(trackEvent);
+    }
+    // Track logged servers to avoid duplicate logs
+    const loggedServers = new Set();
+    // Track active message processing to detect duplicates
+    const activeMessages = new Set();
+    // Create session queue for ordered message processing
+    const enqueue = createSessionQueue();
+    // Health check interval
+    let healthCheckInterval = null;
+    return new Promise((resolve, reject) => {
+        // Event handlers (defined early so they can be referenced in cleanup)
+        const messageHandler = (message, sessionId, serverId) => {
+            const messageKey = `${sessionId}::${message.id}`;
+            log(`[MONITOR-HANDLER] ####### messageHandler triggered: serverId=${serverId}, sessionId=${sessionId}, messageId=${message.id} #######`);
+            // ✅ Report health: received a message
+            trackEvent?.();
+            // Check for duplicate message handling
+            if (activeMessages.has(messageKey)) {
+                error(`[MONITOR-HANDLER] ⚠️ WARNING: Duplicate message detected! messageKey=${messageKey}, this may cause duplicate dispatchers!`);
+            }
+            activeMessages.add(messageKey);
+            log(`[MONITOR-HANDLER] 📝 Active messages count: ${activeMessages.size}, messageKey: ${messageKey}`);
+            const task = async () => {
+                try {
+                    log(`[MONITOR-HANDLER] 🚀 Starting handleXYMessage for messageKey=${messageKey}`);
+                    await (0, xy_bot_js_1.handleXYMessage)({
+                        cfg,
+                        runtime,
+                        message,
+                        accountId, // ✅ Pass accountId ("default")
+                    });
+                    log(`[MONITOR-HANDLER] ✅ Completed handleXYMessage for messageKey=${messageKey}`);
+                }
+                catch (err) {
+                    // ✅ Only log error, don't re-throw to prevent gateway restart
+                    error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
+                }
+                finally {
+                    // Remove from active messages when done
+                    activeMessages.delete(messageKey);
+                    log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
+                }
+            };
+            void enqueue(sessionId, task).catch((err) => {
+                // Error already logged in task, this is for queue failures
+                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                activeMessages.delete(messageKey);
+            });
+        };
+        const connectedHandler = (serverId) => {
+            if (!loggedServers.has(serverId)) {
+                log(`XY gateway: ${serverId} connected`);
+                loggedServers.add(serverId);
+            }
+            // ✅ Report health: connection established
+            trackEvent?.();
+            opts.setStatus?.({ connected: true });
+        };
+        const disconnectedHandler = (serverId) => {
+            console.warn(`XY gateway: ${serverId} disconnected`);
+            loggedServers.delete(serverId);
+            // ✅ Report disconnection status (only if all servers disconnected)
+            if (loggedServers.size === 0) {
+                opts.setStatus?.({ connected: false });
+            }
+        };
+        const errorHandler = (err, serverId) => {
+            error(`XY gateway: ${serverId} error: ${String(err)}`);
+        };
+        const cleanup = () => {
+            log("XY gateway: cleaning up...");
+            // Stop health check interval
+            if (healthCheckInterval) {
+                clearInterval(healthCheckInterval);
+                healthCheckInterval = null;
+                console.log("⏸️  Stopped periodic health check");
+            }
+            // Remove event handlers to prevent duplicate calls on gateway restart
+            wsManager.off("message", messageHandler);
+            wsManager.off("connected", connectedHandler);
+            wsManager.off("disconnected", disconnectedHandler);
+            wsManager.off("error", errorHandler);
+            // ✅ Remove manager from cache - this will also disconnect
+            // removeXYWebSocketManager internally calls manager.disconnect()
+            (0, xy_client_js_1.removeXYWebSocketManager)(account);
+            loggedServers.clear();
+            activeMessages.clear();
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+        };
+        const handleAbort = () => {
+            log("XY gateway: abort signal received, stopping");
+            cleanup();
+            log("XY gateway stopped");
+            resolve();
+        };
+        if (opts.abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        // Register event handlers (handlers are defined above in cleanup scope)
+        wsManager.on("message", messageHandler);
+        wsManager.on("connected", connectedHandler);
+        wsManager.on("disconnected", disconnectedHandler);
+        wsManager.on("error", errorHandler);
+        // Start periodic health check (every 5 minutes)
+        console.log("🏥 Starting periodic health check (every 5 minutes)...");
+        healthCheckInterval = setInterval(() => {
+            console.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`);
+            // }
+        }, 5 * 60 * 1000); // 5 minutes
+        // Connect to WebSocket servers
+        wsManager.connect()
+            .then(() => {
+            log("XY gateway: started successfully");
+        })
+            .catch((err) => {
+            // Connection failed but don't reject - continue monitoring for reconnection
+            error(`XY gateway: initial connection failed: ${String(err)}`);
+            // Still resolve successfully so plugin starts
+            resolve();
+        });
+    });
+}

package/dist/xy-parser.d.ts

@@ -0,0 +1,49 @@
+import type { A2AJsonRpcRequest, A2AMessagePart, A2ADataEvent } from "./types.js";
+/**
+ * Parsed message information extracted from A2A request.
+ * Note: agentId is not extracted from message - it should come from config.
+ */
+export interface ParsedA2AMessage {
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    parts: A2AMessagePart[];
+    method: string;
+}
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+export declare function parseA2AMessage(request: A2AJsonRpcRequest): ParsedA2AMessage;
+/**
+ * Extract text content from message parts.
+ */
+export declare function extractTextFromParts(parts: A2AMessagePart[]): string;
+/**
+ * Extract file parts from message parts.
+ */
+export declare function extractFileParts(parts: A2AMessagePart[]): Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>;
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+export declare function extractDataEvents(parts: A2AMessagePart[]): A2ADataEvent[];
+/**
+ * Check if message is a clearContext request.
+ */
+export declare function isClearContextMessage(method: string): boolean;
+/**
+ * Check if message is a tasks/cancel request.
+ */
+export declare function isTasksCancelMessage(method: string): boolean;
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export declare function extractPushId(parts: A2AMessagePart[]): string | null;
+/**
+ * Validate A2A request structure.
+ */
+export declare function validateA2ARequest(request: any): request is A2AJsonRpcRequest;

package/dist/xy-parser.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseA2AMessage = parseA2AMessage;
+exports.extractTextFromParts = extractTextFromParts;
+exports.extractFileParts = extractFileParts;
+exports.extractDataEvents = extractDataEvents;
+exports.isClearContextMessage = isClearContextMessage;
+exports.isTasksCancelMessage = isTasksCancelMessage;
+exports.extractPushId = extractPushId;
+exports.validateA2ARequest = validateA2ARequest;
+const logger_js_1 = require("./xy-utils/logger.js");
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+function parseA2AMessage(request) {
+    const { method, params, id } = request;
+    if (!params) {
+        throw new Error("A2A request missing params");
+    }
+    const { sessionId, message, id: paramsId } = params;
+    if (!sessionId || !message) {
+        throw new Error("A2A request params missing required fields");
+    }
+    return {
+        sessionId,
+        taskId: paramsId, // Task ID from params (对话唯一标识)
+        messageId: id, // Global unique message sequence ID from top-level request
+        parts: message.parts || [],
+        method,
+    };
+}
+/**
+ * Extract text content from message parts.
+ */
+function extractTextFromParts(parts) {
+    const textParts = parts
+        .filter((part) => part.kind === "text")
+        .map((part) => part.text);
+    return textParts.join("\n").trim();
+}
+/**
+ * Extract file parts from message parts.
+ */
+function extractFileParts(parts) {
+    return parts
+        .filter((part) => part.kind === "file")
+        .map((part) => part.file);
+}
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+function extractDataEvents(parts) {
+    return parts
+        .filter((part) => part.kind === "data")
+        .map((part) => part.data.event)
+        .filter((event) => event !== undefined);
+}
+/**
+ * Check if message is a clearContext request.
+ */
+function isClearContextMessage(method) {
+    return method === "clearContext" || method === "clear_context";
+}
+/**
+ * Check if message is a tasks/cancel request.
+ */
+function isTasksCancelMessage(method) {
+    return method === "tasks/cancel" || method === "tasks_cancel";
+}
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+function extractPushId(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const pushId = part.data.variables?.systemVariables?.push_id;
+            if (pushId && typeof pushId === "string") {
+                return pushId;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Validate A2A request structure.
+ */
+function validateA2ARequest(request) {
+    if (!request || typeof request !== "object") {
+        return false;
+    }
+    if (request.jsonrpc !== "2.0") {
+        logger_js_1.logger.warn("Invalid JSON-RPC version:", request.jsonrpc);
+        return false;
+    }
+    if (!request.method || typeof request.method !== "string") {
+        logger_js_1.logger.warn("Missing or invalid method");
+        return false;
+    }
+    if (!request.id) {
+        logger_js_1.logger.warn("Missing request id");
+        return false;
+    }
+    if (!request.params || typeof request.params !== "object") {
+        logger_js_1.logger.warn("Missing or invalid params");
+        return false;
+    }
+    return true;
+}

package/dist/xy-reply-dispatcher.d.ts

@@ -0,0 +1,17 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+type ClawdbotConfig = OpenClawConfig;
+export interface CreateXYReplyDispatcherParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    accountId: string;
+}
+/**
+ * Create a reply dispatcher for XY channel messages.
+ * Follows feishu pattern with status updates and streaming support.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function createXYReplyDispatcher(params: CreateXYReplyDispatcherParams): any;
+export {};