@ynhcj/xiaoyi 0.0.1-beta

package/dist/xy-monitor.js

@@ -0,0 +1,194 @@
+"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
+    // 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...");
+            // // 🔍 Diagnose before cleanup
+            // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
+            // diagnoseAllManagers();
+            // 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);
+            // ✅ Disconnect the wsManager to prevent connection leaks
+            // This is safe because each gateway lifecycle should have clean connections
+            wsManager.disconnect();
+            // ✅ Remove manager from cache to prevent reusing dirty state
+            (0, xy_client_js_1.removeXYWebSocketManager)(account);
+            loggedServers.clear();
+            activeMessages.clear();
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+            // // 🔍 Diagnose after cleanup
+            // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
+            // diagnoseAllManagers();
+        };
+        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 {};

package/dist/xy-reply-dispatcher.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXYReplyDispatcher = createXYReplyDispatcher;
+const runtime_js_1 = require("./runtime.js");
+const xy_formatter_js_1 = require("./xy-formatter.js");
+const xy_config_js_1 = require("./xy-config.js");
+/**
+ * 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.
+ */
+function createXYReplyDispatcher(params) {
+    const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher for session=${sessionId}, taskId=${taskId}, messageId=${messageId} *******`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    log(`[DISPATCHER-CREATE] ======== Creating reply dispatcher ========`);
+    log(`[DISPATCHER-CREATE] sessionId: ${sessionId}, taskId: ${taskId}, messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    // Get OpenClaw PluginRuntime (not XiaoYiRuntime)
+    const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const core = xiaoYiRuntime.getPluginRuntime();
+    // Resolve configuration
+    const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+    // Reply prefix context: not imported at runtime to avoid openclaw/plugin-sdk
+    // module resolution issues in the CJS require chain. For a bot-to-bot A2A
+    // channel the response prefix (model name badge) is not needed.
+    const prefixContext = { responsePrefix: undefined, responsePrefixContextProvider: undefined, onModelSelected: undefined };
+    // Status update interval (every 60 seconds)
+    let statusUpdateInterval = null;
+    // Track if we've sent any response
+    let hasSentResponse = false;
+    // Track if we've sent the final empty message
+    let finalSent = false;
+    // Accumulate all text from deliver calls
+    let accumulatedText = "";
+    /**
+     * Start the status update interval
+     * Call this immediately after creating the dispatcher
+     */
+    const startStatusInterval = () => {
+        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}, taskId=${taskId}`);
+        statusUpdateInterval = setInterval(() => {
+            log(`[STATUS INTERVAL] Triggering status update for session ${sessionId}, taskId=${taskId}`);
+            void (0, xy_formatter_js_1.sendStatusUpdate)({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                text: "任务正在处理中，请稍后~",
+                state: "working",
+            }).catch((err) => {
+                error(`Failed to send status update:`, err);
+            });
+        }, 30000); // 30 seconds
+    };
+    /**
+     * Stop the status update interval
+     */
+    const stopStatusInterval = () => {
+        if (statusUpdateInterval) {
+            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}, taskId=${taskId}`);
+            clearInterval(statusUpdateInterval);
+            statusUpdateInterval = null;
+            log(`[STATUS INTERVAL] Stopped interval for session ${sessionId}, taskId=${taskId}`);
+        }
+    };
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+        responsePrefix: prefixContext.responsePrefix,
+        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
+        onReplyStart: () => {
+            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${taskId}`);
+            // Status update interval is now managed externally
+        },
+        deliver: async (payload, info) => {
+            const text = payload.text ?? "";
+            // 🔍 Debug logging
+            log(`[DELIVER] sessionId=${sessionId}, info.kind=${info?.kind}, text.length=${text.length}, text="${text.slice(0, 200)}"`);
+            log(`[DELIVER] payload keys: ${Object.keys(payload).join(", ")}`);
+            if (payload.mediaUrls) {
+                log(`[DELIVER] mediaUrls: ${payload.mediaUrls.length} files`);
+            }
+            try {
+                // Skip empty messages
+                if (!text.trim()) {
+                    log(`[DELIVER SKIP] Empty text, skipping`);
+                    return;
+                }
+                // Accumulate text instead of sending immediately
+                accumulatedText += text;
+                hasSentResponse = true;
+                log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
+                // Also stream text as reasoningText for real-time display
+                await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
+            }
+            catch (deliverError) {
+                error(`Failed to deliver message:`, deliverError);
+            }
+        },
+        onError: async (err, info) => {
+            runtime.error?.(`xy: ${info.kind} reply failed: ${String(err)}`);
+            // Stop status updates
+            stopStatusInterval();
+            // Send error status if we haven't sent any response yet
+            if (!hasSentResponse) {
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "处理失败，请稍后重试",
+                        state: "failed",
+                    });
+                }
+                catch (statusError) {
+                    error(`Failed to send error status:`, statusError);
+                }
+            }
+        },
+        onIdle: async () => {
+            log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+            // Send accumulated text with append=false and final=true
+            if (hasSentResponse && !finalSent) {
+                log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
+                try {
+                    // Send status update before final message
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: accumulatedText,
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] Sent accumulated text`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
+                }
+            }
+            else {
+                log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                // Task was interrupted - send failure status and error response
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                }
+            }
+            // Stop status updates
+            stopStatusInterval();
+        },
+        onCleanup: () => {
+            log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+        },
+    });
+    return {
+        dispatcher,
+        replyOptions: {
+            ...replyOptions,
+            onModelSelected: prefixContext.onModelSelected,
+            // 🔧 Tool execution start callback
+            onToolStart: async ({ name, phase }) => {
+                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: `正在使用工具: ${toolName}...`,
+                            state: "working",
+                        });
+                        log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                    }
+                    catch (err) {
+                        error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                    }
+                }
+            },
+            // 🔧 Tool execution result callback
+            onToolResult: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
+                log(`[TOOL RESULT]   - text.length=${text.length}`);
+                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
+                log(`[TOOL RESULT]   - isError=${payload.isError}`);
+                if (text.length > 0) {
+                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: resultText,
+                            state: "working",
+                        });
+                        log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                    }
+                }
+                catch (err) {
+                    error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                }
+            },
+            // 🧠 Reasoning/thinking process streaming callback
+            onReasoningStream: async (payload) => {
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[REASONING STREAM]   - text.length=${text.length}`);
+                if (text.length > 0) {
+                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                // try {
+                //   if (text.length > 0) {
+                //     await sendReasoningTextUpdate({
+                //       config,
+                //       sessionId,
+                //       taskId,
+                //       messageId,
+                //       text,
+                //     });
+                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
+                //   }
+                // } catch (err) {
+                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
+                // }
+            },
+            // 📝 Partial reply streaming callback (real-time preview)
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
+                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
+                if (text.length > 0) {
+                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0) {
+                        await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                }
+            },
+        },
+        markDispatchIdle,
+        startStatusInterval, // Expose this to be called immediately
+        stopStatusInterval, // Expose this for manual control if needed
+    };
+}