@ynhcj/xiaoyi-channel 0.0.131-next → 0.0.132-next

package/dist/src/bot.js

@@ -254,6 +254,9 @@ export async function handleXYMessage(params) {
         // so the dispatcher skips all user-facing callbacks (deliver, onIdle, etc.)
         // and onSettled skips cleanup.
         const steerState = { steered: isUpdate };
+        // 🔑 第一条消息的 streaming 信号：deliver 首次触发时 resolve
+        // steer 消息通过串行队列等待此信号后再 dispatch
+        const streamingSignal = !isUpdate ? createStreamingSignal(parsed.sessionId) : undefined;
         // 🔑 创建dispatcher
         logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
         logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
@@ -265,6 +268,7 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             accountId: route.accountId,
             steerState,
+            onFirstStream: streamingSignal?.notify,
         });
         // Steer injections don't need status intervals
         if (!skipReg) {
@@ -331,14 +335,12 @@ export async function handleXYMessage(params) {
                 return dispatchPromise;
             },
         });
-        // 🔑 Steer 重试：如果首次注入失败（run 还没 streaming），等待后重试
+        // 🔑 Steer 串行队列：等待 streaming 信号后 dispatch，多个 steer 按顺序处理
         if (isUpdate) {
-            await retrySteerIfNeeded({
-                steerState,
+            await enqueueSteer({
                 sessionId: parsed.sessionId,
                 sessionKey: route.sessionKey,
                 steerText: textForAgent,
-                ctxPayload,
                 cfg,
                 runtime,
                 parsed,
@@ -401,114 +403,121 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
-const STEER_RETRY_DELAYS = [2000, 3000, 5000];
+const streamingSignals = new Map();
+function createStreamingSignal(sessionId) {
+    let resolve;
+    const promise = new Promise(r => { resolve = r; });
+    const signal = { promise, notify: resolve };
+    streamingSignals.set(sessionId, signal);
+    logger.log(`[STEER-QUEUE] 🟢 Streaming signal created for session ${sessionId}`);
+    return signal;
+}
+/** Per-session 串行队列：保证同一 session 的 steer 消息按顺序处理 */
+const steerQueues = new Map();
 /**
- * Steer 注入重试：当首次注入因 run 未 streaming 而失败时，
- * 等待递增延迟后重试，最多尝试 3 次。
+ * 将 steer 消息放入 per-session 串行队列。
+ * 等待第一条消息的 streaming 信号（deliver 首次触发），然后 dispatch。
+ * 多个 steer 按到达顺序串行处理，无需重试。
  */
-async function retrySteerIfNeeded(params) {
-    const { steerState, sessionId, steerText } = params;
-    // 首次成功则无需重试
-    if (steerState.steerResult === 'success') {
-        logger.log(`[STEER-RETRY] ✅ Steer succeeded on first attempt`);
-        return;
+function enqueueSteer(params) {
+    const { sessionId } = params;
+    // 取出当前队列尾部（或 undefined），然后链上新的 Promise
+    const prev = steerQueues.get(sessionId);
+    const next = (prev ?? Promise.resolve()).then(() => dispatchSteerWhenReady(params));
+    steerQueues.set(sessionId, next);
+    // 链条结束后清理
+    next.catch(() => { }).finally(() => {
+        if (steerQueues.get(sessionId) === next) {
+            steerQueues.delete(sessionId);
+        }
+    });
+    return next;
+}
+async function dispatchSteerWhenReady(params) {
+    const { sessionId, sessionKey, steerText } = params;
+    // 1. 等待第一条消息开始 streaming
+    const signal = streamingSignals.get(sessionId);
+    if (signal) {
+        logger.log(`[STEER-QUEUE] ⏳ Waiting for streaming signal, session=${sessionId}`);
+        await signal.promise;
+        streamingSignals.delete(sessionId);
+        logger.log(`[STEER-QUEUE] ✅ Streaming signal received, session=${sessionId}`);
     }
-    // 只有明确失败才重试；无结果可能是异常路径，也尝试重试
-    if (steerState.steerResult !== 'fail' && steerState.steerResult !== undefined) {
+    // 2. 第一条消息已结束 → 放弃
+    if (!hasActiveTask(sessionId)) {
+        logger.log(`[STEER-QUEUE] ℹ️ First message completed, skip steer`);
         return;
     }
-    logger.log(`[STEER-RETRY] ⚠️ First steer attempt result=${steerState.steerResult}, starting retry loop`);
+    // 3. 构建 dispatch 上下文并 dispatch /steer
     const core = getXYRuntime();
-    for (let attempt = 0; attempt < STEER_RETRY_DELAYS.length; attempt++) {
-        const delay = STEER_RETRY_DELAYS[attempt];
-        logger.log(`[STEER-RETRY] ⏳ Waiting ${delay}ms before retry #${attempt + 1}`);
-        await new Promise(resolve => setTimeout(resolve, delay));
-        // 第一条消息已结束，无需继续
-        if (!hasActiveTask(sessionId)) {
-            logger.log(`[STEER-RETRY] ℹ️ First message completed, skip retry`);
-            return;
-        }
-        logger.log(`[STEER-RETRY] 🔄 Retrying steer dispatch #${attempt + 1}`);
-        // 构建新的 steer 消息上下文
-        const speaker = sessionId;
-        const messageBody = `${speaker}: ${steerText}`;
-        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
-        const body = core.channel.reply.formatAgentEnvelope({
-            channel: "xiaoyi-channel",
-            from: speaker,
-            timestamp: new Date(),
-            envelope: envelopeOptions,
-            body: messageBody,
-        });
-        const retryCtx = core.channel.reply.finalizeInboundContext({
-            Body: body,
-            RawBody: steerText,
-            CommandBody: steerText,
-            From: sessionId,
-            To: sessionId,
-            SessionKey: params.route.sessionKey,
-            AccountId: params.route.accountId,
-            ChatType: "direct",
-            GroupSubject: undefined,
-            SenderName: sessionId,
-            SenderId: sessionId,
-            Provider: "xiaoyi-channel",
-            Surface: "xiaoyi-channel",
-            MessageSid: `${params.parsed.taskId}_${params.deviceType}`,
-            Timestamp: Date.now(),
-            WasMentioned: false,
-            CommandAuthorized: true,
-            OriginatingChannel: "xiaoyi-channel",
-            OriginatingTo: sessionId,
-            ReplyToBody: undefined,
-        });
-        const retryState = { steered: true };
-        const { dispatcher: retryDispatcher, replyOptions: retryReplyOptions } = createXYReplyDispatcher({
-            cfg: params.cfg,
-            runtime: params.runtime,
-            sessionId,
-            taskId: params.parsed.taskId,
-            messageId: params.parsed.messageId,
-            accountId: params.route.accountId,
-            steerState: retryState,
-        });
-        const sessionContext = {
-            config: resolveXYConfig(params.cfg),
-            sessionId,
-            taskId: params.parsed.taskId,
-            messageId: params.parsed.messageId,
-            agentId: params.route.accountId,
-            deviceType: params.deviceType,
-        };
-        try {
-            await core.channel.reply.withReplyDispatcher({
-                dispatcher: retryDispatcher,
-                onSettled: () => {
-                    logger.log(`[STEER-RETRY] 🏁 Retry dispatch settled, result=${retryState.steerResult}`);
-                },
-                run: () => {
-                    return runWithSessionContext(sessionContext, async () => {
-                        const result = await core.channel.reply.dispatchReplyFromConfig({
-                            ctx: retryCtx,
-                            cfg: params.cfg,
-                            dispatcher: retryDispatcher,
-                            replyOptions: retryReplyOptions,
-                        });
-                        logger.log(`[STEER-RETRY] dispatch result: ${JSON.stringify(result)}`);
-                        return result;
-                    });
-                },
+    const speaker = sessionId;
+    const messageBody = `${speaker}: ${steerText}`;
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
+    const body = core.channel.reply.formatAgentEnvelope({
+        channel: "xiaoyi-channel",
+        from: speaker,
+        timestamp: new Date(),
+        envelope: envelopeOptions,
+        body: messageBody,
+    });
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+        Body: body,
+        RawBody: steerText,
+        CommandBody: steerText,
+        From: sessionId,
+        To: sessionId,
+        SessionKey: params.route.sessionKey,
+        AccountId: params.route.accountId,
+        ChatType: "direct",
+        GroupSubject: undefined,
+        SenderName: sessionId,
+        SenderId: sessionId,
+        Provider: "xiaoyi-channel",
+        Surface: "xiaoyi-channel",
+        MessageSid: `${params.parsed.taskId}_${params.deviceType}`,
+        Timestamp: Date.now(),
+        WasMentioned: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "xiaoyi-channel",
+        OriginatingTo: sessionId,
+        ReplyToBody: undefined,
+    });
+    const steerState = { steered: true };
+    const { dispatcher, replyOptions } = createXYReplyDispatcher({
+        cfg: params.cfg,
+        runtime: params.runtime,
+        sessionId,
+        taskId: params.parsed.taskId,
+        messageId: params.parsed.messageId,
+        accountId: params.route.accountId,
+        steerState,
+    });
+    const sessionContext = {
+        config: resolveXYConfig(params.cfg),
+        sessionId,
+        taskId: params.parsed.taskId,
+        messageId: params.parsed.messageId,
+        agentId: params.route.accountId,
+        deviceType: params.deviceType,
+    };
+    logger.log(`[STEER-QUEUE] 🚀 Dispatching steer for session=${sessionId}`);
+    await core.channel.reply.withReplyDispatcher({
+        dispatcher,
+        onSettled: () => {
+            logger.log(`[STEER-QUEUE] 🏁 Steer dispatch settled for session=${sessionId}`);
+        },
+        run: () => {
+            return runWithSessionContext(sessionContext, async () => {
+                const result = await core.channel.reply.dispatchReplyFromConfig({
+                    ctx: ctxPayload,
+                    cfg: params.cfg,
+                    dispatcher,
+                    replyOptions,
+                });
+                logger.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
+                return result;
             });
-        }
-        catch (err) {
-            logger.error(`[STEER-RETRY] ❌ Retry dispatch #${attempt + 1} threw: ${String(err)}`);
-            continue;
-        }
-        if (retryState.steerResult === 'success') {
-            logger.log(`[STEER-RETRY] ✅ Steer succeeded on retry #${attempt + 1}`);
-            return;
-        }
-        logger.log(`[STEER-RETRY] ⚠️ Retry #${attempt + 1} result=${retryState.steerResult}, continuing`);
-    }
-    logger.warn(`[STEER-RETRY] ❌ All retries exhausted for session ${sessionId}`);
+        },
+    });
+    logger.log(`[STEER-QUEUE] ✅ Steer dispatch completed for session=${sessionId}`);
 }

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

@@ -8,8 +8,9 @@ export interface CreateXYReplyDispatcherParams {
     accountId: string;
     steerState: {
         steered: boolean;
-        steerResult?: 'success' | 'fail';
     };
+    /** Called the first time deliver fires for a non-steered dispatch — signals the model is streaming. */
+    onFirstStream?: () => void;
 }
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件

package/dist/src/reply-dispatcher.js

@@ -45,7 +45,7 @@ export async function cleanupStaleTempFiles(tempDir = "/tmp/xy_channel") {
  * Runtime is expected to be validated before calling this function.
  */
 export function createXYReplyDispatcher(params) {
-    const { cfg, runtime, sessionId, taskId, messageId, accountId, steerState } = params;
+    const { cfg, runtime, sessionId, taskId, messageId, accountId, steerState, onFirstStream } = params;
     logger.log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
     logger.log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
     // 初始taskId和messageId（作为fallback）
@@ -73,6 +73,7 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     let finalSent = false;
     let accumulatedText = "";
+    let streamingSignaled = false;
     /**
      * Start the status update interval
      */
@@ -115,16 +116,14 @@ export function createXYReplyDispatcher(params) {
         deliver: async (payload, info) => {
             // 🔑 steered dispatch不发送内容（让主dispatcher处理）
             if (steerState.steered) {
-                const text = payload.text ?? '';
-                if (text.includes('steered current session')) {
-                    steerState.steerResult = 'success';
-                }
-                else if (text.includes('not accepting steering') || text.includes('No active run')) {
-                    steerState.steerResult = 'fail';
-                }
-                logger.log(`[DELIVER] Steered dispatch - result=${steerState.steerResult}, info.kind=${info?.kind}, text=${text.slice(0, 80)}`);
+                logger.log(`[DELIVER] Steered dispatch - skipping deliver, info.kind=${info?.kind}`);
                 return;
             }
+            // 🔑 第一次 deliver = 模型开始 streaming，通知等待中的 steer
+            if (onFirstStream && !streamingSignaled) {
+                streamingSignaled = true;
+                onFirstStream();
+            }
             const text = payload.text ?? "";
             const currentTaskId = getActiveTaskId();
             const currentMessageId = getActiveMessageId();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.131-next",
+  "version": "0.0.132-next",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",