@ynhcj/xiaoyi-channel 0.0.204-beta → 0.0.206-beta

package/dist/src/provider.js

@@ -128,6 +128,7 @@ function createRetryingStream(createStream, cronJob) {
             let hasContent = false;
             const buffer = [];
             let errorResult = null;
+            const fullResponseEvents = [];
             for await (const event of stream) {
                 const isContent = CONTENT_EVENT_TYPES.has(event.type);
                 if (!hasContent && !isContent) {
@@ -150,9 +151,14 @@ function createRetryingStream(createStream, cronJob) {
                     if (!hasContent) {
                         logger.log("[xiaoyiprovider] first content event received, switching to streaming mode");
                         hasContent = true;
-                        for (const b of buffer)
+                        for (const b of buffer) {
+                            if (CONTENT_EVENT_TYPES.has(b.type))
+                                fullResponseEvents.push(b);
                             yield b;
+                        }
                     }
+                    if (isContent)
+                        fullResponseEvents.push(event);
                     // IMPORTANT: resolve result() BEFORE yielding terminal events to avoid deadlock.
                     // The SDK calls result() when it sees done/error — if we yield first, the generator
                     // suspends and can never reach resolve, causing a permanent deadlock.

package/dist/src/reply-dispatcher.js

@@ -424,9 +424,20 @@ export function createXYReplyDispatcher(params) {
                         // 模型可能返回完整文本（非纯增量），如果新文本以已累积内容开头，
                         // 则只取新增的后缀部分，避免 append 模式下重复拼接。
                         let sendText = text;
-                        if (accumulatedText.length > 0 && text.startsWith(accumulatedText)) {
+                        const dedupApplied = accumulatedText.length > 0 && text.startsWith(accumulatedText);
+                        if (dedupApplied) {
                             sendText = text.slice(accumulatedText.length);
                         }
+                        else {
+                            // 新文本不以已累积内容为前缀（如工具调用后模型重新开始生成），
+                            // 更新 accumulatedText 为当前文本，后续基于此新前缀做去重
+                            const wasFirstRound = accumulatedText.length === 0;
+                            accumulatedText = "";
+                            // 新一轮输出前加换行分隔（第一轮除外）
+                            if (sendText.length > 0 && !wasFirstRound) {
+                                sendText = "\n" + sendText;
+                            }
+                        }
                         accumulatedText += sendText;
                         hasSentResponse = true;
                         if (sendText.length > 0) {

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

@@ -0,0 +1,66 @@
+export interface SubagentWaitState {
+    sessionId: string;
+    sessionKey: string;
+    taskId: string;
+    messageId: string;
+    artifactId: string;
+    startedAt: number;
+    expectedCompletions: number;
+    deliveredCompletions: number;
+    completionTexts: string[];
+    parentSettled: boolean;
+    finalizationClaimed: boolean;
+    stopHeartbeat?: () => void;
+}
+export interface SubagentWaitTransition {
+    state: SubagentWaitState;
+    isComplete: boolean;
+    shouldFinalize: boolean;
+}
+/**
+ * Register a mapping from openclaw sessionKey to A2A sessionId/taskId.
+ * Called in bot.ts when a new message dispatch begins.
+ */
+export declare function registerSessionKeyMapping(sessionKey: string, sessionId: string, taskId: string, messageId: string): void;
+/**
+ * Look up the A2A sessionId for a given openclaw sessionKey.
+ * Used in hooks (index.ts) to translate requesterSessionKey to A2A sessionId.
+ */
+export declare function resolveSessionIdFromSessionKey(sessionKey: string): {
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+} | null;
+/**
+ * Remove a sessionKey→sessionId mapping (cleanup when wait state resolved).
+ */
+export declare function unregisterSessionKeyMapping(sessionKey: string): void;
+/**
+ * Called from subagent_spawned hook. Increments expected completion count.
+ * If no wait state exists yet, creates one (sessions_spawn may happen before sessions_yield).
+ */
+export declare function markSubagentSpawned(sessionKey: string): number;
+/**
+ * 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): 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;
+export declare function clearWaitState(sessionId: string, reason: string, taskId?: string): SubagentWaitState | null;

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

@@ -0,0 +1,226 @@
+// Subagent wait state manager.
+//
+// Tracks sessions that are waiting for subagent completions after sessions_yield.
+// Subagent spawn/end is detected via subagent_spawned / subagent_ended hooks (index.ts).
+// Completion delivery is intercepted in xyOutbound.sendText (outbound.ts).
+//
+// Isolation: xyOutbound.sendText also serves cron pushes and normal message-tool calls.
+// Guards ensure these paths never collide with subagent result interception:
+//   1. ALS context guard — subagent completions arrive with ALS null
+//   2. Wait state match — only sessions that have yielded have a wait state
+//   3. TaskId match — subagent delivery's "to" is a bare sessionId, enhanced via wait state
+//
+// TTL: wait states expire after WAIT_TTL_MS (30 min) to avoid stale leaks.
+// Only one finalization path wins via finalizationClaimed flag.
+import { randomUUID } from "crypto";
+import { logger } from "./utils/logger.js";
+// ─── Global state ──────────────────────────────────────────────
+const WAIT_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const _g = globalThis;
+if (!_g.__xySubagentWaitStates) {
+    _g.__xySubagentWaitStates = new Map();
+}
+if (!_g.__xySessionKeyToSessionId) {
+    _g.__xySessionKeyToSessionId = new Map();
+}
+const waitStates = _g.__xySubagentWaitStates;
+const sessionKeyMap = _g.__xySessionKeyToSessionId;
+// ─── Helpers ───────────────────────────────────────────────────
+function waitKey(sessionId, taskId) {
+    return `${sessionId}::${taskId}`;
+}
+function isExpired(state) {
+    return Date.now() - state.startedAt > WAIT_TTL_MS;
+}
+function isComplete(state) {
+    return state.deliveredCompletions >= Math.max(1, state.expectedCompletions);
+}
+function claimFinalizationIfReady(state) {
+    if (state.finalizationClaimed)
+        return false;
+    if (!state.parentSettled || !isComplete(state))
+        return false;
+    state.finalizationClaimed = true;
+    return true;
+}
+// ─── SessionKey ↔ SessionId mapping ────────────────────────────
+/**
+ * Register a mapping from openclaw sessionKey to A2A sessionId/taskId.
+ * Called in bot.ts when a new message dispatch begins.
+ */
+export function registerSessionKeyMapping(sessionKey, sessionId, taskId, messageId) {
+    if (!sessionKey || !sessionId)
+        return;
+    sessionKeyMap.set(sessionKey, { sessionId, taskId, messageId });
+}
+/**
+ * Look up the A2A sessionId for a given openclaw sessionKey.
+ * Used in hooks (index.ts) to translate requesterSessionKey to A2A sessionId.
+ */
+export function resolveSessionIdFromSessionKey(sessionKey) {
+    return sessionKeyMap.get(sessionKey) ?? null;
+}
+/**
+ * Remove a sessionKey→sessionId mapping (cleanup when wait state resolved).
+ */
+export function unregisterSessionKeyMapping(sessionKey) {
+    sessionKeyMap.delete(sessionKey);
+}
+// ─── Wait state management ─────────────────────────────────────
+function getStatesArray(sessionId) {
+    const raw = waitStates.get(sessionId);
+    if (!raw)
+        return [];
+    const active = raw.filter((s) => {
+        if (!isExpired(s))
+            return true;
+        s.stopHeartbeat?.();
+        logger.withContext(sessionId, s.taskId).log(`[SUBAGENT-WAIT] Expired wait state cleared, expected=${s.expectedCompletions}, delivered=${s.deliveredCompletions}`);
+        return false;
+    });
+    if (active.length > 0) {
+        waitStates.set(sessionId, active);
+    }
+    else {
+        waitStates.delete(sessionId);
+    }
+    return active;
+}
+/**
+ * Called from subagent_spawned hook. Increments expected completion count.
+ * If no wait state exists yet, creates one (sessions_spawn may happen before sessions_yield).
+ */
+export function markSubagentSpawned(sessionKey) {
+    const mapped = resolveSessionIdFromSessionKey(sessionKey);
+    if (!mapped) {
+        logger.log(`[SUBAGENT-WAIT] No session mapping for sessionKey=${sessionKey.slice(0, 30)}`);
+        return 0;
+    }
+    const { sessionId, taskId, messageId } = mapped;
+    const states = getStatesArray(sessionId);
+    let state = states.find((s) => s.taskId === taskId);
+    if (!state) {
+        state = {
+            sessionId,
+            sessionKey,
+            taskId,
+            messageId,
+            artifactId: randomUUID(),
+            startedAt: Date.now(),
+            expectedCompletions: 0,
+            deliveredCompletions: 0,
+            completionTexts: [],
+            parentSettled: false,
+            finalizationClaimed: false,
+        };
+        states.push(state);
+    }
+    state.expectedCompletions = Math.max(1, state.expectedCompletions + 1);
+    waitStates.set(sessionId, states);
+    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent spawned, expected=${state.expectedCompletions}`);
+    return state.expectedCompletions;
+}
+/**
+ * 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 null;
+    const { sessionId, taskId } = mapped;
+    const states = getStatesArray(sessionId);
+    const state = states.find((s) => s.taskId === taskId);
+    if (!state) {
+        logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent ended but no wait state found`);
+        return null;
+    }
+    state.deliveredCompletions += 1;
+    const complete = isComplete(state);
+    const shouldFinalize = claimFinalizationIfReady(state);
+    waitStates.set(sessionId, states);
+    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Subagent ended, delivered=${state.deliveredCompletions}/${state.expectedCompletions}, complete=${complete}, shouldFinalize=${shouldFinalize}`);
+    return { state, isComplete: complete, shouldFinalize };
+}
+/**
+ * Called from bot.ts onSettled. Marks parent dispatcher as settled.
+ * Returns transition with shouldFinalize if all completions already arrived.
+ */
+export function markParentSettled(sessionId, taskId) {
+    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 parent settled`);
+        return null;
+    }
+    state.parentSettled = true;
+    const complete = isComplete(state);
+    const shouldFinalize = claimFinalizationIfReady(state);
+    waitStates.set(sessionId, states);
+    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);
+    if (!state) {
+        logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] No wait state matched for heartbeat attachment`);
+        return;
+    }
+    state.stopHeartbeat = stopHeartbeat;
+    waitStates.set(sessionId, states);
+    logger.withContext(sessionId, taskId).log(`[SUBAGENT-WAIT] Heartbeat attached`);
+}
+// ─── Query functions ───────────────────────────────────────────
+export function getWaitState(sessionId, taskId) {
+    const states = getStatesArray(sessionId);
+    if (states.length === 0)
+        return null;
+    if (taskId) {
+        return states.find((s) => s.taskId === taskId) ?? null;
+    }
+    // FIFO: return oldest wait state when taskId not specified
+    return states[0] ?? null;
+}
+export function hasWaitState(sessionId, taskId) {
+    return getWaitState(sessionId, taskId) !== null;
+}
+export function clearWaitState(sessionId, reason, taskId) {
+    const states = getStatesArray(sessionId);
+    if (states.length === 0)
+        return null;
+    const index = taskId
+        ? states.findIndex((s) => s.taskId === taskId)
+        : 0;
+    if (index < 0) {
+        logger.withContext(sessionId, taskId ?? "").log(`[SUBAGENT-WAIT] No wait state matched for clear, reason=${reason}`);
+        return null;
+    }
+    const [state] = states.splice(index, 1);
+    state.stopHeartbeat?.();
+    if (states.length > 0) {
+        waitStates.set(sessionId, states);
+    }
+    else {
+        waitStates.delete(sessionId);
+    }
+    logger.withContext(sessionId, state.taskId).log(`[SUBAGENT-WAIT] Cleared wait state, reason=${reason}, remaining=${states.length}`);
+    return state;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.204-beta",
+  "version": "0.0.206-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     }
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.6"
+    "openclaw": ">=2026.6.6"
   },
   "peerDependenciesMeta": {
     "openclaw": {