@ynhcj/xiaoyi-channel 0.0.9 → 0.0.10-next

package/dist/src/push.js

@@ -1,46 +1,150 @@
 // Push message service for scheduled tasks
 import fetch from "node-fetch";
-import { logger } from "./utils/logger.js";
+import { randomUUID } from "crypto";
+import { configManager } from "./utils/config-manager.js";
 /**
  * Service for sending push messages to users.
  * Used for outbound messages and scheduled tasks.
  */
 export class XYPushService {
     config;
+    DEFAULT_PUSH_URL = "https://hag.cloud.huawei.com/open-ability-agent/v1/agent-webhook";
+    REQUEST_FROM = "openclaw";
     constructor(config) {
         this.config = config;
     }
+    /**
+     * Generate a random trace ID for request tracking.
+     */
+    generateTraceId() {
+        return `trace-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
     /**
      * Send a push message to a user session.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
      */
-    async sendPush(content, title, sessionId) {
-        const pushUrl = this.config.pushUrl || `${this.config.fileUploadUrl}/push`;
-        logger.debug(`Sending push message: title="${title}"`);
+    async sendPush(content, title, data, sessionId, pushDataId) {
+        const pushUrl = this.config.pushUrl || this.DEFAULT_PUSH_URL;
+        const traceId = this.generateTraceId();
+        // Get dynamic pushId for the session (falls back to config pushId)
+        const dynamicPushId = configManager.getPushId(sessionId);
+        const pushId = dynamicPushId || this.config.pushId;
+        console.log(`[PUSH] 📤 Preparing to send push message`);
+        console.log(`[PUSH]   - Title: "${title}"`);
+        console.log(`[PUSH]   - Content length: ${content.length} chars`);
+        console.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
+        console.log(`[PUSH]   - Trace ID: ${traceId}`);
+        console.log(`[PUSH]   - Push URL: ${pushUrl}`);
+        if (dynamicPushId) {
+            console.log(`[PUSH]   - Using dynamic pushId (from session): ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Full dynamic pushId: ${pushId}`);
+        }
+        else {
+            console.log(`[PUSH]   - Using config pushId (fallback): ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Full config pushId: ${pushId}`);
+        }
+        console.log(`[PUSH]   - API ID: ${this.config.apiId}`);
+        console.log(`[PUSH]   - UID: ${this.config.uid}`);
         try {
-            const request = {
-                apiKey: this.config.apiKey,
-                apiId: this.config.apiId,
-                pushId: this.config.pushId,
-                sessionId: sessionId || "default",
-                title,
-                content,
+            const requestBody = {
+                jsonrpc: "2.0",
+                id: randomUUID(),
+                result: {
+                    id: randomUUID(),
+                    apiId: this.config.apiId,
+                    pushId: pushId, // Use dynamic pushId
+                    pushText: title,
+                    kind: "task",
+                    artifacts: [
+                        {
+                            artifactId: randomUUID(),
+                            parts: pushDataId
+                                ? [
+                                    {
+                                        kind: "data",
+                                        data: {
+                                            pushDataId: pushDataId,
+                                        },
+                                    },
+                                ]
+                                : [
+                                    {
+                                        kind: "text",
+                                        text: content,
+                                    },
+                                ],
+                        },
+                    ],
+                },
             };
+            console.log(`[PUSH] Full request body:`, JSON.stringify(requestBody, null, 2));
             const response = await fetch(pushUrl, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "x-hag-trace-id": traceId,
+                    "x-uid": this.config.uid,
                     "x-api-key": this.config.apiKey,
-                    "x-request-from": "openclaw",
+                    "x-request-from": this.REQUEST_FROM,
                 },
-                body: JSON.stringify(request),
+                body: JSON.stringify(requestBody),
             });
+            // Log response status and headers
+            console.log(`[PUSH] 📥 Response received`);
+            console.log(`[PUSH]   - HTTP Status: ${response.status} ${response.statusText}`);
+            console.log(`[PUSH]   - Content-Type: ${response.headers.get('content-type')}`);
+            console.log(`[PUSH]   - Content-Length: ${response.headers.get('content-length')}`);
             if (!response.ok) {
-                throw new Error(`Push failed: HTTP ${response.status}`);
+                const errorText = await response.text();
+                console.log(`[PUSH] ❌ Push request failed`);
+                console.log(`[PUSH]   - HTTP Status: ${response.status}`);
+                console.log(`[PUSH]   - Response body: ${errorText}`);
+                throw new Error(`Push failed: HTTP ${response.status} - ${errorText}`);
+            }
+            // Try to parse JSON response with detailed error handling
+            let result;
+            try {
+                const responseText = await response.text();
+                console.log(`[PUSH] 📄 Response body length: ${responseText.length} chars`);
+                console.log(`[PUSH] 📄 Response body preview: ${responseText.substring(0, 200)}`);
+                if (!responseText || responseText.trim() === '') {
+                    console.log(`[PUSH] ⚠️ Received empty response body`);
+                    result = {};
+                }
+                else {
+                    result = JSON.parse(responseText);
+                }
+            }
+            catch (parseError) {
+                console.log(`[PUSH] ❌ Failed to parse JSON response`);
+                console.log(`[PUSH]   - Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                throw new Error(`Invalid JSON response from push service: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
             }
-            logger.log(`Push message sent successfully: "${title}"`);
+            console.log(`[PUSH] ✅ Push message sent successfully`);
+            console.log(`[PUSH]   - Title: "${title}"`);
+            console.log(`[PUSH]   - Trace ID: ${traceId}`);
+            console.log(`[PUSH]   - Used pushId: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Response:`, result);
         }
         catch (error) {
-            logger.error("Failed to send push message:", error);
+            console.log(`[PUSH] ❌ Failed to send push message`);
+            console.log(`[PUSH]   - Trace ID: ${traceId}`);
+            console.log(`[PUSH]   - Target URL: ${pushUrl}`);
+            console.log(`[PUSH]   - Push ID: ${pushId.substring(0, 20)}...`);
+            if (error instanceof Error) {
+                console.log(`[PUSH]   - Error name: ${error.name}`);
+                console.log(`[PUSH]   - Error message: ${error.message}`);
+                console.log(`[PUSH]   - Error stack:`, error.stack);
+            }
+            else {
+                console.log(`[PUSH]   - Error:`, error);
+            }
             throw error;
         }
     }
@@ -48,8 +152,10 @@ export class XYPushService {
      * Send a push message with file attachments.
      */
     async sendPushWithFiles(content, title, fileIds, sessionId) {
-        // Build content with file references
-        const contentWithFiles = `${content}\n\n[文件: ${fileIds.join(", ")}]`;
-        await this.sendPush(contentWithFiles, title, sessionId);
+        const data = {
+            content,
+            fileIds,
+        };
+        await this.sendPush(content, title, data, sessionId);
     }
 }

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

@@ -6,6 +6,7 @@ export interface CreateXYReplyDispatcherParams {
     taskId: string;
     messageId: string;
     accountId: string;
+    isSteerFollower?: boolean;
 }
 /**
  * Create a reply dispatcher for XY channel messages.

package/dist/src/reply-dispatcher.js

@@ -1,64 +1,71 @@
 import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 import { getXYRuntime } from "./runtime.js";
-import { sendA2AResponse, sendStatusUpdate } from "./formatter.js";
+import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.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.
  */
 export function createXYReplyDispatcher(params) {
-    const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
+    const { cfg, runtime, sessionId, taskId, messageId, accountId, isSteerFollower } = 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 runtime (already validated in monitor.ts, but get reference for use)
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
+    log(`[DISPATCHER-CREATE]   - sessionId: ${sessionId}`);
+    log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
+    log(`[DISPATCHER-CREATE]   - messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE]   - isSteerFollower: ${isSteerFollower ?? false}`);
+    // 初始taskId和messageId（作为fallback）
+    const initialTaskId = taskId;
+    const initialMessageId = messageId;
+    /**
+     * 🔑 核心改造：动态获取当前活跃的taskId和messageId
+     * 每次需要taskId时，都从TaskManager获取最新值
+     */
+    const getActiveTaskId = () => {
+        return getCurrentTaskId(sessionId) ?? initialTaskId;
+    };
+    const getActiveMessageId = () => {
+        return getCurrentMessageId(sessionId) ?? initialMessageId;
+    };
     const core = getXYRuntime();
-    // Resolve configuration
     const config = resolveXYConfig(cfg);
-    // Create reply prefix context (for model selection, etc.)
     const prefixContext = createReplyPrefixContext({ cfg, agentId: accountId });
-    // 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}`);
+        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}`);
         statusUpdateInterval = setInterval(() => {
-            log(`[STATUS INTERVAL] Triggering status update for session ${sessionId}, taskId=${taskId}`);
+            // 🔑 使用动态taskId
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[STATUS INTERVAL] Triggering status update`);
+            log(`[STATUS INTERVAL]   - sessionId: ${sessionId}`);
+            log(`[STATUS INTERVAL]   - currentTaskId: ${currentTaskId}`);
             void sendStatusUpdate({
                 config,
                 sessionId,
-                taskId,
-                messageId,
+                taskId: currentTaskId, // 🔑 动态taskId
+                messageId: currentMessageId, // 🔑 动态messageId
                 text: "任务正在处理中，请稍后~",
                 state: "working",
             }).catch((err) => {
                 error(`Failed to send status update:`, err);
             });
