@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/xy-bot.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleXYMessage = handleXYMessage;
+const runtime_js_1 = require("./runtime.js");
+const xy_reply_dispatcher_js_1 = require("./xy-reply-dispatcher.js");
+const xy_parser_js_1 = require("./xy-parser.js");
+const file_download_js_1 = require("./file-download.js");
+const xy_config_js_1 = require("./xy-config.js");
+const xy_formatter_js_1 = require("./xy-formatter.js");
+const session_manager_js_1 = require("./xy-tools/session-manager.js");
+const config_manager_js_1 = require("./xy-utils/config-manager.js");
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+async function handleXYMessage(params) {
+    const { cfg, runtime, message, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Get OpenClaw PluginRuntime (not XiaoYiRuntime)
+    const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const core = xiaoYiRuntime.getPluginRuntime();
+    try {
+        // Check for special messages BEFORE parsing (these have different param structures)
+        const messageMethod = message.method;
+        log(`[BOT-ENTRY] <<<<<<< Received message with method: ${messageMethod}, id: ${message.id} >>>>>>>`);
+        log(`[BOT-ENTRY] Stack trace for debugging:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+        // Handle clearContext messages (params only has sessionId)
+        if (messageMethod === "clearContext" || messageMethod === "clear_context") {
+            const sessionId = message.params?.sessionId;
+            if (!sessionId) {
+                throw new Error("clearContext request missing sessionId in params");
+            }
+            log(`Clear context request for session ${sessionId}`);
+            const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+            await (0, xy_formatter_js_1.sendClearContextResponse)({
+                config,
+                sessionId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Handle tasks/cancel messages
+        if (messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
+            const sessionId = message.params?.sessionId;
+            const taskId = message.params?.id || message.id;
+            if (!sessionId) {
+                throw new Error("tasks/cancel request missing sessionId in params");
+            }
+            log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
+            const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+            await (0, xy_formatter_js_1.sendTasksCancelResponse)({
+                config,
+                sessionId,
+                taskId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Parse the A2A message (for regular messages)
+        const parsed = (0, xy_parser_js_1.parseA2AMessage)(message);
+        // Extract and update push_id if present
+        const pushId = (0, xy_parser_js_1.extractPushId)(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            config_manager_js_1.configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
+        // Resolve configuration (needed for status updates)
+        const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+        // ✅ Resolve agent route (following feishu pattern)
+        // accountId is "default" for XY (single account mode)
+        // Use sessionId as peer.id to ensure all messages in the same session share context
+        let route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "xiaoyi-channel",
+            accountId, // "default"
+            peer: {
+                kind: "direct",
+                id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
+            },
+        });
+        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        // Register session context for tools
+        log(`[BOT] 📝 About to register session for tools...`);
+        log(`[BOT]   - sessionKey: ${route.sessionKey}`);
+        log(`[BOT]   - sessionId: ${parsed.sessionId}`);
+        log(`[BOT]   - taskId: ${parsed.taskId}`);
+        (0, session_manager_js_1.registerSession)(route.sessionKey, {
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            agentId: route.accountId,
+        });
+        log(`[BOT] ✅ Session registered for tools`);
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void (0, xy_formatter_js_1.sendStatusUpdate)({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
+        // Extract text and files from parts
+        const text = (0, xy_parser_js_1.extractTextFromParts)(parsed.parts);
+        const fileParts = (0, xy_parser_js_1.extractFileParts)(parsed.parts);
+        // Download files if present (using core's media download)
+        const mediaList = await (0, file_download_js_1.downloadFilesFromParts)(fileParts);
+        // Build media payload for inbound context (following feishu pattern)
+        const mediaPayload = buildXYMediaPayload(mediaList);
+        // Resolve envelope format options (following feishu pattern)
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        // Build message body with speaker prefix (following feishu pattern)
+        let messageBody = text || "";
+        // Add speaker prefix for clarity
+        const speaker = parsed.sessionId;
+        messageBody = `${speaker}: ${messageBody}`;
+        // Format agent envelope (following feishu pattern)
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "xiaoyi-channel",
+            from: speaker,
+            timestamp: new Date(),
+            envelope: envelopeOptions,
+            body: messageBody,
+        });
+        // ✅ Finalize inbound context (following feishu pattern)
+        // Use route.accountId and route.sessionKey instead of parsed fields
+        const ctxPayload = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            RawBody: text || "",
+            CommandBody: text || "",
+            From: parsed.sessionId,
+            To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
+            SessionKey: route.sessionKey, // ✅ Use route.sessionKey
+            AccountId: route.accountId, // ✅ Use route.accountId ("default")
+            ChatType: "direct",
+            GroupSubject: undefined,
+            SenderName: parsed.sessionId,
+            SenderId: parsed.sessionId,
+            Provider: "xiaoyi-channel",
+            Surface: "xiaoyi-channel",
+            MessageSid: parsed.messageId,
+            Timestamp: Date.now(),
+            WasMentioned: false,
+            CommandAuthorized: true,
+            OriginatingChannel: "xiaoyi-channel",
+            OriginatingTo: parsed.sessionId, // Original message target
+            ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
+            ...mediaPayload,
+        });
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void (0, xy_formatter_js_1.sendStatusUpdate)({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
+        // Create reply dispatcher (following feishu pattern)
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
+        const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = (0, xy_reply_dispatcher_js_1.createXYReplyDispatcher)({
+            cfg,
+            runtime,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            accountId: route.accountId, // ✅ Use route.accountId
+        });
+        log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
+        // Start status update interval (will send updates every 60 seconds)
+        // Interval will be automatically stopped when onIdle/onCleanup is triggered
+        startStatusInterval();
+        log(`xy: dispatching to agent (session=${parsed.sessionId})`);
+        // Dispatch to OpenClaw core using correct API (following feishu pattern)
+        log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
+        await core.channel.reply.withReplyDispatcher({
+            dispatcher,
+            onSettled: () => {
+                log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                log(`[BOT]   - About to unregister session...`);
+                markDispatchIdle();
+                // Unregister session context when done
+                (0, session_manager_js_1.unregisterSession)(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered in onSettled`);
+            },
+            run: () => core.channel.reply.dispatchReplyFromConfig({
+                ctx: ctxPayload,
+                cfg,
+                dispatcher,
+                replyOptions,
+            }),
+        });
+        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
+        log(`xy: dispatch complete (session=${parsed.sessionId})`);
+    }
+    catch (err) {
+        // ✅ Only log error, don't re-throw to prevent gateway restart
+        error("Failed to handle XY message:", err);
+        runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
+        log(`[BOT] ❌ Error occurred, attempting cleanup...`);
+        // Try to unregister session on error (if route was established)
+        try {
+            const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+            const core = xiaoYiRuntime.getPluginRuntime();
+            const params = message.params;
+            const sessionId = params?.sessionId;
+            if (sessionId) {
+                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
+                const route = core.channel.routing.resolveAgentRoute({
+                    cfg,
+                    channel: "xiaoyi-channel",
+                    accountId,
+                    peer: {
+                        kind: "direct",
+                        id: sessionId, // ✅ Use sessionId for cleanup consistency
+                    },
+                });
+                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
+                (0, session_manager_js_1.unregisterSession)(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered after error`);
+            }
+        }
+        catch (cleanupErr) {
+            log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
+            // Ignore cleanup errors
+        }
+        // ❌ Don't re-throw: message processing error should not affect gateway stability
+    }
+}
+/**
+ * Build media payload for inbound context.
+ * Following feishu pattern: buildFeishuMediaPayload().
+ */
+function buildXYMediaPayload(mediaList) {
+    const first = mediaList[0];
+    const mediaPaths = mediaList.map((media) => media.path);
+    const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
+    return {
+        MediaPath: first?.path,
+        MediaType: first?.mimeType,
+        MediaUrl: first?.path,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    };
+}
+/**
+ * Infer OpenClaw media type from file type string.
+ */
+function inferMediaType(fileType) {
+    const lower = fileType.toLowerCase();
+    if (lower.includes("image") || /\.(jpg|jpeg|png|gif|bmp|webp)$/i.test(lower)) {
+        return "image";
+    }
+    if (lower.includes("video") || /\.(mp4|avi|mov|mkv|webm)$/i.test(lower)) {
+        return "video";
+    }
+    if (lower.includes("audio") || /\.(mp3|wav|ogg|m4a)$/i.test(lower)) {
+        return "audio";
+    }
+    return "file";
+}

package/dist/xy-client.d.ts

@@ -0,0 +1,26 @@
+import { XiaoYiWebSocketManager } from "./websocket.js";
+import type { XiaoYiChannelConfig } from "./types.js";
+import type { RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+/**
+ * Set the runtime for logging in client module.
+ */
+export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ * Adapted for xiaoyi - uses aksk instead of apiKey/uid
+ */
+export declare function getXYWebSocketManager(config: XiaoYiChannelConfig): XiaoYiWebSocketManager;
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export declare function removeXYWebSocketManager(config: XiaoYiChannelConfig): void;
+/**
+ * Clear all cached WebSocket managers.
+ */
+export declare function clearXYWebSocketManagers(): void;
+/**
+ * Get the number of cached managers.
+ */
+export declare function getCachedManagerCount(): number;

package/dist/xy-client.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setClientRuntime = setClientRuntime;
+exports.getXYWebSocketManager = getXYWebSocketManager;
+exports.removeXYWebSocketManager = removeXYWebSocketManager;
+exports.clearXYWebSocketManagers = clearXYWebSocketManagers;
+exports.getCachedManagerCount = getCachedManagerCount;
+// WebSocket client cache management
+// Adapted for xiaoyi - uses xiaoyi's WebSocket manager with aksk auth
+const websocket_js_1 = require("./websocket.js");
+// Runtime reference for logging
+let runtime;
+/**
+ * Set the runtime for logging in client module.
+ */
+function setClientRuntime(rt) {
+    runtime = rt;
+}
+/**
+ * Global cache for WebSocket managers.
+ * Key format: `${ak}-${agentId}` (using xiaoyi's aksk auth)
+ */
+const wsManagerCache = new Map();
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ * Adapted for xiaoyi - uses aksk instead of apiKey/uid
+ */
+function getXYWebSocketManager(config) {
+    const cacheKey = `${config.ak}-${config.agentId}`;
+    let cached = wsManagerCache.get(cacheKey);
+    if (cached) {
+        const log = runtime?.log ?? console.log;
+        log(`[WS-MANAGER-CACHE] ✅ Reusing cached WebSocket manager: ${cacheKey}, total managers: ${wsManagerCache.size}`);
+        return cached;
+    }
+    // Create new manager with xiaoyi's config (aksk auth)
+    const log = runtime?.log ?? console.log;
+    log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    cached = new websocket_js_1.XiaoYiWebSocketManager(config);
+    wsManagerCache.set(cacheKey, cached);
+    log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    return cached;
+}
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+function removeXYWebSocketManager(config) {
+    const cacheKey = `${config.ak}-${config.agentId}`;
+    const manager = wsManagerCache.get(cacheKey);
+    if (manager) {
+        console.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        manager.disconnect();
+        wsManagerCache.delete(cacheKey);
+        console.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+    }
+    else {
+        console.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+    }
+}
+/**
+ * Clear all cached WebSocket managers.
+ */
+function clearXYWebSocketManagers() {
+    const log = runtime?.log ?? console.log;
+    log("Clearing all WebSocket manager caches");
+    for (const manager of wsManagerCache.values()) {
+        manager.disconnect();
+    }
+    wsManagerCache.clear();
+}
+/**
+ * Get the number of cached managers.
+ */
+function getCachedManagerCount() {
+    return wsManagerCache.size;
+}

package/dist/xy-config.d.ts

@@ -0,0 +1,18 @@
+import type { OpenClawConfig } from "openclaw/dist/plugin-sdk/index.js";
+import type { XiaoYiChannelConfig } from "./types.js";
+type ClawdbotConfig = OpenClawConfig;
+/**
+ * Resolve XiaoYi channel configuration from OpenClaw config.
+ */
+export declare function resolveXYConfig(cfg: ClawdbotConfig): XiaoYiChannelConfig;
+/**
+ * List XiaoYi channel account IDs.
+ * Single account mode - always returns ["default"].
+ */
+export declare function listXYAccountIds(cfg: ClawdbotConfig): string[];
+/**
+ * Get default XiaoYi channel account ID.
+ * Single account mode - always returns "default".
+ */
+export declare function getDefaultXYAccountId(cfg: ClawdbotConfig): string | undefined;
+export {};

package/dist/xy-config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveXYConfig = resolveXYConfig;
+exports.listXYAccountIds = listXYAccountIds;
+exports.getDefaultXYAccountId = getDefaultXYAccountId;
+/**
+ * Resolve XiaoYi channel configuration from OpenClaw config.
+ */
+function resolveXYConfig(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig) {
+        throw new Error("XiaoYi channel configuration not found");
+    }
+    return channelConfig;
+}
+/**
+ * List XiaoYi channel account IDs.
+ * Single account mode - always returns ["default"].
+ */
+function listXYAccountIds(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig || !channelConfig.enabled) {
+        return [];
+    }
+    return ["default"];
+}
+/**
+ * Get default XiaoYi channel account ID.
+ * Single account mode - always returns "default".
+ */
+function getDefaultXYAccountId(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig || !channelConfig.enabled) {
+        return undefined;
+    }
+    return "default";
+}

package/dist/xy-formatter.d.ts

@@ -0,0 +1,94 @@
+import type { XiaoYiChannelConfig, A2ACommand } from "./types.js";
+/**
+ * Parameters for sending an A2A response.
+ */
+export interface SendA2AResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text?: string;
+    append: boolean;
+    final: boolean;
+    files?: Array<{
+        fileName: string;
+        fileType: string;
+        fileId: string;
+    }>;
+}
+/**
+ * Send an A2A artifact update response.
+ */
+export declare function sendA2AResponse(params: SendA2AResponseParams): Promise<void>;
+/**
+ * Parameters for sending a reasoning text update (intermediate, streamed).
+ */
+export interface SendReasoningTextUpdateParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    append?: boolean;
+}
+/**
+ * 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.
+ */
+export declare function sendReasoningTextUpdate(params: SendReasoningTextUpdateParams): Promise<void>;
+/**
+ * Parameters for sending a status update.
+ */
+export interface SendStatusUpdateParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+export declare function sendStatusUpdate(params: SendStatusUpdateParams): Promise<void>;
+/**
+ * Parameters for sending a command.
+ */
+export interface SendCommandParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    command: A2ACommand;
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+export declare function sendCommand(params: SendCommandParams): Promise<void>;
+/**
+ * Parameters for sending a clearContext response.
+ */
+export interface SendClearContextResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    messageId: string;
+}
+/**
+ * Send a clearContext response.
+ */
+export declare function sendClearContextResponse(params: SendClearContextResponseParams): Promise<void>;
+/**
+ * Parameters for sending a tasks/cancel response.
+ */
+export interface SendTasksCancelResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+}
+/**
+ * Send a tasks/cancel response.
+ */
+export declare function sendTasksCancelResponse(params: SendTasksCancelResponseParams): Promise<void>;