@ynhcj/xiaoyi-channel 0.0.222-next → 0.0.224-next

package/dist/index.js

@@ -15,7 +15,8 @@ import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 import { registerCLIHook } from "./src/tools/hmos-cli.js";
 import { recoverCronState } from "./src/cron-recovery.js";
 import { writeSkillUsage } from "./src/utils/skills-logger.js";
-import { markSubagentSpawned, markSubagentEnded, getCachedXYConfig, } from "./src/subagent-wait-state.js";
+import { markSubagentSpawned, markSubagentEnded, deliverSubagentFinalResult, } from "./src/conversation/conversation-manager.js";
+import { notifyCronAgentEnd } from "./src/conversation/cron-buffer.js";
 import { logger } from "./src/utils/logger.js";
 /**
  * Parse a file path string to detect if it refers to a SKILL.md file within
@@ -56,6 +57,7 @@ function registerSkillsDiagnosticHook(api) {
         message: "message",
         get_phone_tool_schema: "phone",
         get_collection_tool_schema: "xiaoyi-collection",
+        image_reading: "xiaoyi-image-understanding"
     };
     // Log skill usage for known device tools on before_tool_call
     api.on("before_tool_call", async (event, _ctx) => {
@@ -330,15 +332,12 @@ function registerSubagentHooks(api) {
             logger.log(`[XY-SUBAGENT-END] ended, targetSessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, complete=${transition?.isComplete ?? false}, shouldFinalize=${transition?.shouldFinalize ?? false}, transition=${!!transition}`);
             if (transition?.shouldFinalize) {
                 logger.log(`[XY-SUBAGENT-END] Starting finalization...`);
-                const config = getCachedXYConfig();
-                if (!config) {
-                    logger.error(`[XY-SUBAGENT-END] No cached XY config, cannot deliver final result`);
-                    return;
-                }
-                const { deliverSubagentFinalResult } = await import("./src/outbound.js");
-                logger.log(`[XY-SUBAGENT-END] Using cached XY config`);
+                // Grace: announce 投递的 sendText 与 subagent_ended hook 并发到达
+                // （实测 sendText 可能先于 hook 约 1s，也可能略晚于 hook），
+                // 短等让最后一条完成文本先落入 completionTexts 再合并发 final 帧。
+                await new Promise((r) => setTimeout(r, 1500));
+                // 最终交付由对话管理层统一负责（含 config 解析、final 帧、清理）
                 await deliverSubagentFinalResult({
-                    config: config,
                     state: transition.state,
                     reason: "all-subagents-ended-after-parent-settled",
                 });
@@ -353,6 +352,33 @@ function registerSubagentHooks(api) {
 function registerFullHooks(api) {
     // SUBAGENT HOOKS: track subagent spawn/end lifecycle for session keep-alive
     registerSubagentHooks(api);
+    // CRON AGGREGATION: 通过 agent 事件总线感知 cron isolated run 结束。
+    // 注意：agent_end 插件 hook 只在 dispatch-from-config 路径触发，cron
+    // isolated run 不会触发它；embedded run 的 lifecycle 事件才是可靠信号。
+    // phase=end/error 后到达的 sendText 即为 announce 最终结果（放行）。
+    api.agent.events.registerAgentEventSubscription({
+        id: "xy-cron-turn-tracker",
+        description: "Track cron isolated run completion for sendText aggregation",
+        streams: ["lifecycle"],
+        handle: (event) => {
+            try {
+                const phase = event?.data?.phase;
+                // 仅 phase=end 是 run 级终态信号；phase=error 可能是单次模型调用
+                // 失败（后续还有重试/start），不能据此放行 announce。
+                // 真正失败的 run（无 end）由 120s 安全超时兜底 flush 缓冲文本。
+                if (phase !== "end")
+                    return;
+                const sessionKey = event?.sessionKey ?? "";
+                if (sessionKey.startsWith("cron:") || sessionKey.includes(":cron:") || isCronActive()) {
+                    logger.log(`[XY-CRON] Cron run lifecycle end, sessionKey=${sessionKey || "unknown"}`);
+                    notifyCronAgentEnd();
+                }
+            }
+            catch (err) {
+                logger.error(`[XY-CRON] Error in cron lifecycle subscription:`, err);
+            }
+        },
+    });
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};
     const skillRetrieverConfig = normalizeToolRetrieverConfig({

package/dist/src/bot.js

@@ -17,7 +17,6 @@ import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
 import { setCsplSteerContext } from "./cspl/steer-context.js";
 import { resolveActiveEmbeddedRunSessionId, queueAgentHarnessMessage, } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { registerTaskId, decrementTaskIdRef, hasActiveTask, } from "./task-manager.js";
-import { registerSessionKeyMapping, getWaitState, hasWaitState, markParentSettled, cacheXYConfig, } from "./subagent-wait-state.js";
 import { logger } from "./utils/logger.js";
 /**
  * Handle an incoming A2A message.
@@ -166,7 +165,6 @@ export async function handleXYMessage(params) {
         const runCrossTaskContext = extractRunCrossTaskContext(parsed.parts);
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
-        cacheXYConfig(config);
         // ✅ Resolve agent route (following feishu pattern)
         // accountId is "default" for XY (single account mode)
         // Use sessionId as peer.id to ensure all messages in the same session share context
@@ -180,16 +178,6 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
-        // Register sessionKey→A2A sessionId mapping for subagent hook translation.
-        // Hooks receive openclaw sessionKey (e.g. "agent:main:direct:xxx") but
-        // xy_channel operates on A2A sessionId. This bridge lets subagent_spawned/
-        // subagent_ended hooks find the correct wait state.
-        // IMPORTANT: Only register on the FIRST message. Steer messages have a
-        // different taskId — overwriting the mapping would break subagent wait
-        // state tracking for the original message's subagents.
-        if (!isUpdate) {
-            registerSessionKeyMapping(route.sessionKey, parsed.sessionId, parsed.taskId, parsed.messageId);
-        }
         // Check for ACP runtime binding on this A2A conversation
         const runtimeRoute = resolveRuntimeConversationBindingRoute({
             route,
@@ -254,18 +242,20 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新
-            log.log(`[BOT] Sending initial status update`);
-            void sendStatusUpdate({
-                config,
-                sessionId: parsed.sessionId,
-                taskId: parsed.taskId,
-                messageId: parsed.messageId,
-                text: "任务正在处理中，请稍候~",
-                state: "working",
-            }).catch((err) => {
-                log.error(`Failed to send initial status update:`, err);
-            });
+            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
+            if (!isUpdate) {
+                log.log(`[BOT] Sending initial status update`);
+                void sendStatusUpdate({
+                    config,
+                    sessionId: parsed.sessionId,
+                    taskId: parsed.taskId,
+                    messageId: parsed.messageId,
+                    text: "任务正在处理中，请稍候~",
+                    state: "working",
+                }).catch((err) => {
+                    log.error(`Failed to send initial status update:`, err);
+                });
+            }
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -291,8 +281,10 @@ export async function handleXYMessage(params) {
             }
         }
         // ── Build message and dispatch via auto-reply pipeline ──────────
-        // 首条消息和 steer 回退都走此统一 dispatch 路径。
-        // File download — for both first message and steer fallthrough
+        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
+        // detects active runs and handles steer injection natively — the channel
+        // does not need its own steer detection or polling logic.
+        // File download
         let mediaPayload = {};
         if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
@@ -322,10 +314,8 @@ export async function handleXYMessage(params) {
                 });
                 if (queued) {
                     log.log(`[BOT-STEER] Direct steer succeeded — message injected into active run`);
-                    // Steer message taskId stays in the binding so getActiveTaskId()
-                    // resolves to the latest taskId for onPartialReply replies.
-                    // Cleanup happens via the original dispatcher's onIdleComplete →
-                    // decrementTaskIdRef(sessionId) which removes the entire binding.
+                    // Steer message taskId refCount is no longer needed since we skip the dispatcher.
+                    decrementTaskIdRef(parsed.sessionId);
                     return;
                 }
                 log.log(`[BOT-STEER] Direct steer failed (queued=false), falling through to dispatchReplyFromConfig`);
@@ -337,8 +327,10 @@ export async function handleXYMessage(params) {
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
+        let messageBody = textForAgent;
+        // Add speaker prefix for clarity
         const speaker = parsed.sessionId;
-        const messageBody = `${speaker}: ${textForAgent}`;
+        messageBody = `${speaker}: ${messageBody}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
             channel: "xiaoyi-channel",
@@ -397,15 +389,6 @@ export async function handleXYMessage(params) {
             cleaned = true;
             log.log(`[BOT] Cleanup started, steered=${steerState.steered}, skipReg=${skipReg}`);
             if (!skipReg) {
-                // Check for pending subagent wait on this session
-                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId) ??
-                    (hasWaitState(parsed.sessionId) ? { deliveredCompletions: 0, expectedCompletions: 1 } : null);
-                if (pendingWait && pendingWait.deliveredCompletions < pendingWait.expectedCompletions) {
-                    // Subagent wait active — skip cleanup, session stays alive
-                    log.log(`[BOT] Cleanup suppressed — subagent wait active on session, taskId=${parsed.taskId}`);
-                    cleaned = false;
-                    return;
-                }
                 decrementTaskIdRef(parsed.sessionId);
             }
             else {
@@ -447,34 +430,13 @@ export async function handleXYMessage(params) {
         log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
-            onSettled: async () => {
+            onSettled: () => {
                 log.log(`[BOT] onSettled, steered=${steerState.steered}`);
                 // 🔑 When steered, skip cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
                     log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
                     return;
                 }
-                // Subagent wait state: if parent has pending subagents, mark settled
-                // and defer finalization. Cleanup is suppressed so the session stays alive.
-                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId);
-                if (pendingWait && !pendingWait.parentSettled) {
-                    const transition = markParentSettled(parsed.sessionId, parsed.taskId);
-                    if (transition?.shouldFinalize) {
-                        // All completions arrived before parent settled → finalize now
-                        const { deliverSubagentFinalResult } = await import("./outbound.js");
-                        await deliverSubagentFinalResult({
-                            config,
-                            state: transition.state,
-                            reason: "all-subagent-results-delivered-before-parent-settled",
-                        });
-                        log.log(`[BOT] Subagent wait complete on parent settled; final response delivered`);
-                    }
-                    else {
-                        log.log(`[BOT] Subagent wait active, preserving session context for completion`);
-                    }
-                    dispatcherUpdaters.delete(parsed.sessionId);
-                    return;
-                }
                 // cleanup 已由 onIdleComplete 在 onIdle 的 finally 中执行。
                 // onSettled 不做任何清理（直接在这里清理会发生 race condition）。
                 dispatcherUpdaters.delete(parsed.sessionId);
@@ -488,7 +450,7 @@ export async function handleXYMessage(params) {
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
                     const isSteerDispatch = isUpdate && !skipReg;
                     log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}, isSteer=${isSteerDispatch}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -496,7 +458,13 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
+                        // 区分 steer 成功（undefined）和 steer 失败/正常 run（有结果）
+                        if (result === undefined) {
+                            log.log(`[BOT-STEER] dispatchReplyFromConfig returned undefined — steer injected via fast path OK, sessionKey=${route.sessionKey}`);
+                        }
+                        else {
+                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, resultType=${typeof result}, isSteer=${isSteerDispatch}, steered=${steerState.steered}`);
+                        }
                         return result;
                     }
                     catch (dispatchErr) {
@@ -547,21 +515,19 @@ export async function handleXYMessage(params) {
 function buildXYMediaPayload(mediaList) {
     const first = mediaList[0];
     const mediaPaths = mediaList.map((media) => media.path);
-    const mediaUrls = mediaList.map((media) => media.uri);
     const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
     return {
         MediaPath: first?.path,
         MediaType: first?.mimeType,
-        MediaUrl: first?.uri,
         MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
-        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
 // ─────────────────────────────────────────────────────────────
 // Dispatcher updaters (cross-chain taskId bridging)
 // ─────────────────────────────────────────────────────────────
-// Use globalThis to survive module deduplication
+// 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.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();

package/dist/src/channel.js

@@ -1,6 +1,6 @@
 import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./config.js";
 import { xyConfigSchema } from "./config-schema.js";
-import { xyOutbound } from "./outbound.js";
+import { xyOutbound } from "./dispatch/outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -158,7 +158,7 @@ export const xyPlugin = {
     },
     gateway: {
         async startAccount(context) {
-            const { monitorXYProvider } = await import("./monitor.js");
+            const { monitorXYProvider } = await import("./dispatch/monitor.js");
             const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({

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

@@ -0,0 +1,87 @@
+import { ConversationSession, SubagentWaitState, SubagentWaitTransition, TaskEntry } from "./conversation-session.js";
+export declare function getOrCreateSession(sessionId: string): ConversationSession;
+export declare function getSession(sessionId: string): ConversationSession | null;
+export declare function deleteSession(sessionId: string): void;
+export declare function listSessions(): ConversationSession[];
+/** 会话状态迁移（working / waiting-subagent / completing / 终态）。 */
+export declare function setSessionState(sessionId: string, state: ConversationSession["state"]): void;
+/**
+ * 注册或更新 session 的活跃 taskId。
+ * Returns true if this was an update (session already had an active task).
+ */
+export declare function registerTask(sessionId: string, taskId: string, messageId: string): boolean;
+/**
+ * 移除 session 的活跃 taskId（消息处理完成时调用）。
+ * @param expectedTaskId 可选：精确移除指定的 taskId，而非清空整个任务链。
+ */
+export declare function completeTask(sessionId: string, expectedTaskId?: string): void;
+/** 获取 session 当前活跃 task（任务链末尾）。 */
+export declare function getCurrentTask(sessionId: string): TaskEntry | null;
+/** 获取 session 当前活跃 taskId（reply-dispatcher 跨链读取 / 工具富化用）。 */
+export declare function getCurrentTaskId(sessionId: string): string | null;
+/** 获取 session 当前活跃 messageId。 */
+export declare function getCurrentMessageId(sessionId: string): string | null;
+export declare function hasActiveTask(sessionId: string): boolean;
+/** 所有活跃 task 绑定（gateway_stop 通知等场景）。 */
+export declare function listActiveTaskBindings(): Array<{
+    sessionId: string;
+    currentTaskId: string;
+    currentMessageId: string;
+    updatedAt: number;
+}>;
+/**
+ * 绑定 openclaw sessionKey 到首条消息的 A2A 身份。
+ * 仅在首条消息时调用（steer 消息不覆盖，保持 subagent 等待态跟踪稳定）。
+ */
+export declare function bindSessionKey(sessionKey: string, sessionId: string, taskId: string, messageId: string): void;
+export declare function resolveBySessionKey(sessionKey: string): {
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+} | null;
+export declare function unbindSessionKey(sessionKey: string): void;
+/**
+ * 全局缓存 resolved XY config，供 hook 上下文（无 raw ClawdbotConfig）使用。
+ */
+export declare function cacheXYConfig(config: unknown): void;
+export declare function getCachedXYConfig(): unknown;
+/**
+ * 启动（或重启）session 的 30s 状态心跳。
+ * 心跳由 manager 拥有：dispatcher 销毁不影响心跳；
+ * tick 时读取任务链末尾的当前 taskId/messageId。
+ */
+export declare function startStatusHeartbeat(sessionId: string, text?: string): void;
+export declare function stopStatusHeartbeat(sessionId: string): void;
+/**
+ * subagent_spawned hook 调用。递增 expected completion 计数。
+ * 若等待态尚不存在则创建（sessions_spawn 可能先于 sessions_yield）。
+ */
+export declare function markSubagentSpawned(sessionKey: string): number;
+/**
+ * subagent_ended hook 调用。标记一个 subagent run 结束并计为一次交付。
+ * 这是主要的完成跟踪机制（subagent 完成可能不经 xyOutbound.sendText）。
+ */
+export declare function markSubagentEnded(sessionKey: string): SubagentWaitTransition | null;
+/**
+ * bot.ts onSettled 调用。标记父 dispatcher 已 settle。
+ */
+export declare function markParentSettled(sessionId: string, taskId: string): SubagentWaitTransition | null;
+/**
+ * 存储从 xyOutbound.sendText 捕获的完成文本。不递增交付计数。
+ */
+export declare function addCompletionText(sessionId: string, taskId: string, text: string): void;
+export declare function getWaitState(sessionId: string, taskId?: string): SubagentWaitState | null;
+export declare function hasWaitState(sessionId: string, taskId?: string): boolean;
+export declare function clearWaitState(sessionId: string, reason: string, taskId?: string): SubagentWaitState | null;
+/**
+ * 当所有 subagent 完成且父 turn 已 settle 时，由 manager 发送唯一的
+ * final 帧并真正结束当前 A2A session：
+ *   1. 合并 completionTexts 发送 final:true 帧
+ *   2. 清理等待态、停止心跳、移除任务链
+ *   3. 会话状态迁移到 completed
+ */
+export declare function deliverSubagentFinalResult(params: {
+    state: SubagentWaitState;
+    reason?: string;
+    text?: string;
+}): Promise<void>;