@ynhcj/xiaoyi-channel 1.1.26 → 1.1.28

package/dist/src/reply-dispatcher.js

@@ -1,11 +1,56 @@
 import { getXYRuntime } from "./runtime.js";
-import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
+import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate, sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
+import { clearRunCrossTaskSentFiles, getCurrentSessionContext } from "./tools/session-manager.js";
 import fs from "fs/promises";
 import path from "path";
 import { logger } from "./utils/logger.js";
 const TEMP_FILE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const RUN_CROSS_TASK_LOG_TAG = "[RunCrossTask]";
+function buildDistributionStatusCommand(context) {
+    return {
+        header: {
+            namespace: "DistributionInteraction",
+            name: "DistributionStatus",
+        },
+        payload: {
+            agentId: context.agentId,
+            isDistributed: true,
+            networkId: context.networkId,
+            distributionType: "softbus",
+            distributionExecutePolicy: "backgroundExecution",
+        },
+    };
+}
+function buildCrossTaskExecuteResultCommand(code, message, sentFiles = []) {
+    return {
+        header: {
+            namespace: "DistributionInteraction",
+            name: "CrossTaskExecuteResult",
+        },
+        payload: {
+            code,
+            message,
+            sentFiles,
+        },
+    };
+}
+async function sendRunCrossTaskResult(params) {
+    const { config, sessionId, taskId, messageId, context, resultCode, resultMessage } = params;
+    const sentFiles = Array.isArray(context.sentFiles) ? context.sentFiles : [];
+    const statusCommand = buildDistributionStatusCommand(context);
+    const resultCommand = buildCrossTaskExecuteResultCommand(resultCode, resultMessage, sentFiles);
+    await sendCommand({
+        config,
+        sessionId,
+        taskId,
+        messageId,
+        commands: [statusCommand, resultCommand],
+    });
+    clearRunCrossTaskSentFiles(context);
+    logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, sentFileCount=${sentFiles.length}, clearedSentFileCount=${sentFiles.length}, messageLength=${resultMessage.length}`);
+}
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
  */
@@ -32,11 +77,11 @@ export async function cleanupStaleTempFiles(tempDir = "/tmp/xy_channel") {
             }
         }
         if (cleanedCount > 0) {
-            logger.log(`[CLEANUP] 🧹 Cleaned ${cleanedCount} stale files (>${TEMP_FILE_TTL_MS / 1000 / 3600}h) from ${tempDir}`);
+            logger.log(`[CLEANUP] Cleaned ${cleanedCount} stale files (>${TEMP_FILE_TTL_MS / 1000 / 3600}h) from ${tempDir}`);
         }
     }
     catch (err) {
-        logger.error(`[CLEANUP] ❌ Failed to cleanup temp dir:`, err);
+        logger.error(`[CLEANUP] Failed to cleanup temp dir:`, err);
     }
 }
 /**
@@ -46,21 +91,19 @@ export async function cleanupStaleTempFiles(tempDir = "/tmp/xy_channel") {
  */
 export function createXYReplyDispatcher(params) {
     const { cfg, runtime, sessionId, taskId, messageId, accountId, steerState } = params;
-    logger.log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
-    logger.log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
     // 初始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;
     };
+    // Create a scoped logger that always uses this session's sessionId
+    // and dynamically resolves the latest taskId
+    const scopedLog = () => logger.withContext(sessionId, getActiveTaskId());
+    scopedLog().log(`[DISPATCHER-CREATE] Creating dispatcher`);
     const core = getXYRuntime();
     const config = resolveXYConfig(cfg);
     // Simplified prefix context for single-account Xiaoyi channel
@@ -73,18 +116,20 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     let finalSent = false;
     let accumulatedText = "";
+    const initialRunCrossTaskContext = getCurrentSessionContext()?.runCrossTaskContext;
+    const getRunCrossTaskContext = () => {
+        return getCurrentSessionContext()?.runCrossTaskContext ?? initialRunCrossTaskContext;
+    };
     /**
      * Start the status update interval
      */
     const startStatusInterval = () => {
-        logger.log(`[STATUS INTERVAL] Starting interval for session ${sessionId}`);
+        scopedLog().log(`[STATUS-INTERVAL] Starting interval`);
         statusUpdateInterval = setInterval(() => {
             // 🔑 使用动态taskId
             const currentTaskId = getActiveTaskId();
             const currentMessageId = getActiveMessageId();
-            logger.log(`[STATUS INTERVAL] Triggering status update`);
-            logger.log(`[STATUS INTERVAL]   - sessionId: ${sessionId}`);
-            logger.log(`[STATUS INTERVAL]   - currentTaskId: ${currentTaskId}`);
+            scopedLog().log(`[STATUS-INTERVAL] Triggering status update, taskId=${currentTaskId}`);
             void sendStatusUpdate({
                 config,
                 sessionId,
@@ -93,13 +138,13 @@ export function createXYReplyDispatcher(params) {
                 text: "任务正在处理中，请稍候~",
                 state: "working",
             }).catch((err) => {
-                logger.error(`Failed to send status update:`, err);
+                scopedLog().error(`Failed to send status update:`, err);
             });
         }, 30000); // 30 seconds
     };
     const stopStatusInterval = () => {
         if (statusUpdateInterval) {
-            logger.log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}`);
+            scopedLog().log(`[STATUS-INTERVAL] Stopping interval`);
             clearInterval(statusUpdateInterval);
             statusUpdateInterval = null;
         }
