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

package/dist/src/bot.js

@@ -1,11 +1,14 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractTriggerData } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
-import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
-import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
+import { registerSession, unregisterSession, runWithSessionContext } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
+import { addPushId } from "./utils/pushid-manager.js";
+import { getPushDataById } from "./utils/pushdata-manager.js";
+import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -56,6 +59,60 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // ========== 检测 Trigger 消息 ==========
+        // 如果消息中包含 Trigger 事件数据，直接返回 pushData 内容，不走正常流程
+        const triggerData = extractTriggerData(parsed.parts);
+        if (triggerData) {
+            log(`[BOT] 📌 Detected Trigger message with pushDataId: ${triggerData.pushDataId}`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Task ID: ${parsed.taskId}`);
+            try {
+                // 读取 pushData
+                const pushDataItem = await getPushDataById(triggerData.pushDataId);
+                if (!pushDataItem) {
+                    error(`[BOT] ❌ pushData not found for ID: ${triggerData.pushDataId}`);
+                    return;
+                }
+                log(`[BOT] ✅ Found pushData, sending direct response`);
+                log(`[BOT]   - pushDataId: ${pushDataItem.pushDataId}`);
+                log(`[BOT]   - time: ${pushDataItem.time}`);
+                log(`[BOT]   - content length: ${pushDataItem.dataDetail.length} chars`);
+                const config = resolveXYConfig(cfg);
+                // 直接发送响应（final=true，不走 openclaw 流程）
+                await sendA2AResponse({
+                    config,
+                    sessionId: parsed.sessionId,
+                    taskId: parsed.taskId,
+                    messageId: parsed.messageId,
+                    text: pushDataItem.dataDetail,
+                    append: false,
+                    final: true,
+                });
+                log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
+                return; // 提前返回，不继续处理
+            }
+            catch (err) {
+                error(`[BOT] ❌ Failed to handle Trigger message:`, err);
+                return;
+            }
+        }
+        // ========================================
+        // 🔑 检测steer模式和是否是第二条消息
+        const isSteerMode = cfg.messages?.queue?.mode === "steer";
+        const isSecondMessage = isSteerMode && hasActiveTask(parsed.sessionId);
+        if (isSecondMessage) {
+            log(`[BOT] 🔄 STEER MODE - Second message detected (will be follower)`);
+            log(`[BOT]   - Session: ${parsed.sessionId}`);
+            log(`[BOT]   - New taskId: ${parsed.taskId} (will replace current)`);
+        }
+        // 🔑 注册taskId（第二条消息会覆盖第一条的taskId）
+        const { isUpdate, refCount } = registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId, { incrementRef: true } // 增加引用计数
+        );
+        // 🔑 如果是第一条消息，锁定taskId防止被过早清理
+        if (!isUpdate) {
+            lockTaskId(parsed.sessionId);
+            log(`[BOT] 🔒 Locked taskId for first message`);
+        }
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
@@ -64,6 +121,10 @@ export async function handleXYMessage(params) {
             log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
             log(`[BOT]   - Full push_id: ${pushId}`);
             configManager.updatePushId(parsed.sessionId, pushId);
+            // 持久化 pushId 到本地文件（异步，不阻塞主流程）
+            addPushId(pushId).catch((err) => {
+                error(`[BOT] Failed to persist pushId:`, err);
+            });
         }
         else {
             log(`[BOT] ℹ️  No push_id found in message, will use config default`);
@@ -83,11 +144,12 @@ export async function handleXYMessage(params) {
             },
         });
         log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
-        // Register session context for tools
+        // 🔑 注册session（带引用计数）
         log(`[BOT] 📝 About to register session for tools...`);
         log(`[BOT]   - sessionKey: ${route.sessionKey}`);
         log(`[BOT]   - sessionId: ${parsed.sessionId}`);
         log(`[BOT]   - taskId: ${parsed.taskId}`);
+        log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
         registerSession(route.sessionKey, {
             config,
             sessionId: parsed.sessionId,
@@ -96,14 +158,14 @@ export async function handleXYMessage(params) {
             agentId: route.accountId,
         });
         log(`[BOT] ✅ Session registered for tools`);
-        // Send initial status update immediately after parsing message
+        // 🔑 发送初始状态更新（第二条消息也要发，用新taskId）
         log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
         void sendStatusUpdate({
             config,
             sessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            text: "任务正在处理中，请稍后~",
+            text: isSecondMessage ? "新消息已接收，正在处理..." : "任务正在处理中，请稍后~",
             state: "working",
         }).catch((err) => {
             error(`Failed to send initial status update:`, err);
@@ -111,10 +173,11 @@ export async function handleXYMessage(params) {
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         const fileParts = extractFileParts(parsed.parts);
-        // Download files if present (using core's media download)
-        const mediaList = await downloadFilesFromParts(fileParts);
-        // Build media payload for inbound context (following feishu pattern)
-        const mediaPayload = buildXYMediaPayload(mediaList);
+        // Download files to local disk
+        // MediaPath will be local path (faster for openclaw to read)
+        // MediaUrl will be remote URL (fallback if needed)
+        const downloadedFiles = await downloadFilesFromParts(fileParts);
+        const mediaPayload = buildXYMediaPayload(fileParts, downloadedFiles);
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
@@ -155,51 +218,66 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // Send initial status update immediately after parsing message
-        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
-        void sendStatusUpdate({
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            text: "任务正在处理中，请稍后~",
-            state: "working",
-        }).catch((err) => {
-            error(`Failed to send initial status update:`, err);
-        });
-        // Create reply dispatcher (following feishu pattern)
-        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
+        // 🔑 创建dispatcher（dispatcher会自动使用动态taskId）
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
+        log(`[BOT-DISPATCHER]   - session: ${parsed.sessionId}`);
+        log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
+        log(`[BOT-DISPATCHER]   - isSecondMessage: ${isSecondMessage}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
             sessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            accountId: route.accountId, // ✅ Use route.accountId
+            accountId: route.accountId,
+            isSteerFollower: isSecondMessage, // 🔑 标记第二条消息
         });
         log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