-        }, 60000); // 60 seconds
+        }, 30000); // 30 seconds
     };
-    /**
-     * Stop the status update interval
-     */
     const stopStatusInterval = () => {
         if (statusUpdateInterval) {
-            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}, taskId=${taskId}`);
+            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}`);
             clearInterval(statusUpdateInterval);
             statusUpdateInterval = null;
-            log(`[STATUS INTERVAL] Stopped interval for session ${sessionId}, taskId=${taskId}`);
         }
     };
     const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
@@ -66,27 +73,31 @@ export function createXYReplyDispatcher(params) {
         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
+            const currentTaskId = getActiveTaskId();
+            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
         },
         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`);
-            }
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[DELIVER] sessionId=${sessionId}, taskId=${currentTaskId}, info.kind=${info?.kind}, text.length=${text.length}`);
             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}`);
+                // 🔑 使用动态taskId发送reasoningText更新
+                await sendReasoningTextUpdate({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
             }
             catch (deliverError) {
                 error(`Failed to deliver message:`, deliverError);
@@ -94,16 +105,21 @@ export function createXYReplyDispatcher(params) {
         },
         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
+            // 🔑 steer follower不发送错误状态（让主dispatcher处理）
+            if (isSteerFollower) {
+                log(`[ON_ERROR] Steer follower - skipping error response`);
+                return;
+            }
             if (!hasSentResponse) {
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
                 try {
                     await sendStatusUpdate({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: "处理失败，请稍后重试",
                         state: "failed",
                     });
@@ -114,37 +130,86 @@ export function createXYReplyDispatcher(params) {
             }
         },
         onIdle: async () => {
-            log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Send accumulated text with append=false and final=true
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[ON_IDLE] Reply idle`);
+            log(`[ON_IDLE]   - sessionId: ${sessionId}`);
+            log(`[ON_IDLE]   - taskId: ${currentTaskId}`);
+            log(`[ON_IDLE]   - isSteerFollower: ${isSteerFollower}`);
+            log(`[ON_IDLE]   - hasSentResponse: ${hasSentResponse}`);
+            log(`[ON_IDLE]   - finalSent: ${finalSent}`);
+            // 🔑 核心改动：steer follower不发送final响应
+            if (isSteerFollower) {
+                log(`[ON_IDLE] Steer follower - skipping final response`);
+                log(`[ON_IDLE]   - Message queued successfully, waiting for primary dispatcher`);
+                stopStatusInterval();
+                return; // ← 直接返回，不发送任何东西！
+            }
+            // 正常模式（或steer的第一条消息）
             if (hasSentResponse && !finalSent) {
                 log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
+                    // 🔑 使用动态taskId发送完成状态
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
+                    // 🔑 使用动态taskId发送最终响应
                     await sendA2AResponse({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: accumulatedText,
                         append: false,
                         final: true,
                     });
                     finalSent = true;
-                    log(`[ON_IDLE] Sent accumulated text`);
+                    log(`[ON_IDLE] ✅ Sent final response with taskId=${currentTaskId}`);
                 }
                 catch (err) {
-                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
+                    error(`[ON_IDLE] Failed to send final response:`, err);
                 }
             }
             else {
+                // 正常失败场景（非steer follower）
                 log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                try {
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await sendA2AResponse({
+                        config,
+                        sessionId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send error response:`, err);
+                }
             }
-            // Stop status updates
             stopStatusInterval();
         },
         onCleanup: () => {
-            log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Stop status updates
-            stopStatusInterval();
+            const currentTaskId = getActiveTaskId();
+            log(`[ON_CLEANUP] Reply cleanup, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
         },
     });
     return {
@@ -152,9 +217,99 @@ export function createXYReplyDispatcher(params) {
         replyOptions: {
             ...replyOptions,
             onModelSelected: prefixContext.onModelSelected,
+            onToolStart: async ({ name, phase }) => {
+                // 🔑 steer follower不发送tool状态（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                log(`[TOOL START] Tool: ${name}, phase: ${phase}, taskId: ${currentTaskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            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);
+                    }
+                }
+            },
+            onToolResult: async (payload) => {
+                // 🔑 steer follower不发送tool结果（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] Tool result, taskId: ${currentTaskId}, text.length: ${text.length}`);
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            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);
+                }
+            },
+            onReasoningStream: async (payload) => {
+                // 🔑 steer follower不发送reasoning stream
+                if (isSteerFollower) {
+                    return;
+                }
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] Reasoning chunk received, text.length: ${text.length}`);
+                // Reasoning stream 目前被注释掉
+                // 如果需要可以启用
+            },
+            onPartialReply: async (payload) => {
+                // 🔑 steer follower不发送partial reply（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                const text = payload.text ?? "";
+                log(`[PARTIAL REPLY] Partial reply chunk received, taskId: ${currentTaskId}`);
+                try {
+                    if (text.length > 0) {
+                        await sendReasoningTextUpdate({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply:`, err);
+                }
+            },
         },
         markDispatchIdle,