@@ -110,38 +155,43 @@ export function createXYReplyDispatcher(params) {
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
         onReplyStart: () => {
             const currentTaskId = getActiveTaskId();
-            logger.log(`[REPLY START] Reply started for session ${sessionId}, taskId=${currentTaskId}, steered=${steerState.steered}`);
+            scopedLog().log(`[REPLY-START] Reply started, taskId=${currentTaskId}, steered=${steerState.steered}`);
         },
         deliver: async (payload, info) => {
             // 🔑 steered dispatch不发送内容（让主dispatcher处理）
             if (steerState.steered) {
-                logger.log(`[DELIVER] Steered dispatch - skipping deliver, info.kind=${info?.kind}`);
+                scopedLog().log(`[DELIVER] Steered dispatch, skipping, kind=${info?.kind}`);
                 return;
             }
             const text = payload.text ?? "";
             const currentTaskId = getActiveTaskId();
             const currentMessageId = getActiveMessageId();
-            logger.log(`[DELIVER] sessionId=${sessionId}, taskId=${currentTaskId}, info.kind=${info?.kind}, text.length=${text.length}`);
+            scopedLog().log(`[DELIVER] kind=${info?.kind}, text.length=${text.length}`);
             try {
                 if (!text.trim()) {
-                    logger.log(`[DELIVER SKIP] Empty text, skipping`);
+                    scopedLog().log(`[DELIVER SKIP] Empty text, skipping`);
+                    return;
+                }
+                // 🔑 如果 onPartialReply 已经流式发送过文本，deliver 不再重复发送
+                if (hasSentResponse) {
+                    scopedLog().log(`[DELIVER SKIP] Already sent via onPartialReply`);
                     return;
                 }
                 accumulatedText += text;
                 hasSentResponse = true;
-                logger.log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
-                // 🔑 使用动态taskId发送reasoningText更新
-                await sendReasoningTextUpdate({
+                // 🔑 使用动态taskId发送A2A响应（流式append）
+                await sendA2AResponse({
                     config,
                     sessionId,
                     taskId: currentTaskId,
                     messageId: currentMessageId,
                     text,
+                    append: true,
+                    final: false,
                 });
-                logger.log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
             }
             catch (deliverError) {
-                logger.error(`Failed to deliver message:`, deliverError);
+                scopedLog().error(`Failed to deliver message:`, deliverError);
             }
         },
         onError: async (err, info) => {
@@ -149,7 +199,7 @@ export function createXYReplyDispatcher(params) {
             stopStatusInterval();
             // 🔑 steered dispatcher不发送错误状态（让主dispatcher处理）
             if (steerState.steered) {
-                logger.log(`[ON_ERROR] Steered dispatch - skipping error response`);
+                scopedLog().log(`[ON-ERROR] Steered dispatch, skipping error response`);
                 return;
             }
             if (!hasSentResponse) {
@@ -166,29 +216,36 @@ export function createXYReplyDispatcher(params) {
                     });
                 }
                 catch (statusError) {
-                    logger.error(`Failed to send error status:`, statusError);
+                    scopedLog().error(`Failed to send error status:`, statusError);
                 }
             }
         },
         onIdle: async () => {
             const currentTaskId = getActiveTaskId();
             const currentMessageId = getActiveMessageId();
-            logger.log(`[ON_IDLE] Reply idle`);
-            logger.log(`[ON_IDLE]   - sessionId: ${sessionId}`);
-            logger.log(`[ON_IDLE]   - taskId: ${currentTaskId}`);
-            logger.log(`[ON_IDLE]   - steered: ${steerState.steered}`);
-            logger.log(`[ON_IDLE]   - hasSentResponse: ${hasSentResponse}`);
-            logger.log(`[ON_IDLE]   - finalSent: ${finalSent}`);
+            scopedLog().log(`[ON-IDLE] Reply idle, steered=${steerState.steered}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
             // 🔑 steered dispatch不发送final响应（核心已注入到活跃 Pi run）
             if (steerState.steered) {
-                logger.log(`[ON_IDLE] Steered dispatch - skipping final response`);
+                scopedLog().log(`[ON-IDLE] Steered dispatch, skipping final response`);
                 stopStatusInterval();
                 return; // ← 直接返回，不发送任何东西！
             }
             // 正常模式（或未被steer的dispatch）
             if (hasSentResponse && !finalSent) {
-                logger.log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
+                scopedLog().log(`[ON-IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
+                    const runCrossTaskContext = getRunCrossTaskContext();
+                    if (runCrossTaskContext) {
+                        await sendRunCrossTaskResult({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            context: runCrossTaskContext,
+                            resultCode: "0",
+                            resultMessage: accumulatedText,
+                        });
+                    }
                     // 🔑 使用动态taskId发送完成状态
                     await sendStatusUpdate({
                         config,
@@ -198,28 +255,40 @@ export function createXYReplyDispatcher(params) {
                         text: "任务处理已完成~",
                         state: "completed",
                     });
-                    logger.log(`[ON_IDLE] ✅ Sent completion status update`);
-                    // 🔑 使用动态taskId发送最终响应
+                    scopedLog().log(`[ON-IDLE] Sent completion status update`);
+                    // 🔑 使用动态taskId发送最终响应（空字符串表示流结束）
                     await sendA2AResponse({
                         config,
                         sessionId,
                         taskId: currentTaskId,
                         messageId: currentMessageId,
-                        text: accumulatedText,
-                        append: false,
+                        text: "",
+                        append: true,
                         final: true,
                     });
                     finalSent = true;
-                    logger.log(`[ON_IDLE] ✅ Sent final response with taskId=${currentTaskId}`);
+                    scopedLog().log(`[ON-IDLE] Sent final response (empty, stream end)`);
                 }
                 catch (err) {
-                    logger.error(`[ON_IDLE] Failed to send final response:`, err);
+                    scopedLog().error(`[ON-IDLE] Failed to send final response:`, err);
                 }
             }
             else {
                 // 正常失败场景（非steered）
-                logger.log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                scopedLog().log(`[ON-IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
                 try {
+                    const runCrossTaskContext = getRunCrossTaskContext();
+                    if (runCrossTaskContext) {
+                        await sendRunCrossTaskResult({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            context: runCrossTaskContext,
+                            resultCode: "1",
+                            resultMessage: "任务执行异常，请重试",
+                        });
+                    }
                     await sendStatusUpdate({
                         config,
                         sessionId,
@@ -228,36 +297,37 @@ export function createXYReplyDispatcher(params) {
                         text: "任务处理中断了~",
                         state: "failed",
                     });
-                    logger.log(`[ON_IDLE] ✅ Sent failure status update`);
+                    scopedLog().log(`[ON-IDLE] Sent failure status update`);
                     await sendA2AResponse({
                         config,
                         sessionId,
                         taskId: currentTaskId,
                         messageId: currentMessageId,
                         text: "任务执行异常，请重试~",
-                        append: false,
+                        append: true,
                         final: true,
                         errorCode: 99921111,
                         errorMessage: "任务执行异常，请重试",
                     });
                     finalSent = true;
-                    logger.log(`[ON_IDLE] ✅ Sent error response with code: 99921111`);
+                    scopedLog().log(`[ON-IDLE] Sent error response, code=99921111`);
                 }
                 catch (err) {
-                    logger.error(`[ON_IDLE] Failed to send error response:`, err);
+                    scopedLog().error(`[ON-IDLE] Failed to send error response:`, err);
                 }
             }
             stopStatusInterval();
         },
         onCleanup: () => {
             const currentTaskId = getActiveTaskId();
-            logger.log(`[ON_CLEANUP] Reply cleanup, taskId=${currentTaskId}, steered=${steerState.steered}`);
+            scopedLog().log(`[ON-CLEANUP] Reply cleanup, steered=${steerState.steered}`);
         },
     });
     return {
         dispatcher,
         replyOptions: {
             ...replyOptions,
+            suppressToolErrorWarnings: true,
             onModelSelected: prefixContext.onModelSelected,
             onToolStart: async ({ name, phase }) => {
                 // 🔑 steered dispatch不发送tool状态（让主dispatcher处理）
@@ -266,13 +336,13 @@ export function createXYReplyDispatcher(params) {
                 }
                 const currentTaskId = getActiveTaskId();
                 const currentMessageId = getActiveMessageId();
-                logger.log(`[TOOL START] Tool: ${name}, phase: ${phase}, taskId: ${currentTaskId}`);
+                scopedLog().log(`[TOOL-START] Tool: ${name}, phase: ${phase}`);
                 if (phase === "start") {
                     const toolName = name || "unknown";
                     // call_device_tool 由自身 execute() 内部发送具体子工具名的状态更新
                     // get_xxx_tool_schema 是给 LLM 查 schema 用的，无需向用户展示
                     if (toolName === "call_device_tool" || toolName.endsWith("_tool_schema") || toolName === "huawei_id_tool") {
-                        logger.log(`[TOOL START] Skipping generic status for ${toolName}`);
+                        scopedLog().log(`[TOOL-START] Skipping generic status for ${toolName}`);
                         return;
                     }
                     try {
@@ -284,10 +354,10 @@ export function createXYReplyDispatcher(params) {
                             text: `正在使用工具: ${toolName}...`,
                             state: "working",
                         });
-                        logger.log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                        scopedLog().log(`[TOOL-START] Sent status update for tool start: ${toolName}`);
                     }
                     catch (err) {
-                        logger.error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                        scopedLog().error(`[TOOL-START] Failed to send tool start status:`, err);
                     }
                 }
             },
@@ -300,7 +370,7 @@ export function createXYReplyDispatcher(params) {
                 const currentMessageId = getActiveMessageId();
                 const text = payload.text ?? "";
                 const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
-                logger.log(`[TOOL RESULT] Tool result, taskId: ${currentTaskId}, text.length: ${text.length}`);
+                scopedLog().log(`[TOOL-RESULT] Tool result, text.length: ${text.length}`);
                 try {
                     if (text.length > 0 || hasMedia) {
                         const resultText = text.length > 0 ? text : "工具执行完成";
@@ -312,11 +382,11 @@ export function createXYReplyDispatcher(params) {
                             text: resultText,
                             state: "working",
                         });
-                        logger.log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                        scopedLog().log(`[TOOL-RESULT] Sent tool result as status update`);
                     }
                 }
                 catch (err) {
-                    logger.error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                    scopedLog().error(`[TOOL-RESULT] Failed to send tool result status:`, err);
                 }
             },
             onReasoningStream: async (payload) => {
@@ -324,10 +394,29 @@ export function createXYReplyDispatcher(params) {
                 if (steerState.steered) {
                     return;
                 }
-                const text = payload.text ?? "";
-                logger.log(`[REASONING STREAM] Reasoning chunk received, text.length: ${text.length}`);
-                // Reasoning stream 目前被注释掉
-                // 如果需要可以启用
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                let text = payload.text ?? "";
+                // Strip "Reasoning:" prefix that some reasoning models add to their thinking output
+                const lines = text.split(/\r?\n/);
+                if (lines[0]?.trim() === "Reasoning:") {
+                    text = lines.slice(1).join("\n").trim();
+                }
+                try {
+                    if (text.length > 0) {
+                        await sendReasoningTextUpdate({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            text,
+                            append: false,
+                        });
+                    }
+                }
+                catch (err) {
+                    scopedLog().error(`[REASONING-STREAM] Failed to send reasoning text:`, err);
+                }
             },
             onPartialReply: async (payload) => {
                 // 🔑 steered dispatch不发送partial reply（让主dispatcher处理）
@@ -339,18 +428,22 @@ export function createXYReplyDispatcher(params) {
                 const text = payload.text ?? "";
                 try {
                     if (text.length > 0) {
-                        await sendReasoningTextUpdate({
+                        accumulatedText += text;
+                        hasSentResponse = true;
+                        await sendA2AResponse({
                             config,
                             sessionId,
                             taskId: currentTaskId,
                             messageId: currentMessageId,
                             text,
                             append: false,
+                            final: false,
+                            log: false,
                         });
                     }
                 }
                 catch (err) {
-                    logger.error(`[PARTIAL REPLY] ❌ Failed to send partial reply:`, err);
+                    scopedLog().error(`[PARTIAL-REPLY] Failed to send partial reply:`, err);
                 }
             },
         },

package/dist/src/self-evolution-handler.d.ts

@@ -1,5 +1,5 @@
 import type { XYWebSocketManager } from "./websocket.js";
-export declare function handleSelfEvolutionEvent(context: any, runtime: any): void;
+export declare function handleSelfEvolutionEvent(context: any, cfg: any): Promise<void>;
 /**
  * 读取 .xiaoyiruntime 中的 selfEvolutionState 并直接通过 wsManager 下发指令回复设备
  * 参考trigger实现：直接使用当前已连接的 wsManager 发送消息，避免 getXYWebSocketManager 返回未连接实例

package/dist/src/self-evolution-handler.js

@@ -1,14 +1,20 @@
 import { readFileSync, writeFileSync } from "fs";
 import { v4 as uuidv4 } from "uuid";
+import { resolveXYConfig } from "./config.js";
+import { sendA2AResponse } from "./formatter.js";
 import { logger } from "./utils/logger.js";
 const XIAOYIRUNTIME_PATH = "/home/sandbox/.openclaw/.xiaoyiruntime";
-export function handleSelfEvolutionEvent(context, runtime) {
+export async function handleSelfEvolutionEvent(context, cfg) {
     try {
         const state = context.event?.payload?.selfEvolutionState;
         if (typeof state !== "string") {
             logger.error("[SELF_EVOLUTION] invalid payload: missing selfEvolutionState");
             return;
         }
+        const sessionId = context.sessionId ?? "";
+        const taskId = context.taskId ?? sessionId;
+        const messageId = context.messageId ?? uuidv4();
+        const config = resolveXYConfig(cfg);
         logger.log(`[SELF_EVOLUTION] received state: ${state}`);
         let content;
         try {
@@ -19,6 +25,8 @@ export function handleSelfEvolutionEvent(context, runtime) {
             logger.log(`[SELF_EVOLUTION] ${XIAOYIRUNTIME_PATH} not found, creating new file`);
             writeFileSync(XIAOYIRUNTIME_PATH, `selfEvolutionState=${state}\n`, "utf-8");
             logger.log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
+            await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+            logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
             return;
         }
         const lines = content.split("\n");
@@ -40,6 +48,9 @@ export function handleSelfEvolutionEvent(context, runtime) {
             writeFileSync(XIAOYIRUNTIME_PATH, updated.join("\n"), "utf-8");
         }
         logger.log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIRUNTIME_PATH}`);
+        // Reply with final empty response to acknowledge the state update
+        await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+        logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
     }
     catch (err) {
         logger.error("[SELF_EVOLUTION] failed to handle event:", err);
@@ -108,7 +119,7 @@ export async function handleSelfEvolutionStateGetEvent(context, cfg, runtime, ws
                 kind: "artifact-update",
                 append: false,
                 lastChunk: true,
-                final: false,
+                final: true,
                 artifact: {
                     artifactId: uuidv4(),
                     parts: [{
@@ -127,7 +138,7 @@ export async function handleSelfEvolutionStateGetEvent(context, cfg, runtime, ws
             taskId,
             msgDetail: JSON.stringify(jsonRpcResponse),
         };
-        logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
+        logger.log(`[A2A_COMMAND] Sending A2A command, taskId: ${taskId}`);
         await wsManager.sendMessage(sessionId, outboundMessage);
         logger.log(`[SELF_EVOLUTION_GET] command sent successfully`);
     }

package/dist/src/sensitive-redactor.d.ts

@@ -0,0 +1,4 @@
+export declare function refreshSensitivePatterns(): void;
+export declare function redactSensitiveText(text: any): any;
+export declare function redactSensitiveObject(obj: any): any;
+export declare function containsSensitiveInfo(text: any): boolean;