@ynhcj/xiaoyi-channel 0.0.125-next → 0.0.126-next

package/dist/index.js

@@ -1,7 +1,13 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
-import { createCsplMiddleware } from "./src/cspl/middleware.js";
+import { callCsplApiWithConfig } from "./src/cspl/call-api.js";
+import { getCsplConfig, initCsplConfigFromXYConfig } from "./src/cspl/config.js";
+import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./src/cspl/constants.js";
+import { extractResultText, parseSecurityResult, processText, validateAndTruncateText, } from "./src/cspl/utils.js";
+import { tryInjectSteer } from "./src/cspl/steer-context.js";
+import { getSessionContext } from "./src/tools/session-manager.js";
+import { logger } from "./src/utils/logger.js";
 import { setXYRuntime } from "./src/runtime.js";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
@@ -20,13 +26,66 @@ function registerFullHooks(api) {
     api.on("before_prompt_build", beforePromptBuildHandler);
     registerSelfEvolutionToolResultNudge(api);
 }
-function registerCsplMiddleware(api) {
-    // CSPL security scanning via AgentToolResultMiddleware.
-    // Intercepts tool results BEFORE they reach the LLM, so on REJECT
-    // the result is replaced entirely — no steer injection needed.
-    // Only registered in "full" mode because it depends on session context
-    // for CSPL config resolution.
-    api.registerAgentToolResultMiddleware(createCsplMiddleware(), { runtimes: ["pi"] });
+function registerCsplHook(api) {
+    // CSPL security scanning via after_tool_call hook.
+    // When CSPL returns REJECT, injects a steer message via tryInjectSteer
+    // to interrupt the agent. Uses skipRegistration to avoid refCount leaks
+    // and taskId overwrites.
+    // Only registered in "full" mode because it depends on handleXYMessage
+    // having cached cfg/runtime via setCsplSteerContext.
+    api.on("after_tool_call", async (event, ctx) => {
+        if (!ALLOWED_TOOLS.includes(event.toolName)) {
+            return;
+        }
+        try {
+            const resultText = extractResultText(event, event.toolName);
+            const resultLength = resultText.length;
+            if (resultLength <= MIN_TEXT_LENGTH || resultLength > MAX_TOTAL_LENGTH) {
+                return;
+            }
+            logger.log(`[SENTINEL HOOK] after_tool_call: toolName=${event.toolName}, textLength=${resultLength}`);
+            const questionText = {
+                subSceneID: "TOOL_OUTPUT",
+                tool: event.toolName,
+                output: [{ content: "" }],
+            };
+            const originText = processText(resultText);
+            questionText.output[0].content = originText;
+            let finalJson = JSON.stringify(questionText);
+            if (finalJson.length > MAX_TEXT_LENGTH) {
+                const diff = finalJson.length - MAX_TEXT_LENGTH;
+                const { text: trimmed } = validateAndTruncateText(originText, MAX_TEXT_LENGTH - diff);
+                questionText.output[0].content = trimmed;
+                finalJson = JSON.stringify(questionText);
+            }
+            const sessionCtx = getSessionContext(ctx.sessionKey ?? "");
+            const csplConfig = sessionCtx
+                ? initCsplConfigFromXYConfig(sessionCtx.config)
+                : getCsplConfig();
+            const csplStartTime = Date.now();
+            const response = await callCsplApiWithConfig(finalJson, csplConfig);
+            const csplElapsed = Date.now() - csplStartTime;
+            const result = parseSecurityResult(response);
+            logger.log(`[SENTINEL HOOK] Security result: status=${result.status}, toolName=${event.toolName}, elapsed=${csplElapsed}ms`);
+            if (result.status === "REJECT") {
+                logger.log(`[SENTINEL HOOK] REJECT - injecting steer via tryInjectSteer`);
+                if (sessionCtx) {
+                    await tryInjectSteer({
+                        sessionId: sessionCtx.sessionId,
+                        taskId: sessionCtx.taskId,
+                        message: STEER_ABORT_MESSAGE,
+                        source: "cspl",
+                    });
+                }
+                else {
+                    logger.error("[SENTINEL HOOK] No session context, cannot inject steer");
+                }
+            }
+        }
+        catch (err) {
+            logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
+        }
+    });
 }
 export default definePluginEntry({
     id: "xiaoyi-channel",
@@ -36,12 +95,22 @@ export default definePluginEntry({
         // Always register the provider so wrapStreamFn/prepareExtraParams work
         // in ALL registration modes (not just "full").
         api.registerProvider(xiaoyiProvider);
+        if (api.registrationMode === "cli-metadata") {
+            return;
+        }
+        if (api.registrationMode === "tool-discovery") {
+            registerFullHooks(api);
+            return;
+        }
         // Register channel plugin and set runtime
         api.registerChannel({ plugin: xyPlugin });
         setXYRuntime(api.runtime);
+        if (api.registrationMode === "discovery") {
+            return;
+        }
         if (api.registrationMode === "full") {
             registerFullHooks(api);
-            registerCsplMiddleware(api);
+            registerCsplHook(api);
         }
     },
 });

package/dist/src/bot.d.ts

@@ -11,6 +11,12 @@ export interface HandleXYMessageParams {
     webSocketSessionId?: string;
     /** Called after dispatch init is complete (agentTools/wrapStreamFn done). */
     onInitComplete?: () => void;
+    /**
+     * When true, skip taskId/session registration. Used by tryInjectSteer to
+     * inject a steer message without overwriting the active taskId or leaking
+     * session refCount.
+     */
+    skipRegistration?: boolean;
 }
 /**
  * Handle an incoming A2A message.

package/dist/src/bot.js

@@ -101,12 +101,16 @@ export async function handleXYMessage(params) {
         // ========================================
         // 🔑 注册taskId（检测是否是已有活跃任务的 session）
         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}`);
         }
-        registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId);
+        // Steer injections skip taskId registration to avoid overwriting the active taskId
+        if (!skipReg) {
+            registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId);
+        }
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
@@ -147,26 +151,29 @@ export async function handleXYMessage(params) {
             },
         });
         logger.log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
-        registerSession(route.sessionKey, {
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            agentId: route.accountId,
-            deviceType,
-        });
-        // 🔑 发送初始状态更新
-        logger.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) => {
-            logger.error(`Failed to send initial status update:`, err);
-        });
+        // Steer injections skip session registration to avoid refCount leaks
+        if (!skipReg) {
+            registerSession(route.sessionKey, {
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                agentId: route.accountId,
+                deviceType,
+            });
+            // 🔑 发送初始状态更新
+            logger.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) => {
+                logger.error(`Failed to send initial status update:`, err);
+            });
+        }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         let textForAgent = text || "";
@@ -255,7 +262,10 @@ export async function handleXYMessage(params) {
             accountId: route.accountId,
             steerState,
         });
-        startStatusInterval();
+        // Steer injections don't need status intervals
+        if (!skipReg) {
+            startStatusInterval();
+        }
         // Build session context for AsyncLocalStorage
         const sessionContext = {
             config,

package/dist/src/cspl/steer-context.d.ts

@@ -1,7 +1,21 @@
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
 export declare function setCsplSteerContext(cfg: ClawdbotConfig, runtime: RuntimeEnv): void;
+/** Parameters for steer message injection. */
+export interface SteerInjectionParams {
+    sessionId: string;
+    taskId: string;
+    message: string;
+    /** Human-readable source label for logging (e.g. "cspl", "self-evolution"). */
+    source: string;
+}
 /**
- * Inject a steer message into the given session by constructing a synthetic
- * A2A message and dispatching it through handleXYMessage.
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
  */
-export declare function injectCsplSteer(sessionId: string, taskId: string, message: string): Promise<boolean>;
+export declare function tryInjectSteer(params: SteerInjectionParams): Promise<boolean>;

package/dist/src/cspl/steer-context.js

@@ -3,23 +3,30 @@ import { logger } from "../utils/logger.js";
 import { randomUUID } from "node:crypto";
 let cachedCfg = null;
 let cachedRuntime = null;
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
 export function setCsplSteerContext(cfg, runtime) {
     cachedCfg = cfg;
     cachedRuntime = runtime;
 }
 /**
- * Inject a steer message into the given session by constructing a synthetic
- * A2A message and dispatching it through handleXYMessage.
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
  */
-export async function injectCsplSteer(sessionId, taskId, message) {
+export async function tryInjectSteer(params) {
+    const { sessionId, taskId, message, source } = params;
     if (!cachedCfg || !cachedRuntime) {
-        logger.error("[CSPL STEER] No cached cfg/runtime, cannot inject steer");
+        logger.error(`[STEER:${source}] No cached cfg/runtime, cannot inject steer`);
         return false;
     }
     const syntheticMessage = {
         jsonrpc: "2.0",
         method: "tasks/send",
-        id: `cspl-steer-${randomUUID()}`,
+        id: `steer-${source}-${randomUUID()}`,
         params: {
             sessionId,
             id: taskId,
@@ -30,18 +37,19 @@ export async function injectCsplSteer(sessionId, taskId, message) {
             },
         },
     };
-    logger.log(`[CSPL STEER] Injecting steer for sessionId=${sessionId}, taskId=${taskId}`);
+    logger.log(`[STEER:${source}] Injecting steer for sessionId=${sessionId}, taskId=${taskId}`);
     try {
         await handleXYMessage({
             cfg: cachedCfg,
             runtime: cachedRuntime,
             message: syntheticMessage,
             accountId: "default",
+            skipRegistration: true,
         });
         return true;
     }
     catch (err) {
-        logger.error(`[CSPL STEER] Failed to inject steer: ${err}`);
+        logger.error(`[STEER:${source}] Failed to inject steer: ${err}`);
         return false;
     }
 }

package/package.json

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