@ynhcj/xiaoyi-channel 0.0.138-beta → 0.0.138-next

package/dist/src/bot.d.ts

@@ -24,3 +24,8 @@ export interface HandleXYMessageParams {
  * Runtime is expected to be validated before calling this function.
  */
 export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
+/**
+ * 由 provider.ts 在 wrapStreamFn 调用时触发。
+ * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
+ */
+export declare function notifyModelStreaming(sessionId: string): void;

package/dist/src/bot.js

@@ -197,11 +197,40 @@ export async function handleXYMessage(params) {
                 logger.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
-        // 🔑 Steer消息加 /steer 前缀，触发core的 queueEmbeddedPiMessage
-        if (isUpdate && textForAgent) {
-            textForAgent = `/steer ${textForAgent}`;
-            logger.log(`[BOT] 🔄 Prepended /steer for steer injection`);
+        // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
+        // /steer 前缀由 dispatchSteerWhenReady 内部添加
+        if (isUpdate) {
+            // 立即释放 init gate——steer 不走 withReplyDispatcher 的 run()
+            // 回调，onInitComplete 永远不会被触发。如果不释放，后续消息
+            // 会被 globalDispatchInitGate 永久阻塞。
+            params.onInitComplete?.();
+            // Steer 也支持文件 —— 提取并下载，附带到 mediaPayload
+            const steerFileParts = extractFileParts(parsed.parts);
+            const steerDownloadedFiles = await downloadFilesFromParts(steerFileParts);
+            const steerMediaPayload = buildXYMediaPayload(steerDownloadedFiles);
+            if (steerFileParts.length > 0) {
+                logger.log(`[BOT] 📎 Steer message with files: ${steerFileParts.length} file(s)`);
+            }
+            logger.log(`[BOT] 🔄 Steer message — enqueuing to streaming-signal queue`);
+            await enqueueSteer({
+                sessionId: parsed.sessionId,
+                sessionKey: route.sessionKey,
+                steerText: textForAgent, // 原始文本，不带 /steer 前缀
+                mediaPayload: steerMediaPayload,
+                cfg,
+                runtime,
+                parsed,
+                route,
+                deviceType,
+            });
+            logger.log(`[BOT] ✅ Steer queue completed for session: ${parsed.sessionId}`);
+            logger.log(`xy: dispatch complete (session=${parsed.sessionId})`);
+            return;
         }
+        // ── First message (non-steer) path below ──────────────────────
+        // 🔑 立即创建 streaming 信号——必须在文件下载等耗时操作之前，
+        // 否则 steer 消息的 dispatchSteerWhenReady 会找不到信号而跳过等待。
+        createStreamingSignal(parsed.sessionId);
         // File download — only for real user messages, steer injections have no files
         let mediaPayload = {};
         if (!skipReg) {
@@ -241,7 +270,7 @@ export async function handleXYMessage(params) {
             SenderId: parsed.sessionId,
             Provider: "xiaoyi-channel",
             Surface: "xiaoyi-channel",
-            MessageSid: `${parsed.taskId}_${deviceType}`,
+            MessageSid: `xiaoyi_${parsed.taskId}_${deviceType}`,
             Timestamp: Date.now(),
             WasMentioned: false,
             CommandAuthorized: true,
@@ -250,10 +279,8 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // 🔑 Dynamic steer state: when isUpdate (second message), start as steered=true
-        // so the dispatcher skips all user-facing callbacks (deliver, onIdle, etc.)
-        // and onSettled skips cleanup.
-        const steerState = { steered: isUpdate };
+        // 🔑 Streaming 信号已在上方创建（在文件下载之前）
+        const steerState = { steered: false };
         // 🔑 创建dispatcher
         logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
         logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
@@ -290,6 +317,7 @@ export async function handleXYMessage(params) {
                     logger.log(`[BOT] ✅ Steered dispatch settled (skipping cleanup)`);
                     return;
                 }
+                streamingSignals.delete(parsed.sessionId);
                 decrementTaskIdRef(parsed.sessionId);
                 unregisterSession(route.sessionKey);
                 logger.log(`[BOT] ✅ Cleanup completed`);
@@ -386,3 +414,169 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
+// Use globalThis to survive module deduplication — provider.ts may load a
+// different copy of bot.ts, so a plain module-level Map would be two objects.
+const _g = globalThis;
+if (!_g.__xyStreamingSignals)
+    _g.__xyStreamingSignals = new Map();
+if (!_g.__xySteerQueues)
+    _g.__xySteerQueues = new Map();
+const streamingSignals = _g.__xyStreamingSignals;
+const steerQueues = _g.__xySteerQueues;
+/**
+ * 由 provider.ts 在 wrapStreamFn 调用时触发。
+ * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
+ */
+export function notifyModelStreaming(sessionId) {
+    const signal = streamingSignals.get(sessionId);
+    if (signal) {
+        // 不删除 signal——后续 steer 需要靠它判断模型已在 streaming。
+        // 清理由第一条消息的 onSettled 兜底。
+        signal.notify();
+        logger.log(`[STEER-QUEUE] 📡 Model streaming signal fired for session=${sessionId}`);
+    }
+}
+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;
+}
+/**
+ * 将 steer 消息放入 per-session 串行队列。
+ * 等待第一条消息的 streaming 信号（deliver 首次触发），然后 dispatch。
+ * 多个 steer 按到达顺序串行处理，无需重试。
+ */
+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((err) => {
+        logger.error(`[STEER-QUEUE] ❌ Steer chain failed: ${String(err)}`);
+    }).finally(() => {
+        if (steerQueues.get(sessionId) === next) {
+            steerQueues.delete(sessionId);
+        }
+    });
+    return next;
+}
+async function dispatchSteerWhenReady(params) {
+    const { sessionId, sessionKey, steerText } = params;
+    // 1. 等待第一条消息开始 streaming
+    //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
+    //    轮询等待直到 signal 出现，最長等待 ~5 秒。
+    let signal = streamingSignals.get(sessionId);
+    if (!signal) {
+        logger.log(`[STEER-QUEUE] ⏳ Signal not yet created, polling for session=${sessionId}`);
+        for (let i = 0; i < 50; i++) {
+            await new Promise(r => setTimeout(r, 100));
+            signal = streamingSignals.get(sessionId);
+            if (signal)
+                break;
+            if (!hasActiveTask(sessionId)) {
+                logger.log(`[STEER-QUEUE] ℹ️ First message completed while waiting, skip steer`);
+                return;
+            }
+        }
+    }
+    if (signal) {
+        logger.log(`[STEER-QUEUE] ⏳ Waiting for streaming signal, session=${sessionId}`);
+        await signal.promise;
+        logger.log(`[STEER-QUEUE] ✅ Streaming signal received, session=${sessionId}`);
+    }
+    else {
+        // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
+        // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
+        logger.log(`[STEER-QUEUE] ⚠️ Signal never appeared after polling, skip steer to avoid collision`);
+        return;
+    }
+    // 2. 第一条消息已结束 → 放弃
+    if (!hasActiveTask(sessionId)) {
+        logger.log(`[STEER-QUEUE] ℹ️ First message completed, skip steer`);
+        return;
+    }
+    // 3. 构建 dispatch 上下文并 dispatch /steer
+    const core = getXYRuntime();
+    const speaker = sessionId;
+    // 如果有文件附件，把路径拼到 steer 文本末尾，让模型通过工具读取
+    const mediaPaths = params.mediaPayload?.MediaPaths;
+    const fileHint = mediaPaths && mediaPaths.length > 0
+        ? `\n【用户上传附件】：${JSON.stringify(mediaPaths)}`
+        : "";
+    const steerCommand = `/steer ${steerText}${fileHint}`;
+    const messageBody = `${speaker}: ${steerCommand}`;
+    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: steerCommand,
+        CommandBody: steerCommand,
+        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: `xiaoyi_${params.parsed.taskId}_${params.deviceType}`,
+        Timestamp: Date.now(),
+        WasMentioned: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "xiaoyi-channel",
+        OriginatingTo: sessionId,
+        ReplyToBody: undefined,
+        ...params.mediaPayload,
+    });
+    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;
+            });
+        },
+    });
+    logger.log(`[STEER-QUEUE] ✅ Steer dispatch completed for session=${sessionId}`);
+}