-        // Start status update interval (will send updates every 60 seconds)
-        // Interval will be automatically stopped when onIdle/onCleanup is triggered
-        startStatusInterval();
+        // 🔑 只有第一条消息启动状态定时器
+        // 第二条消息会很快返回，不需要定时器
+        if (!isSecondMessage) {
+            startStatusInterval();
+            log(`[BOT-DISPATCHER] ✅ Status interval started for first message`);
+        }
+        else {
+            log(`[BOT-DISPATCHER] ⏭️  Skipped status interval for steer follower`);
+        }
         log(`xy: dispatching to agent (session=${parsed.sessionId})`);
         // Dispatch to OpenClaw core using correct API (following feishu pattern)
         log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
+        // Build session context for AsyncLocalStorage
+        const sessionContext = {
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            agentId: route.accountId,
+        };
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
                 log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                log(`[BOT]   - About to unregister session...`);
+                log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
                 markDispatchIdle();
-                // Unregister session context when done
+                // 🔑 减少引用计数
+                decrementTaskIdRef(parsed.sessionId);
+                // 🔑 如果是第一条消息完成，解锁
+                if (!isSecondMessage) {
+                    unlockTaskId(parsed.sessionId);
+                    log(`[BOT] 🔓 Unlocked taskId (first message completed)`);
+                }
+                // 减少session引用计数
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Session unregistered in onSettled`);
+                log(`[BOT] ✅ Cleanup completed`);
             },
-            run: () => core.channel.reply.dispatchReplyFromConfig({
+            run: () => 
+            // 🔐 Use AsyncLocalStorage to provide session context to tools
+            runWithSessionContext(sessionContext, () => core.channel.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
                 cfg,
                 dispatcher,
                 replyOptions,
-            }),
+            })),
         });
         log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);
@@ -209,25 +287,28 @@ export async function handleXYMessage(params) {
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
         log(`[BOT] ❌ Error occurred, attempting cleanup...`);
-        // Try to unregister session on error (if route was established)
+        // 🔑 错误时也要清理taskId和session
         try {
-            const core = getXYRuntime();
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
-                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
+                log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
+                // 清理 taskId
+                decrementTaskIdRef(sessionId);
+                unlockTaskId(sessionId);
+                // 清理 session
+                const core = getXYRuntime();
                 const route = core.channel.routing.resolveAgentRoute({
                     cfg,
                     channel: "xiaoyi-channel",
                     accountId,
                     peer: {
                         kind: "direct",
-                        id: sessionId, // ✅ Use sessionId for cleanup consistency
+                        id: sessionId,
                     },
                 });
-                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Session unregistered after error`);
+                log(`[BOT] ✅ Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {
@@ -240,17 +321,42 @@ export async function handleXYMessage(params) {
 /**
  * Build media payload for inbound context.
  * Following feishu pattern: buildFeishuMediaPayload().
+ *
+ * @param fileParts - Original file parts with remote URLs
+ * @param downloadedFiles - Downloaded files with local paths (optional)
+ *
+ * If downloadedFiles provided:
+ *   MediaPath will be local path (faster for openclaw to read)
+ *   MediaUrl will be remote URL (fallback if local read fails)
+ *
+ * If not provided:
+ *   Both will be remote URL (openclaw will download)
  */
-function buildXYMediaPayload(mediaList) {
-    const first = mediaList[0];
-    const mediaPaths = mediaList.map((media) => media.path);
-    const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
+function buildXYMediaPayload(fileParts, downloadedFiles) {
+    const first = fileParts[0];
+    const uris = fileParts.map((file) => file.uri);
+    const mediaTypes = fileParts.map((file) => file.mimeType).filter(Boolean);
+    // If files were downloaded locally, use local paths for MediaPath
+    // and remote URLs for MediaUrl (best of both worlds)
+    if (downloadedFiles && downloadedFiles.length > 0) {
+        const localPaths = downloadedFiles.map((f) => f.path);
+        const firstLocal = downloadedFiles[0];
+        return {
+            MediaPath: firstLocal?.path, // ⭐ Local path (/tmp/xy_channel/...)
+            MediaType: first?.mimeType,
+            MediaUrl: firstLocal?.uri, // ⭐ Remote URL (https://cdn...)
+            MediaPaths: localPaths.length > 0 ? localPaths : undefined,
+            MediaUrls: uris.length > 0 ? uris : undefined,
+            MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+        };
+    }
+    // Fallback: use remote URLs for both (original behavior)
     return {
-        MediaPath: first?.path,
+        MediaPath: first?.uri,
         MediaType: first?.mimeType,
-        MediaUrl: first?.path,
-        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
-        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrl: first?.uri,
+        MediaPaths: uris.length > 0 ? uris : undefined,
+        MediaUrls: uris.length > 0 ? uris : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }

package/dist/src/channel.js

@@ -9,7 +9,21 @@ import { modifyNoteTool } from "./tools/modify-note-tool.js";
 import { calendarTool } from "./tools/calendar-tool.js";
 import { searchCalendarTool } from "./tools/search-calendar-tool.js";
 import { searchContactTool } from "./tools/search-contact-tool.js";
-import { searchPhotoTool } from "./tools/search-photo-tool.js";
+import { searchPhotoGalleryTool } from "./tools/search-photo-gallery-tool.js";
+import { uploadPhotoTool } from "./tools/upload-photo-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { callPhoneTool } from "./tools/call-phone-tool.js";
+import { searchMessageTool } from "./tools/search-message-tool.js";
+import { sendMessageTool } from "./tools/send-message-tool.js";
+import { searchFileTool } from "./tools/search-file-tool.js";
+import { uploadFileTool } from "./tools/upload-file-tool.js";
+import { createAlarmTool } from "./tools/create-alarm-tool.js";
+import { searchAlarmTool } from "./tools/search-alarm-tool.js";
+import { modifyAlarmTool } from "./tools/modify-alarm-tool.js";
+import { deleteAlarmTool } from "./tools/delete-alarm-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { xiaoyiCollectionTool } from "./tools/xiaoyi-collection-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -49,7 +63,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, sendMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, xiaoyiCollectionTool, viewPushResultTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();
@@ -76,10 +90,9 @@ export const xyPlugin = {
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
-                wsUrl1: account.wsUrl1,
-                wsUrl2: account.wsUrl2,
+                wsUrl: account.wsUrl,
             });
-            context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl1: ${account.wsUrl1}, wsUrl2: ${account.wsUrl2})`);
+            context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.js

