@ynhcj/xiaoyi-channel 0.0.189-next → 0.0.190-next

package/dist/index.js

@@ -181,14 +181,27 @@ function registerSubagentHooks(api) {
         }
     });
     // subagent_ended: fires when a subagent run terminates (complete/error/killed).
-    // We log the event for tracking; the actual completion count is decremented
-    // when the subagent result is delivered via xyOutbound.sendText.
+    // This is the PRIMARY delivery tracking mechanism. When all expected
+    // subagents have ended and parent has settled, we finalize the A2A session.
     api.on("subagent_ended", async (event, ctx) => {
         const requesterSessionKey = ctx?.requesterSessionKey;
         if (!requesterSessionKey)
             return;
-        markSubagentEnded(requesterSessionKey);
-        console.log(`[XY-SUBAGENT] ended, sessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, requester=${requesterSessionKey.slice(0, 30)}`);
+        const transition = markSubagentEnded(requesterSessionKey);
+        console.log(`[XY-SUBAGENT] ended, sessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, complete=${transition?.isComplete ?? false}, shouldFinalize=${transition?.shouldFinalize ?? false}`);
+        if (transition?.shouldFinalize) {
+            // All subagents ended and parent already settled — finalize A2A session
+            const { resolveXYConfig } = await import("./src/config.js");
+            const { deliverSubagentFinalResult } = await import("./src/outbound.js");
+            const { getXYRuntime } = await import("./src/runtime.js");
+            const config = resolveXYConfig(getXYRuntime().config);
+            await deliverSubagentFinalResult({
+                config,
+                state: transition.state,
+                reason: "all-subagents-ended-after-parent-settled",
+            });
+            console.log(`[XY-SUBAGENT] Finalized A2A session after all subagents ended`);
+        }
     });
 }
 function registerFullHooks(api) {

package/dist/src/outbound.js

@@ -6,7 +6,7 @@ import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
-import { getWaitState, markCompletionDelivered, clearWaitState, } from "./subagent-wait-state.js";
+import { getWaitState, addCompletionText, clearWaitState, } from "./subagent-wait-state.js";
 import { decrementTaskIdRef } from "./task-manager.js";
 import { sendA2AResponse, sendStatusUpdate } from "./formatter.js";
 import { savePushData } from "./utils/pushdata-manager.js";
@@ -139,67 +139,23 @@ export const xyOutbound = {
     sendText: async ({ cfg, to, text, accountId }) => {
         // Resolve configuration
         const config = resolveXYConfig(cfg);
-        // ── Subagent completion interception ─────────────────────────
-        // Detect subagent completions by checking if the resolved target
-        // matches a wait state's sessionId + taskId. This works regardless
-        // of ALS context because:
-        //   - Normal agent turns: ALS enhances target with CURRENT taskId,
-        //     which differs from wait state's taskId (no match → skip)
-        //   - Subagent completions: ALS is null, resolveTarget enhanced
-        //     from wait state's taskId (match → intercept)
-        //   - Cron: to=DEFAULT_PUSH_MARKER (no match)
-        //   - Message tool: ALS enhances with current taskId (no match
-        //     unless the agent happens to be on the same yielded task)
+        // ── Subagent completion text capture ─────────────────────────
+        // Subagent completions may arrive here when openclaw's announce
+        // flow delivers through the channel outbound. We capture the text
+        // for the final A2A response but do NOT track delivery count here.
+        // Delivery tracking is done by the subagent_ended hook (index.ts).
         if (to && to !== DEFAULT_PUSH_MARKER) {
             const [targetSessionId, targetTaskId] = String(to).split("::");
             const waitState = getWaitState(targetSessionId, targetTaskId);
             const alsCtx = getCurrentSessionContext();
-            // Only intercept when ALS is null OR the target taskId matches
-            // the wait state (not the current ALS taskId). This ensures
-            // we don't intercept normal agent turn deliveries.
             const isFromWaitState = waitState &&
                 (!alsCtx || alsCtx.taskId !== targetTaskId);
             if (isFromWaitState && !waitState.finalizationClaimed) {
                 const log = logger.withContext(waitState.sessionId, waitState.taskId);
-                log.log(`[xyOutbound.sendText] Subagent completion detected, als=${!!alsCtx}, delivered=${waitState.deliveredCompletions}/${waitState.expectedCompletions}`);
-                const delivered = markCompletionDelivered(targetSessionId, targetTaskId, text);
-                if (delivered) {
-                    const { state, isComplete, shouldFinalize } = delivered;
-                    if (shouldFinalize) {
-                        // All completions arrived and parent already settled → finalize
-                        log.log(`[xyOutbound.sendText] Finalizing subagent results`);
-                        await deliverSubagentFinalResult({ config, state, reason: "all-subagent-results-delivered-after-parent-settled", text: text });
-                        // Subagent completion delivered via A2A, skip push
-                        return {
-                            channel: "xiaoyi-channel",
-                            messageId: state.artifactId,
-                            chatId: to,
-                        };
-                    }
-                    if (isComplete) {
-                        // All completions arrived but parent hasn't settled yet → defer to onSettled
-                        log.log(`[xyOutbound.sendText] All subagent results arrived before parent settled, deferring finalization`);
-                    }
-                    else {
-                        // Still waiting for more completions → send progress via A2A, skip push
-                        log.log(`[xyOutbound.sendText] Subagent progress ${state.deliveredCompletions}/${state.expectedCompletions}`);
-                        try {
-                            await sendStatusUpdate({
-                                config,
-                                sessionId: state.sessionId,
-                                taskId: state.taskId,
-                                messageId: state.messageId,
-                                text: `已收到子任务结果 ${state.deliveredCompletions}/${state.expectedCompletions}，继续等待其他子任务~`,
-                                state: "working",
-                                useLatestTask: false,
-                            });
-                        }
-                        catch (err) {
-                            log.error(`[xyOutbound.sendText] Failed to send subagent progress status:`, err);
-                        }
-                    }
-                }
-                // Skip push delivery for subagent completions — only send via A2A
+                log.log(`[xyOutbound.sendText] Subagent completion text captured, len=${text?.length ?? 0}`);
+                // Store the text for later use in final response
+                addCompletionText(targetSessionId, targetTaskId, text);
+                // Skip push delivery — subagent completions go through A2A
                 return {
                     channel: "xiaoyi-channel",
                     messageId: waitState.artifactId,
@@ -207,7 +163,7 @@ export const xyOutbound = {
                 };
             }
         }
-        // ── End subagent interception ───────────────────────────────
+        // ── End subagent text capture ───────────────────────────────
         // Handle default push marker (for cron jobs without explicit target)
         let actualTo = to;
         if (to === DEFAULT_PUSH_MARKER) {

package/dist/src/subagent-wait-state.d.ts

@@ -41,20 +41,25 @@ export declare function unregisterSessionKeyMapping(sessionKey: string): void;
  */
 export declare function markSubagentSpawned(sessionKey: string): number;
 /**
- * Called from subagent_ended hook. Marks a subagent run as ended.
- * Does NOT decrement expected count — that's done when completion is delivered via outbound.
+ * Called from subagent_ended hook. Marks a subagent run as ended AND
+ * counts it as a delivery. This is the primary completion tracking
+ * mechanism because subagent completions may not route through
+ * xyOutbound.sendText (they go through openclaw's internal gateway
+ * agent path with potentially deliver=false).
+ *
+ * Returns transition with shouldFinalize if all completions have ended.
  */
-export declare function markSubagentEnded(sessionKey: string): void;
-/**
- * Called from xyOutbound.sendText when a subagent completion is delivered.
- * Increments delivered count and returns transition state.
- */
-export declare function markCompletionDelivered(sessionId: string, taskId: string, text?: string): SubagentWaitTransition | null;
+export declare function markSubagentEnded(sessionKey: string): SubagentWaitTransition | null;
 /**
  * Called from bot.ts onSettled. Marks parent dispatcher as settled.
  * Returns transition with shouldFinalize if all completions already arrived.
  */
 export declare function markParentSettled(sessionId: string, taskId: string): SubagentWaitTransition | null;
+/**
+ * Store a completion text snippet captured from xyOutbound.sendText.
+ * Does NOT increment delivery count (that's done by markSubagentEnded).
+ */
+export declare function addCompletionText(sessionId: string, taskId: string, text: string): void;
 export declare function attachHeartbeat(sessionId: string, taskId: string, stopHeartbeat: () => void): void;
 export declare function getWaitState(sessionId: string, taskId?: string): SubagentWaitState | null;
 export declare function hasWaitState(sessionId: string, taskId?: string): boolean;

package/dist/src/subagent-wait-state.js

@@ -121,39 +121,30 @@ export function markSubagentSpawned(sessionKey) {
     return state.expectedCompletions;
 }
 /**
- * Called from subagent_ended hook. Marks a subagent run as ended.
- * Does NOT decrement expected count — that's done when completion is delivered via outbound.
+ * Called from subagent_ended hook. Marks a subagent run as ended AND
+ * counts it as a delivery. This is the primary completion tracking
+ * mechanism because subagent completions may not route through
+ * xyOutbound.sendText (they go through openclaw's internal gateway
+ * agent path with potentially deliver=false).
+ *
+ * Returns transition with shouldFinalize if all completions have ended.
  */
 export function markSubagentEnded(sessionKey) {
     const mapped = resolveSessionIdFromSessionKey(sessionKey);
     if (!mapped)
-        return;
+        return null;
     const { sessionId, taskId } = mapped;
-    const states = getStatesArray(sessionId);
-    const state = states.find((s) => s.taskId === taskId);
-    if (!state)
-        return;
-    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent ended, delivered=${state.deliveredCompletions}/${state.expectedCompletions}`);
-}
-/**
- * Called from xyOutbound.sendText when a subagent completion is delivered.
- * Increments delivered count and returns transition state.
- */
-export function markCompletionDelivered(sessionId, taskId, text) {
     const states = getStatesArray(sessionId);
     const state = states.find((s) => s.taskId === taskId);
     if (!state) {
-        logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] No wait state matched for completion delivery`);
+        logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent ended but no wait state found`);
         return null;
     }
     state.deliveredCompletions += 1;
-    if (text?.trim()) {
-        state.completionTexts.push(text.trim());
-    }
     const complete = isComplete(state);
     const shouldFinalize = claimFinalizationIfReady(state);
     waitStates.set(sessionId, states);
-    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Completion delivered=${state.deliveredCompletions}/${state.expectedCompletions}, complete=${complete}, shouldFinalize=${shouldFinalize}`);
+    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent ended, delivered=${state.deliveredCompletions}/${state.expectedCompletions}, complete=${complete}, shouldFinalize=${shouldFinalize}`);
     return { state, isComplete: complete, shouldFinalize };
 }
 /**
@@ -174,6 +165,18 @@ export function markParentSettled(sessionId, taskId) {
     logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Parent settled, completions=${state.deliveredCompletions}/${state.expectedCompletions}, shouldFinalize=${shouldFinalize}`);
     return { state, isComplete: complete, shouldFinalize };
 }
+/**
+ * Store a completion text snippet captured from xyOutbound.sendText.
+ * Does NOT increment delivery count (that's done by markSubagentEnded).
+ */
+export function addCompletionText(sessionId, taskId, text) {
+    const states = getStatesArray(sessionId);
+    const state = states.find((s) => s.taskId === taskId);
+    if (!state || !text.trim())
+        return;
+    state.completionTexts.push(text.trim());
+    waitStates.set(sessionId, states);
+}
 export function attachHeartbeat(sessionId, taskId, stopHeartbeat) {
     const states = getStatesArray(sessionId);
     const state = states.find((s) => s.taskId === taskId);

package/package.json

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