package/dist/src/provider.js

@@ -11,6 +11,7 @@ import { createHash } from "crypto";
 import { logger } from "./utils/logger.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
+import { notifyModelStreaming } from "./bot.js";
 // ── Retry config ──────────────────────────────────────────────
 const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
 const MAX_RETRY_ATTEMPTS = 5;
@@ -45,6 +46,11 @@ function getFirstUserText(messages) {
 }
 /** Regex to match `[cron:<uuid> <title>]` anywhere in text. */
 const CRON_TAG_RE = /\[cron:[^\s\]]+\s+([^\]]+)\]/;
+/** Extract the cron job UUID from the first user message, e.g. `[cron:abc123 ...]` → `abc123`. */
+function extractCronUuid(messages) {
+    const match = getFirstUserText(messages).match(/\[cron:([^\s\]]+)/i);
+    return match ? match[1] : undefined;
+}
 /** Check if the request is triggered by a cron job by inspecting the first user message. */
 function isCronTriggered(messages) {
     return /\[cron:/i.test(getFirstUserText(messages));
@@ -230,8 +236,6 @@ const HEADER_SESSION_ID = "x-session-id";
 const HEADER_INTERACTION_ID = "x-interaction-id";
 /** Internal key for passing fallback uid prefix from prepareExtraParams to wrapStreamFn. */
 const FALLBACK_PREFIX_KEY = "_xiaoyi_fallback_prefix";
-/** Internal key for passing deviceType from prepareExtraParams to wrapStreamFn. */
-const DEVICE_TYPE_KEY = "_xiaoyi_device_type";
 const SELF_EVOLUTION_PROMPT_BEGIN = "<self_evolution_prompt>";
 const SELF_EVOLUTION_PROMPT_END = "</self_evolution_prompt>";
 const SELF_EVOLUTION_ENABLED_PROMPT_SECTION = `
@@ -391,7 +395,9 @@ function trimUserMetadata(text) {
 }
 /**
  * Extract A2A taskId and deviceType from Conversation info JSON.
- * bot.ts stores them as MessageSid = "taskId_deviceType".
+ * bot.ts stores them as MessageSid = "xiaoyi_taskId_deviceType".
+ * The "xiaoyi_" prefix ensures extraction only happens for messages
+ * routed through xiaoyi-channel, not other channels sharing the provider.
  */
 function extractA2AFromConversationInfo(text) {
     const match = text.match(/Conversation info \(untrusted metadata\):\n```json\n([\s\S]*?)\n```/);
@@ -401,9 +407,9 @@ function extractA2AFromConversationInfo(text) {
     if (!msgIdMatch)
         return null;
     const parts = msgIdMatch[1].split("_");
-    if (parts.length < 2)
+    if (parts.length < 3 || parts[0] !== "xiaoyi")
         return null;
-    return { taskId: parts[0], deviceType: parts[1] };
+    return { taskId: parts[1], deviceType: parts[2] };
 }
 export const xiaoyiProvider = {
     id: "xiaoyiprovider",
@@ -412,31 +418,12 @@ export const xiaoyiProvider = {
     auth: [],
     isCacheTtlEligible: () => true,
     /**
-     * Inject dynamic session params into extraParams so they flow
-     * through to wrapStreamFn's ctx.extraParams.
-     *
-     * Priority:
-     *   1. Session context (from AsyncLocalStorage, set by bot.ts)
-     *   2. uid-based fallback: sha256(uid).hex[:32]_timestamp
-     *   3. No uid available → return undefined (no headers injected)
+     * Store uid-based fallback prefix for lazy timestamp generation in wrapStreamFn.
+     * Session-level headers (traceId / sessionId / interactionId) are resolved
+     * directly in wrapStreamFn via cron detection, Conversation info extraction,
+     * or uid fallback.
      */
     prepareExtraParams: (ctx) => {
-        const sessionCtx = getCurrentSessionContext();
-        if (sessionCtx) {
-            const taskId = sessionCtx.taskId;
-            const sessionId = taskId.split("&")[0];
-            const interactionId = taskId.split("&")[1] || "";
-            return {
-                ...ctx.extraParams,
-                [HEADER_TRACE_ID]: taskId,
-                [HEADER_SESSION_ID]: sessionId,
-                [HEADER_INTERACTION_ID]: interactionId,
-                [DEVICE_TYPE_KEY]: sessionCtx.deviceType ?? "",
-            };
-        }
-        // Fallback: store uid prefix for lazy timestamp generation in wrapStreamFn.
-        // This ensures each model call gets a fresh timestamp instead of reusing
-        // the same one across tool-use loops and retries.
         const uid = getUidFromConfig(ctx.config);
         if (!uid)
             return undefined;
@@ -487,62 +474,61 @@ export const xiaoyiProvider = {
                 }
             }
             // ── Build dynamic headers ────────────────────────────
-            if (ctx.extraParams) {
-                const fallbackPrefix = ctx.extraParams[FALLBACK_PREFIX_KEY];
+            // Priority:
+            //   1. Cron-triggered: uid → cronUuid, with cron-specific headers
+            //   2. Xiaoyi A2A: taskId extracted from Conversation info (xiaoyi_ prefix)
+            //   3. UID-based fallback: sha256(uid).hex[:32]_timestamp
+            const isCron = isCronTriggered(context.messages);
+            if (isCron) {
+                const fallbackPrefix = ctx.extraParams?.[FALLBACK_PREFIX_KEY];
                 if (typeof fallbackPrefix === "string") {
-                    // Fallback mode: generate fresh timestamp per request
-                    const isCron = isCronTriggered(context.messages);
                     const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
-                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${fallbackValue}` : fallbackValue;
+                    dynamicHeaders[HEADER_TRACE_ID] = `cron_${fallbackValue}`;
                     dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
                     dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
-                    if (isCron) {
-                        const cronTitle = extractCronTitle(context.messages);
-                        if (cronTitle)
-                            dynamicHeaders["x-cron-title"] = encodeURIComponent(cronTitle);
-                        if (context.messages?.length === 1)
-                            dynamicHeaders["x-cron-flag"] = "begin";
-                    }
-                }
-                else if (extractedTaskId) {
-                    // Session mode: taskId extracted from Conversation info
-                    const traceId = extractedTaskId;
-                    const sessionId = traceId.split("&")[0];
-                    const interactionId = traceId.split("&")[1] ?? "";
-                    const isCron = isCronTriggered(context.messages);
-                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}_${Date.now()}` : traceId;
-                    if (isCron) {
-                        const cronTitle = extractCronTitle(context.messages);
-                        if (cronTitle)
-                            dynamicHeaders["x-cron-title"] = encodeURIComponent(cronTitle);
-                        if (context.messages?.length === 1)
-                            dynamicHeaders["x-cron-flag"] = "begin";
-                    }
-                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
-                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
                 }
                 else {
-                    // Fallback: use extraParams cached values
-                    const traceId = ctx.extraParams[HEADER_TRACE_ID];
-                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
-                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
-                    if (typeof traceId === "string")
-                        dynamicHeaders[HEADER_TRACE_ID] = traceId;
-                    if (typeof sessionId === "string")
-                        dynamicHeaders[HEADER_SESSION_ID] = sessionId;
-                    if (typeof interactionId === "string")
-                        dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                    const cronUuid = extractCronUuid(context.messages) ?? "cron";
+                    const cronSessionId = `cron_${cronUuid}_${Date.now()}`;
+                    dynamicHeaders[HEADER_TRACE_ID] = cronSessionId;
+                    dynamicHeaders[HEADER_SESSION_ID] = cronUuid;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = cronSessionId;
+                }
+                const cronTitle = extractCronTitle(context.messages);
+                if (cronTitle)
+                    dynamicHeaders["x-cron-title"] = encodeURIComponent(cronTitle);
+                if (context.messages?.length === 1)
+                    dynamicHeaders["x-cron-flag"] = "begin";
+            }
+            else if (extractedTaskId) {
+                const sessionId = extractedTaskId.split("&")[0];
+                const interactionId = extractedTaskId.split("&")[1] ?? "";
+                dynamicHeaders[HEADER_TRACE_ID] = extractedTaskId;
+                dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+            }
+            else {
+                const fallbackPrefix = ctx.extraParams?.[FALLBACK_PREFIX_KEY];
+                if (typeof fallbackPrefix === "string") {
+                    const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
+                    dynamicHeaders[HEADER_TRACE_ID] = fallbackValue;
+                    dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
                 }
             }
             // 记录输入
             logger.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);
+            // 🔑 通知 steer 队列：模型 API 已被调用，此时 isStreaming 一定为 true
+            const sessionCtx = getCurrentSessionContext();
+            if (sessionCtx?.sessionId) {
+                notifyModelStreaming(sessionCtx.sessionId);
+            }
             if (context.systemPrompt) {
                 logger.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
             // deviceType: prefer value extracted from Conversation info,
-            // then extraParams, then ALS fallback.
-            const extraParamsDeviceType = ctx.extraParams?.[DEVICE_TYPE_KEY] || undefined;
-            const deviceType = (extractedDeviceType || extraParamsDeviceType)
+            // then ALS fallback.
+            const deviceType = extractedDeviceType
                 ?? getCurrentSessionContext()?.deviceType;
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {

package/dist/src/tools/session-manager.js

@@ -8,7 +8,7 @@ import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
  *  仅用于全局 Map 回退路径的清理，不影响 ALS 路径。
  *  工具已改为闭包捕获 ctx，此 TTL 仅作为防止 session 泄漏的最后防线。
  *  正常对话中 registerSession 会刷新 createdAt，所以长对话不受影响。 */
-const SESSION_TTL_MS = 60 * 60 * 1000; // 1 hour
+const SESSION_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
 // Use globalThis to ensure a single Map instance across all module copies.
 // The xy_channel plugin may be loaded by openclaw from different module resolution
 // paths (plugin entry vs tool registration), causing session-manager.ts to be

package/package.json

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