@@ -89,29 +89,16 @@ export function diagnoseAllManagers() {
         console.log(`📌 Manager: ${key}`);
         console.log(`   Shutting down: ${diag.isShuttingDown}`);
         console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
-        // Server 1
-        console.log(`   🔌 Server1:`);
-        console.log(`      - Exists: ${diag.server1.exists}`);
-        console.log(`      - ReadyState: ${diag.server1.readyState}`);
-        console.log(`      - State connected/ready: ${diag.server1.stateConnected}/${diag.server1.stateReady}`);
-        console.log(`      - Reconnect attempts: ${diag.server1.reconnectAttempts}`);
-        console.log(`      - Listeners on WebSocket: ${diag.server1.listenerCount}`);
-        console.log(`      - Heartbeat active: ${diag.server1.heartbeatActive}`);
-        console.log(`      - Has reconnect timer: ${diag.server1.hasReconnectTimer}`);
-        if (diag.server1.isOrphan) {
-            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
-            orphanCount++;
-        }
-        // Server 2
-        console.log(`   🔌 Server2:`);
-        console.log(`      - Exists: ${diag.server2.exists}`);
-        console.log(`      - ReadyState: ${diag.server2.readyState}`);
-        console.log(`      - State connected/ready: ${diag.server2.stateConnected}/${diag.server2.stateReady}`);
-        console.log(`      - Reconnect attempts: ${diag.server2.reconnectAttempts}`);
-        console.log(`      - Listeners on WebSocket: ${diag.server2.listenerCount}`);
-        console.log(`      - Heartbeat active: ${diag.server2.heartbeatActive}`);
-        console.log(`      - Has reconnect timer: ${diag.server2.hasReconnectTimer}`);
-        if (diag.server2.isOrphan) {
+        // Connection
+        console.log(`   🔌 Connection:`);
+        console.log(`      - Exists: ${diag.connection.exists}`);
+        console.log(`      - ReadyState: ${diag.connection.readyState}`);
+        console.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        if (diag.connection.isOrphan) {
             console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
             orphanCount++;
         }
@@ -134,7 +121,7 @@ export function cleanupOrphanConnections() {
     let cleanedCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        if (diag.server1.isOrphan || diag.server2.isOrphan) {
+        if (diag.connection.isOrphan) {
             console.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;

package/dist/src/config.js

@@ -17,8 +17,8 @@ export function resolveXYConfig(cfg) {
     // Return configuration with defaults
     return {
         enabled: xyConfig.enabled ?? false,
-        wsUrl1: xyConfig.wsUrl1 ?? "ws://localhost:8765/ws/link",
-        wsUrl2: xyConfig.wsUrl2 ?? "ws://localhost:8768/ws/link",
+        // ✅ 兼容旧配置：优先使用 wsUrl，然后 wsUrl2（wsUrl1 被忽略）
+        wsUrl: xyConfig.wsUrl ?? xyConfig.wsUrl2 ?? "ws://localhost:8768/ws/link",
         apiKey: xyConfig.apiKey,
         uid: xyConfig.uid,
         agentId: xyConfig.agentId,

package/dist/src/file-download.d.ts

@@ -4,7 +4,11 @@
 export declare function downloadFile(url: string, destPath: string): Promise<void>;
 /**
  * Download files from A2A file parts.
- * Returns array of local file paths.
+ * Returns array of local file paths with metadata.
+ *
+ * @param fileParts - Array of file info from A2A message
+ * @param tempDir - Temporary directory for downloaded files
+ * @returns Array of downloaded file info (includes local path, name, mime type, and original URI)
  */
 export declare function downloadFilesFromParts(fileParts: Array<{
     name: string;
@@ -14,4 +18,5 @@ export declare function downloadFilesFromParts(fileParts: Array<{
     path: string;
     name: string;
     mimeType: string;
+    uri: string;
 }>>;

package/dist/src/file-download.js

@@ -34,7 +34,11 @@ export async function downloadFile(url, destPath) {
 }
 /**
  * Download files from A2A file parts.
- * Returns array of local file paths.
+ * Returns array of local file paths with metadata.
+ *
+ * @param fileParts - Array of file info from A2A message
+ * @param tempDir - Temporary directory for downloaded files
+ * @returns Array of downloaded file info (includes local path, name, mime type, and original URI)
  */
 export async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_channel") {
     // Create temp directory if it doesn't exist
@@ -48,15 +52,20 @@ export async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_chann
         try {
             await downloadFile(uri, destPath);
             downloadedFiles.push({
-                path: destPath,
+                path: destPath, // ⭐ Local path
                 name,
                 mimeType,
+                uri, // ⭐ Original remote URL
             });
+            logger.log(`✅ Downloaded: ${name} -> ${destPath}`);
         }
         catch (error) {
-            logger.error(`Failed to download file ${name}:`, error);
+            logger.error(`❌ Failed to download file ${name}:`, error);
             // Continue with other files
         }
     }
+    if (downloadedFiles.length > 0) {
+        logger.log(`📦 Downloaded ${downloadedFiles.length}/${fileParts.length} files successfully`);
+    }
     return downloadedFiles;
 }

package/dist/src/formatter.d.ts

@@ -92,3 +92,17 @@ export interface SendTasksCancelResponseParams {
  * Send a tasks/cancel response.
  */
 export declare function sendTasksCancelResponse(params: SendTasksCancelResponseParams): Promise<void>;
+/**
+ * Parameters for sending a Trigger response.
+ */
+export interface SendTriggerResponseParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    content: string;
+}
+/**
+ * Send a Trigger response with pushData content.
+ */
+export declare function sendTriggerResponse(params: SendTriggerResponseParams): Promise<void>;

package/dist/src/formatter.js

@@ -106,9 +106,7 @@ export async function sendReasoningTextUpdate(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    log(`[REASONING_TEXT] 📤 Sending reasoningText update: sessionId=${sessionId}, taskId=${taskId}, text.length=${text.length}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`[REASONING_TEXT] ✅ Sent successfully`);
 }
 /**
  * Send an A2A task status update.
@@ -293,3 +291,49 @@ export async function sendTasksCancelResponse(params) {
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
 }
+/**
+ * Send a Trigger response with pushData content.
+ */
+export async function sendTriggerResponse(params) {
+    const { config, sessionId, taskId, messageId, content } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for Trigger
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            taskId: taskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: true,
+            artifact: {
+                artifactId: uuidv4(),
+                parts: [
+                    {
+                        kind: "text",
+                        text: content,
+                    },
+                ],
+            },
+        },
+        error: {
+            code: 0,
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[TRIGGER_RESPONSE] Sending Trigger response: sessionId=${sessionId}, taskId=${taskId}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
+}

package/dist/src/monitor.js

@@ -1,6 +1,9 @@
 import { resolveXYConfig } from "./config.js";
 import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
+import { parseA2AMessage } from "./parser.js";
+import { hasActiveTask } from "./task-manager.js";
+import { handleTriggerEvent } from "./trigger-handler.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -94,11 +97,39 @@ export async function monitorXYProvider(opts = {}) {
                     log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
                 }
             };
-            void enqueue(sessionId, task).catch((err) => {
-                // Error already logged in task, this is for queue failures
-                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
-                activeMessages.delete(messageKey);
-            });
+            // 🔑 核心改造：检测steer模式
+            // 需要提前解析消息以获取sessionId
+            try {
+                const parsed = parseA2AMessage(message);
+                const steerMode = cfg.messages?.queue?.mode === "steer";
+                const hasActiveRun = hasActiveTask(parsed.sessionId);
+                if (steerMode && hasActiveRun) {
+                    // Steer模式且有活跃任务：不入队列，直接并发执行
+                    log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
+                    log(`[MONITOR-HANDLER]   - sessionId: ${parsed.sessionId}`);
+                    log(`[MONITOR-HANDLER]   - Bypassing queue to allow message insertion`);
+                    void task().catch((err) => {
+                        error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+                else {
+                    // 正常模式：入队列串行执行
+                    log(`[MONITOR-HANDLER] 📋 NORMAL MODE: Enqueuing for messageKey=${messageKey}`);
+                    void enqueue(sessionId, task).catch((err) => {
+                        error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+            }
+            catch (parseErr) {
+                // 解析失败，回退到正常队列模式
+                error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
+                void enqueue(sessionId, task).catch((err) => {
+                    error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                    activeMessages.delete(messageKey);
+                });
+            }
         };
         const connectedHandler = (serverId) => {
             if (!loggedServers.has(serverId)) {
@@ -120,6 +151,15 @@ export async function monitorXYProvider(opts = {}) {
         const errorHandler = (err, serverId) => {
             error(`XY gateway: ${serverId} error: ${String(err)}`);
         };
+        const triggerEventHandler = (context) => {
+            log(`[MONITOR] 📌 Received trigger-event, dispatching to handler...`);
+            log(`[MONITOR]   - sessionId: ${context.sessionId}`);
+            log(`[MONITOR]   - taskId: ${context.taskId}`);
+            // 异步处理 Trigger 事件，不阻塞主流程
+            handleTriggerEvent(context, cfg, runtime, accountId).catch((err) => {
+                error(`[MONITOR] Failed to handle trigger-event:`, err);
+            });
+        };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
@@ -136,6 +176,7 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("connected", connectedHandler);
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
+            wsManager.off("trigger-event", triggerEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -165,6 +206,7 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("connected", connectedHandler);
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
+        wsManager.on("trigger-event", triggerEventHandler);
         // Start periodic health check (every 5 minutes)
         console.log("🏥 Starting periodic health check (every 5 minutes)...");
         healthCheckInterval = setInterval(() => {