-        startStatusInterval, // Expose this to be called immediately
-        stopStatusInterval, // Expose this for manual control if needed
+        startStatusInterval,
+        stopStatusInterval,
     };
 }

package/dist/src/task-manager.d.ts

@@ -0,0 +1,55 @@
+interface TaskIdBinding {
+    sessionId: string;
+    currentTaskId: string;
+    currentMessageId: string;
+    refCount: number;
+    updatedAt: number;
+    locked: boolean;
+}
+/**
+ * 注册或更新session的活跃taskId
+ * 返回是否是更新（用于判断是否是第二条消息）
+ */
+export declare function registerTaskId(sessionId: string, taskId: string, messageId: string, options?: {
+    incrementRef?: boolean;
+}): {
+    isUpdate: boolean;
+    refCount: number;
+};
+/**
+ * 增加引用计数（消息开始处理时调用）
+ */
+export declare function incrementTaskIdRef(sessionId: string): void;
+/**
+ * 减少引用计数，当refCount=0时才真正清理
+ */
+export declare function decrementTaskIdRef(sessionId: string): void;
+/**
+ * 锁定taskId，防止被清理（第一个消息使用）
+ */
+export declare function lockTaskId(sessionId: string): void;
+/**
+ * 解锁taskId（第一个消息完成时使用）
+ */
+export declare function unlockTaskId(sessionId: string): void;
+/**
+ * 获取session的当前活跃taskId
+ */
+export declare function getCurrentTaskId(sessionId: string): string | null;
+/**
+ * 获取session的当前活跃messageId
+ */
+export declare function getCurrentMessageId(sessionId: string): string | null;
+/**
+ * 检查session是否有活跃的taskId
+ */
+export declare function hasActiveTask(sessionId: string): boolean;
+/**
+ * 获取完整的binding信息（用于调试）
+ */
+export declare function getTaskIdBinding(sessionId: string): TaskIdBinding | null;
+/**
+ * 强制清理（错误恢复用）
+ */
+export declare function forceCleanTaskId(sessionId: string): void;
+export {};