@ynhcj/xiaoyi-channel 0.0.149-beta → 0.0.151-beta

package/dist/src/bot.js

@@ -35,7 +35,8 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("clearContext request missing sessionId in params");
             }
-            logger.log(`Clear context request for session ${sessionId}`);
+            const log = logger.withContext(sessionId, "");
+            log.log(`[BOT] Clear context request`);
             const config = resolveXYConfig(cfg);
             await sendClearContextResponse({
                 config,
@@ -51,7 +52,8 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("tasks/cancel request missing sessionId in params");
             }
-            logger.log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
+            const log = logger.withContext(sessionId, taskId);
+            log.log(`[BOT] Tasks cancel request`);
             const config = resolveXYConfig(cfg);
             await sendTasksCancelResponse({
                 config,
@@ -63,22 +65,21 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // Scoped logger for this session — avoids concurrent session log mixing
+        const log = logger.withContext(parsed.sessionId, parsed.taskId);
         // ========== 检测 Trigger 消息 ==========
         // 如果消息中包含 Trigger 事件数据，直接返回 pushData 内容，不走正常流程
         const triggerData = extractTriggerData(parsed.parts);
         if (triggerData) {
-            logger.log(`[BOT] 📌 Detected Trigger message with pushDataId: ${triggerData.pushDataId}`);
-            logger.log(`[BOT]   - Session ID: ${parsed.sessionId}`);
-            logger.log(`[BOT]   - Task ID: ${parsed.taskId}`);
+            log.log(`[BOT] Detected Trigger message, pushDataId=${triggerData.pushDataId}`);
             try {
                 // 读取 pushData
                 const pushDataItem = await getPushDataById(triggerData.pushDataId);
                 if (!pushDataItem) {
-                    logger.error(`[BOT] ❌ pushData not found for ID: ${triggerData.pushDataId}`);
+                    log.error(`[BOT] pushData not found for ID: ${triggerData.pushDataId}`);
                     return;
                 }
-                logger.log(`[BOT] ✅ Found pushData, sending direct response`);
-                logger.log(`[BOT]   - pushDataId: ${pushDataItem.pushDataId}`);
+                log.log(`[BOT] Found pushData, sending direct response, pushDataId=${pushDataItem.pushDataId}`);
                 const config = resolveXYConfig(cfg);
                 // 直接发送响应（final=true，不走 openclaw 流程）
                 await sendA2AResponse({
@@ -90,11 +91,11 @@ export async function handleXYMessage(params) {
                     append: false,
                     final: true,
                 });
-                logger.log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
+                log.log(`[BOT] Trigger response sent successfully`);
                 return; // 提前返回，不继续处理
             }
             catch (err) {
-                logger.error(`[BOT] ❌ Failed to handle Trigger message:`, err);
+                log.error(`[BOT] Failed to handle Trigger message:`, err);
                 return;
             }
         }
@@ -103,9 +104,7 @@ export async function handleXYMessage(params) {
         const isUpdate = hasActiveTask(parsed.sessionId);
         const skipReg = params.skipRegistration === true;
         if (isUpdate) {
-            logger.log(`[BOT] 🔄 STEER MODE - Second message detected (core will handle steer)`);
-            logger.log(`[BOT]   - Session: ${parsed.sessionId}`);
-            logger.log(`[BOT]   - New taskId: ${parsed.taskId}`);
+            log.log(`[BOT] STEER MODE - Second message detected, new taskId=${parsed.taskId}`);
         }
         // Steer injections skip taskId registration to avoid overwriting the active taskId
         if (!skipReg) {
@@ -113,28 +112,28 @@ export async function handleXYMessage(params) {
             // Extract and update push_id if present
             const pushId = extractPushId(parsed.parts);
             if (pushId) {
-                logger.log(`[BOT] 📌 Extracted push_id from user message`);
+                log.log(`[BOT] Extracted push_id from user message`);
                 configManager.updatePushId(parsed.sessionId, pushId);
                 // 持久化 pushId 到本地文件（异步，不阻塞主流程）
                 addPushId(pushId).catch((err) => {
-                    logger.error(`[BOT] Failed to persist pushId:`, err);
+                    log.error(`[BOT] Failed to persist pushId:`, err);
                 });
             }
             else {
-                logger.log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+                log.log(`[BOT] No push_id found in message, using config default`);
             }
             // 保存 runtime 信息到 .xiaoyiruntime 文件（异步，不阻塞主流程）
             saveRuntimeInfo(webSocketSessionId || parsed.sessionId, // SESSION_ID (WebSocket 层级，如果没有则 fallback)
             parsed.sessionId, // CONVERSATION_ID (param 里的 sessionId)
             parsed.taskId // TASK_ID (param.id)
             ).catch((err) => {
-                logger.error(`[BOT] Failed to save runtime info:`, err);
+                log.error(`[BOT] Failed to save runtime info:`, err);
             });
         }
         // Extract deviceType if present (always parse — used in ctxPayload.MessageSid)
         const deviceType = extractDeviceType(parsed.parts);
         if (deviceType) {
-            logger.log(`[BOT] 📱 Extracted deviceType from user message: ${deviceType}`);
+            log.log(`[BOT] Extracted deviceType: ${deviceType}`);
         }
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
@@ -150,7 +149,7 @@ export async function handleXYMessage(params) {
                 id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
             },
         });
-        logger.log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
         // Steer injections skip session registration to avoid refCount leaks
         if (!skipReg) {
             registerSession(route.sessionKey, {
@@ -162,7 +161,7 @@ export async function handleXYMessage(params) {
                 deviceType,
             });
             // 🔑 发送初始状态更新
-            logger.log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+            log.log(`[BOT] Sending initial status update`);
             void sendStatusUpdate({
                 config,
                 sessionId: parsed.sessionId,
@@ -171,7 +170,7 @@ export async function handleXYMessage(params) {
                 text: "任务正在处理中，请稍候~",
                 state: "working",
             }).catch((err) => {
-                logger.error(`Failed to send initial status update:`, err);
+                log.error(`Failed to send initial status update:`, err);
             });
         }
         // Extract text and files from parts
@@ -183,18 +182,18 @@ export async function handleXYMessage(params) {
                 const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
                 if (selfEvolutionEnabled && shouldNudgeForSelfEvolutionKeyword(textForAgent)) {
                     const shouldNudge = toolCallNudgeManager.tryMarkKeywordNudge(route.sessionKey);
-                    logger.log(`[SELF_EVOLUTION] Keyword check hit during inbound build: sessionKey=${route.sessionKey}, shouldNudge=${shouldNudge}`);
+                    log.log(`[SELF_EVOLUTION] Keyword check hit during inbound build: sessionKey=${route.sessionKey}, shouldNudge=${shouldNudge}`);
                     if (shouldNudge) {
                         const augmented = appendSelfEvolutionKeywordNudge(textForAgent);
                         textForAgent = augmented.text;
                         if (augmented.appended) {
-                            logger.log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
+                            log.log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
                         }
                     }
                 }
             }
             catch (selfEvolutionError) {
-                logger.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
+                log.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
         // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
@@ -209,9 +208,11 @@ export async function handleXYMessage(params) {
             const steerDownloadedFiles = await downloadFilesFromParts(steerFileParts);
             const steerMediaPayload = buildXYMediaPayload(steerDownloadedFiles);
             if (steerFileParts.length > 0) {
-                logger.log(`[BOT] 📎 Steer message with files: ${steerFileParts.length} file(s)`);
+                log.log(`[BOT] Steer message with ${steerFileParts.length} file(s), enqueuing to streaming-signal queue`);
+            }
+            else {
+                log.log(`[BOT] Steer message — enqueuing to streaming-signal queue`);
             }
-            logger.log(`[BOT] 🔄 Steer message — enqueuing to streaming-signal queue`);
             await enqueueSteer({
                 sessionId: parsed.sessionId,
                 sessionKey: route.sessionKey,
@@ -223,8 +224,7 @@ export async function handleXYMessage(params) {
                 route,
                 deviceType,
             });
-            logger.log(`[BOT] ✅ Steer queue completed for session: ${parsed.sessionId}`);
-            logger.log(`xy: dispatch complete (session=${parsed.sessionId})`);
+            log.log(`[BOT] Steer queue completed`);
             return;
         }
         // ── First message (non-steer) path below ──────────────────────
@@ -236,7 +236,7 @@ export async function handleXYMessage(params) {
         if (!skipReg) {
             const fileParts = extractFileParts(parsed.parts);
             const downloadedFiles = await downloadFilesFromParts(fileParts);
-            logger.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
+            log.log(`[BOT] Downloaded ${downloadedFiles.length} file(s)`);
             mediaPayload = buildXYMediaPayload(downloadedFiles);
         }
         // Resolve envelope format options (following feishu pattern)
@@ -282,8 +282,7 @@ export async function handleXYMessage(params) {
         // 🔑 Streaming 信号已在上方创建（在文件下载之前）
         const steerState = { steered: false };
         // 🔑 创建dispatcher
-        logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
-        logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
+        log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
@@ -306,21 +305,20 @@ export async function handleXYMessage(params) {
             agentId: route.accountId,
             deviceType,
         };
-        logger.log(`[BOT-DISPATCH] ⏳ withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
+        log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
-                logger.log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                logger.log(`[BOT]   - steered: ${steerState.steered}`);
+                log.log(`[BOT] onSettled, steered=${steerState.steered}`);
                 // 🔑 When steered, skip heavy cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
-                    logger.log(`[BOT] ✅ Steered dispatch settled (skipping cleanup)`);
+                    log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
                     return;
                 }
                 streamingSignals.delete(parsed.sessionId);
                 decrementTaskIdRef(parsed.sessionId);
                 unregisterSession(route.sessionKey);
-                logger.log(`[BOT] ✅ Cleanup completed`);
+                log.log(`[BOT] Cleanup completed`);
             },
             run: () => {
                 // 🔐 Use AsyncLocalStorage to provide session context to tools.
@@ -329,12 +327,7 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    logger.log(`[BOT-DISPATCH] ⏳ dispatchReplyFromConfig starting...`);
-                    logger.log(`[BOT-DISPATCH]   - sessionKey: ${ctxPayload.SessionKey}`);
-                    logger.log(`[BOT-DISPATCH]   - provider: ${ctxPayload.Provider}`);
-                    logger.log(`[BOT-DISPATCH]   - surface: ${ctxPayload.Surface}`);
-                    logger.log(`[BOT-DISPATCH]   - from: ${ctxPayload.From}`);
-                    logger.log(`[BOT-DISPATCH]   - body length: ${ctxPayload.Body?.length ?? 0}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -342,15 +335,11 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        logger.log(`[BOT-DISPATCH] ✅ dispatchReplyFromConfig returned`);
-                        logger.log(`[BOT-DISPATCH]   - result: ${JSON.stringify(result)}`);
+                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
                         return result;
                     }
                     catch (dispatchErr) {
-                        logger.error(`[BOT-DISPATCH] ❌ dispatchReplyFromConfig threw`);
-                        logger.error(`[BOT-DISPATCH]   - error name: ${dispatchErr instanceof Error ? dispatchErr.name : "unknown"}`);
-                        logger.error(`[BOT-DISPATCH]   - error message: ${String(dispatchErr)}`);
-                        logger.error(`[BOT-DISPATCH]   - error stack: ${dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : "N/A"}`);
+                        log.error(`[BOT-DISPATCH] dispatchReplyFromConfig threw: ${dispatchErr instanceof Error ? `${dispatchErr.name}: ${dispatchErr.message}` : String(dispatchErr)}`, dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : undefined);
                         throw dispatchErr;
                     }
                 });
@@ -359,20 +348,23 @@ export async function handleXYMessage(params) {
                 return dispatchPromise;
             },
         });
-        logger.log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
-        logger.log(`xy: dispatch complete (session=${parsed.sessionId})`);
+        log.log(`[BOT] Dispatcher completed`);
     }
     catch (err) {
         // ✅ Only log error, don't re-throw to prevent gateway restart
-        logger.error("Failed to handle XY message:", err);
+        // Note: if error occurs before parseA2AMessage, `log` may not be defined yet
+        const errSessionId = message.params?.sessionId || "";
+        const errTaskId = message.params?.id || message.id || "";
+        const errLog = logger.withContext(errSessionId, errTaskId);
+        errLog.error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
-        logger.log(`[BOT] ❌ Error occurred, attempting cleanup...`);
+        errLog.log(`[BOT] Error occurred, attempting cleanup`);
         // 🔑 错误时也要清理taskId和session
         try {
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
-                logger.log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
+                errLog.log(`[BOT] Cleaning up after error`);
                 // 清理 taskId
                 decrementTaskIdRef(sessionId);
                 // 清理 session
@@ -387,11 +379,11 @@ export async function handleXYMessage(params) {
                     },
                 });
                 unregisterSession(route.sessionKey);
-                logger.log(`[BOT] ✅ Cleanup completed after error`);
+                errLog.log(`[BOT] Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {
-            logger.log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
+            errLog.log(`[BOT] Cleanup failed:`, cleanupErr);
             // Ignore cleanup errors
         }
         // ❌ Don't re-throw: message processing error should not affect gateway stability
@@ -428,20 +420,22 @@ const steerQueues = _g.__xySteerQueues;
  * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
  */
 export function notifyModelStreaming(sessionId) {
+    const log = logger.withContext(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}`);
+        log.log(`[STEER-QUEUE] Model streaming signal fired`);
     }
 }
 function createStreamingSignal(sessionId) {
+    const log = logger.withContext(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}`);
+    log.log(`[STEER-QUEUE] Streaming signal created`);
     return signal;
 }
 /**
@@ -451,13 +445,14 @@ function createStreamingSignal(sessionId) {
  */
 function enqueueSteer(params) {
     const { sessionId } = params;
+    const log = logger.withContext(sessionId, params.parsed.taskId);
     // 取出当前队列尾部（或 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)}`);
+        log.error(`[STEER-QUEUE] Steer chain failed: ${String(err)}`);
     }).finally(() => {
         if (steerQueues.get(sessionId) === next) {
             steerQueues.delete(sessionId);
@@ -467,37 +462,38 @@ function enqueueSteer(params) {
 }
 async function dispatchSteerWhenReady(params) {
     const { sessionId, sessionKey, steerText } = params;
+    const log = logger.withContext(sessionId, params.parsed.taskId);
     // 1. 等待第一条消息开始 streaming
     //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
     //    轮询等待直到 signal 出现，最長等待 ~5 秒。
     let signal = streamingSignals.get(sessionId);
     if (!signal) {
-        logger.log(`[STEER-QUEUE] ⏳ Signal not yet created, polling for session=${sessionId}`);
+        log.log(`[STEER-QUEUE] Signal not yet created, polling`);
         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`);
+                log.log(`[STEER-QUEUE] First message completed while waiting, skip steer`);
                 return;
             }
         }
     }
     if (signal) {
-        logger.log(`[STEER-QUEUE] ⏳ Waiting for streaming signal, session=${sessionId}`);
+        log.log(`[STEER-QUEUE] Waiting for streaming signal`);
         await signal.promise;
-        logger.log(`[STEER-QUEUE] ✅ Streaming signal received, session=${sessionId}`);
+        log.log(`[STEER-QUEUE] Streaming signal received`);
     }
     else {
         // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
         // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
-        logger.log(`[STEER-QUEUE] ⚠️ Signal never appeared after polling, skip steer to avoid collision`);
+        log.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`);
+        log.log(`[STEER-QUEUE] First message completed, skip steer`);
         return;
     }
     // 3. 构建 dispatch 上下文并 dispatch /steer
@@ -559,11 +555,11 @@ async function dispatchSteerWhenReady(params) {
         agentId: params.route.accountId,
         deviceType: params.deviceType,
     };
-    logger.log(`[STEER-QUEUE] 🚀 Dispatching steer for session=${sessionId}`);
+    log.log(`[STEER-QUEUE] Dispatching steer`);
     await core.channel.reply.withReplyDispatcher({
         dispatcher,
         onSettled: () => {
-            logger.log(`[STEER-QUEUE] 🏁 Steer dispatch settled for session=${sessionId}`);
+            log.log(`[STEER-QUEUE] Steer dispatch settled`);
         },
         run: () => {
             return runWithSessionContext(sessionContext, async () => {
@@ -573,10 +569,10 @@ async function dispatchSteerWhenReady(params) {
                     dispatcher,
                     replyOptions,
                 });
-                logger.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
+                log.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
                 return result;
             });
         },
     });
-    logger.log(`[STEER-QUEUE] ✅ Steer dispatch completed for session=${sessionId}`);
+    log.log(`[STEER-QUEUE] Steer dispatch completed`);
 }

package/dist/src/client.js

@@ -24,10 +24,10 @@ export function getXYWebSocketManager(config, runtime) {
         return cached;
     }
     // Create new manager
-    logger.log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
     cached = new XYWebSocketManager(config, runtime);
     wsManagerCache.set(cacheKey, cached);
-    logger.log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
 /**
@@ -38,13 +38,13 @@ export function removeXYWebSocketManager(config) {
     const cacheKey = `${config.apiKey}-${config.agentId}`;
     const manager = wsManagerCache.get(cacheKey);
     if (manager) {
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
         manager.disconnect();
         wsManagerCache.delete(cacheKey);
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
     }
     else {
-        logger.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
     }
 }
 /**
@@ -68,35 +68,25 @@ export function getCachedManagerCount() {
  * Helps identify connection issues and orphan connections.
  */
 export function diagnoseAllManagers() {
-    logger.log(`Total cached managers: ${wsManagerCache.size}`);
+    logger.log(`[DIAG] Total cached managers: ${wsManagerCache.size}`);
     if (wsManagerCache.size === 0) {
-        logger.log("ℹ️  No managers in cache");
+        logger.log("[DIAG] No managers in cache");
         return;
     }
     let orphanCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        logger.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
-        // Connection
-        logger.log(`   🔌 Connection:`);
-        logger.log(`      - Exists: ${diag.connection.exists}`);
-        logger.log(`      - ReadyState: ${diag.connection.readyState}`);
-        logger.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
-        logger.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
-        logger.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
-        logger.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
-        logger.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        logger.log(`[DIAG] Manager ${key} — event listeners: ${diag.totalEventListeners} | Connection: exists=${diag.connection.exists}, readyState=${diag.connection.readyState}, stateConnected=${diag.connection.stateConnected}/${diag.connection.stateReady}, reconnectAttempts=${diag.connection.reconnectAttempts}, wsListeners=${diag.connection.listenerCount}, heartbeatActive=${diag.connection.heartbeatActive}, hasReconnectTimer=${diag.connection.hasReconnectTimer}`);
         if (diag.connection.isOrphan) {
-            logger.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            logger.log(`[DIAG] ORPHAN CONNECTION DETECTED on manager: ${key}`);
             orphanCount++;
         }
     });
     if (orphanCount > 0) {
-        logger.log(`⚠️  Total orphan connections found: ${orphanCount}`);
-        logger.log(`💡 Suggestion: These connections should be cleaned up`);
+        logger.log(`[DIAG] Total orphan connections found: ${orphanCount} — these connections should be cleaned up`);
     }
     else {
-        logger.log(`✅ No orphan connections found`);
+        logger.log("[DIAG] No orphan connections found");
     }
 }
 /**
@@ -108,13 +98,13 @@ export function cleanupOrphanConnections() {
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
         if (diag.connection.isOrphan) {
-            logger.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            logger.log(`[CLEANUP] Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;
         }
     });
     if (cleanedCount > 0) {
-        logger.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+        logger.log(`[CLEANUP] Cleaned up ${cleanedCount} manager(s) with orphan connections`);
     }
     return cleanedCount;
 }

package/dist/src/cspl/call_api.d.ts

@@ -0,0 +1,2 @@
+import { ApiResponse } from './constants.js';
+export declare function callApi(questionText: string, api: any, sessionId: string): Promise<ApiResponse>;

package/dist/src/cspl/call_api.js

@@ -0,0 +1,107 @@
+/*
+ * 版权所有 (c) 华为技术有限公司 2026-2026
+ */
+import https from 'https';
+import { URL } from 'url';
+import { getConfig } from './config.js';
+import { DEFAULT_HTTP_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+function buildHeadersForCelia(config, sessionId) {
+    if (!config.uid || !config.apiKey || !config.skillId || !config.requestFrom) {
+        throw new Error('[SENTINEL HOOK] Missing required configuration: uid, apiKey, skillId, or requestFrom is not defined');
+    }
+    return {
+        'x-hag-trace-id': sessionId,
+        'x-uid': config.uid,
+        'x-api-key': config.apiKey,
+        'x-request-from': config.requestFrom,
+        'x-skill-id': config.skillId,
+        'content-type': 'application/json'
+    };
+}
+function buildRequestOptions(url, headers, timeout) {
+    const urlObj = new URL(url);
+    return {
+        hostname: urlObj.hostname,
+        port: urlObj.port || DEFAULT_HTTP_PORT,
+        path: urlObj.pathname,
+        method: "POST",
+        headers: headers,
+        timeout: timeout
+    };
+}
+function checkHttpStatus(res) {
+    if (res.statusCode && res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
+        throw new Error(`HTTP error! status: ${res.statusCode}`);
+    }
+}
+function parseResponseData(data) {
+    try {
+        if (data === undefined || data === null || data.trim() === '') {
+            throw new Error('API response data is empty or invalid');
+        }
+        const jsonData = JSON.parse(data);
+        if (jsonData.retCode && jsonData.retCode !== "0") {
+            const errorMsg = jsonData.retMsg || 'Unknown API error';
+            throw new Error(`API error: ${errorMsg}`);
+        }
+        if (!jsonData.retCode && jsonData.code) {
+            const errorMsg = jsonData.desc || 'Unknown backend error';
+            throw new Error(`Backend error: ${errorMsg}`);
+        }
+        return jsonData;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw new Error(`[SENTINEL HOOK] Failed to parse response：${e.message}`);
+        }
+        return data;
+    }
+}
+function handleResponse(res, resolve, reject) {
+    let data = '';
+    try {
+        checkHttpStatus(res);
+    }
+    catch (e) {
+        reject(e);
+    }
+    res.on('data', (chunk) => {
+        data += chunk;
+    });
+    res.on('end', () => {
+        try {
+            const result = parseResponseData(data);
+            resolve(result);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+export async function callApi(questionText, api, sessionId) {
+    const config = getConfig(api);
+    const headersForCelia = buildHeadersForCelia(config, sessionId);
+    const payload = {
+        questionText: questionText,
+        textSource: config.textSource,
+        action: config.action,
+        extra: `${JSON.stringify({ userId: config.uid })}`
+    };
+    const httpBody = JSON.stringify(payload);
+    const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    return new Promise((resolve, reject) => {
+        const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
+        const req = https.request(options, (res) => {
+            handleResponse(res, resolve, reject);
+        });
+        req.on('error', (error) => {
+            reject(error);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('[SENTINEL HOOK] Request timeout'));
+        });
+        req.write(httpBody);
+        req.end();
+    });
+}

package/dist/src/cspl/config.d.ts

@@ -1,11 +1,11 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { XYChannelConfig } from "../types.js";
+import { HttpHeaders } from './constants.js';
 export interface ApiConfig {
     url: string;
     timeout: number;
 }
-export interface CsplConfig {
+export interface Config {
     api: ApiConfig;
+    headers?: HttpHeaders;
     uid: string;
     apiKey: string;
     skillId: string;
@@ -13,17 +13,4 @@ export interface CsplConfig {
     textSource: string;
     action: string;
 }
-/**
- * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
- * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
- *
- * Accepts either ClawdbotConfig (legacy after_tool_call path) or
- * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
- * after the first successful call so subsequent calls can omit the arg.
- */
-export declare function getCsplConfig(cfg?: ClawdbotConfig): CsplConfig;
-/**
- * Initialize CSPL config from an already-resolved XYChannelConfig.
- * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
- */
-export declare function initCsplConfigFromXYConfig(xyConfig: XYChannelConfig): CsplConfig;
+export declare function getConfig(api: any): Config;