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

package/dist/src/channel.js

@@ -2,15 +2,55 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
-import { createAllTools } from "./tools/create-all-tools.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
-/**
- * Prefix used for synthetic sessionIds created during cron-triggered tool
- * execution.  `sendCommand()` checks this prefix to route commands through
- * the push channel instead of the (non-existent) WebSocket session.
- */
-const CRON_SESSION_PREFIX = "cron-";
+// Static tool imports (3.24 pattern)
+import { locationTool } from "./tools/location-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { sendHtmlCardTool } from "./tools/send-html-card-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
+import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
+import { callDeviceTool } from "./tools/call-device-tool.js";
+import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
+import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
+import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
+import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
+import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
+import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
+import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
+import { agentAsSkillTool } from "./tools/agent-as-skill-tool.js";
+import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js";
+import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
+import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
+import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+const ALL_TOOLS = [
+    locationTool,
+    discoverCrossDevicesTool,
+    sendCrossDeviceTaskTool,
+    displayA2UICardByPathTool,
+    callDeviceTool,
+    getNoteToolSchemaTool,
+    getCalendarToolSchemaTool,
+    getContactToolSchemaTool,
+    getPhotoToolSchemaTool,
+    xiaoyiGuiTool,
+    getDeviceFileToolSchemaTool,
+    getAlarmToolSchemaTool,
+    getCollectionToolSchemaTool,
+    sendFileToUserTool,
+    sendHtmlCardTool,
+    viewPushResultTool,
+    imageReadingTool,
+    timestampToUtc8Tool,
+    saveSelfEvolutionSkillTool,
+    loginTokenTool,
+    agentAsSkillTool,
+    checkPluginPrivilegeTool,
+];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -32,7 +72,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"], // Only private chat (no group support)
+        chatTypes: ["direct"],
         polls: false,
         threads: false,
         media: true,
@@ -49,59 +89,11 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /**
-     * Provide channel-specific agent tools.
-     *
-     * Two execution contexts are supported:
-     *
-     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
-     *     a context that was registered by bot.ts during message processing.
-     *     Tools send commands through the WebSocket and listen for responses.
-     *
-     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
-     *     `agentTools({ cfg })` without an active WebSocket session.  When no
-     *     session context exists but `cfg` is provided, we create a synthetic
-     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
-     *     `sendCommand()` detects this prefix and routes commands through the
-     *     push channel.  Response listening (WebSocket events) works unchanged
-     *     because the gateway WebSocket connection is always active.
-     */
-    agentTools: (params) => {
-        let ctx = getCurrentSessionContext();
-        // ── Cron / non-session fallback ──────────────────────────────
-        // When no active xy WebSocket session exists but the openclaw cfg
-        // is provided (framework calls agentTools({ cfg })), create a
-        // synthetic "cron session".  This enables cron-triggered agent
-        // turns and cross-channel tool calls to use xiaoyi tools via the
-        // push channel.  sendCommand() detects the "cron-" sessionId
-        // prefix and routes commands through push instead of WebSocket.
-        if (!ctx && params?.cfg) {
-            try {
-                const config = resolveXYConfig(params.cfg);
-                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-                ctx = {
-                    config,
-                    sessionId: cronId,
-                    taskId: cronId,
-                    messageId: cronId,
-                    agentId: "default",
-                    isCron: true,
-                };
-                // Register so getCurrentSessionContext() fallback can find it
-                registerSession(`__cron__${cronId}`, ctx);
-                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
-            }
-            catch (err) {
-                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
-            }
-        }
-        if (!ctx) {
-            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
-            return [];
-        }
-        const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+    /** Static tool list (3.24 pattern). Tools read SessionContext at execute time via ALS. */
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(ALL_TOOLS, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${ALL_TOOLS.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {
@@ -113,7 +105,6 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
-                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -135,20 +126,46 @@ export const xyPlugin = {
                 ? { conversationId, matchPriority: 2 }
                 : null;
         },
+        resolveCommandConversation: ({ accountId, sessionKey }) => {
+            // xiaoyi-channel: the A2A sessionId IS the conversationId.
+            // 1. Prefer the current ALS session context (works when the command
+            //    is processed inside an active A2A message-handling turn).
+            const ctx = getCurrentSessionContext();
+            const alsSessionId = ctx?.sessionId?.trim();
+            if (alsSessionId)
+                return { conversationId: alsSessionId };
+            // 2. Fall back to parsing the session key. For xiaoyi-channel the
+            //    session key has the form:
+            //      agent:<agentId>:xiaoyi-channel:<accountId>:<sessionId>
+            //    The last `:`-delimited segment is the A2A sessionId.
+            if (sessionKey) {
+                const lastColon = sessionKey.lastIndexOf(":");
+                if (lastColon >= 0) {
+                    const sessionId = sessionKey.slice(lastColon + 1).trim();
+                    if (sessionId)
+                        return { conversationId: sessionId };
+                }
+            }
+            return null;
+        },
     },
     reload: {
         configPrefixes: ["channels.xiaoyi-channel"],
     },
-    // Gateway adapter for receiving messages
     gateway: {
         async startAccount(context) {
             const { monitorXYProvider } = await import("./monitor.js");
+            const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
                 wsUrl: account.wsUrl,
             });
             context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
+            // Register ACP session binding adapter for this account.
+            // Enables sessions_spawn(runtime="acp") to bind subagent sessions
+            // to the current A2A conversation.
+            createXyAcpBindingManager({ accountId: context.accountId, cfg: context.cfg });
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.d.ts

@@ -1,6 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export declare function getCachedXYWebSocketManager(): XYWebSocketManager;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/client.js

@@ -13,6 +13,16 @@ if (!_g.__xyWsManagerCache) {
     _g.__xyWsManagerCache = new Map();
 }
 const wsManagerCache = _g.__xyWsManagerCache;
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export function getCachedXYWebSocketManager() {
+    if (wsManagerCache.size === 0) {
+        throw new Error("No WebSocket manager available in cache");
+    }
+    return wsManagerCache.values().next().value;
+}
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

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

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

package/dist/src/cspl/call_api.js

@@ -4,7 +4,8 @@
 import https from 'https';
 import { URL } from 'url';
 import { getConfig } from './config.js';
-import { DEFAULT_HTTPS_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { logger } from '../utils/logger.js';
+import { DEFAULT_HTTPS_PORT, DEFAULT_HTTP_PORT, HTTP_STATUS_BAD_REQUEST } 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');
@@ -22,7 +23,7 @@ function buildRequestOptions(url, headers, timeout) {
     const urlObj = new URL(url);
     return {
         hostname: urlObj.hostname,
-        port: urlObj.port || DEFAULT_HTTPS_PORT,
+        port: urlObj.port || (urlObj.protocol === 'https:' ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT),
         path: urlObj.pathname,
         method: "POST",
         headers: headers,
@@ -69,6 +70,7 @@ function handleResponse(res, resolve, reject) {
         data += chunk;
     });
     res.on('end', () => {
+        logger.log(`[SENTINEL HOOK] callApi response body: ${data}`);
         try {
             const result = parseResponseData(data);
             resolve(result);
@@ -78,19 +80,16 @@ function handleResponse(res, resolve, reject) {
         }
     });
 }
-export async function callApi(questionText, api, sessionId, action) {
+export async function callApi(payload, api, sessionId) {
     const config = getConfig(api);
     const headersForCelia = buildHeadersForCelia(config, sessionId);
-    const payload = {
-        questionText: questionText,
-        textSource: config.textSource,
-        action: action,
-        extra: `${JSON.stringify({ userId: config.uid })}`
-    };
-    const httpBody = JSON.stringify(payload);
-    const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    // 确保 uid 存在于消息体中（从 config 注入）
+    const payloadWithUid = { ...payload, uid: config.uid };
+    const httpBody = JSON.stringify(payloadWithUid);
+    logger.log(`[SENTINEL HOOK] callApi request URL: ${config.api.url}`);
+    logger.log(`[SENTINEL HOOK] callApi request body: ${httpBody}`);
     return new Promise((resolve, reject) => {
-        const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
+        const options = buildRequestOptions(config.api.url, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {
             handleResponse(res, resolve, reject);
         });

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

@@ -11,6 +11,5 @@ export interface Config {
     skillId: string;
     requestFrom: string;
     textSource: string;
-    action: string;
 }
 export declare function getConfig(api: any): Config;

package/dist/src/cspl/config.js

@@ -3,48 +3,50 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 import { CONFIG_FILE_NAME, ENV_FILE_PATH, REQUIRED_ENV_VARS } from './constants.js';
 import { logger } from '../utils/logger.js';
 let cachedConfig = null;
-function readEnvFile() {
-    if (!fs.existsSync(ENV_FILE_PATH)) {
-        throw new Error(`Environment file not found.`);
-    }
-    let envData;
+function loadEnvContent() {
     try {
-        envData = fs.readFileSync(ENV_FILE_PATH, 'utf-8');
+        return fs.readFileSync(ENV_FILE_PATH, 'utf-8');
     }
     catch (error) {
         const err = error;
         throw new Error(`Failed to read environment file. Error: ${err.message}`);
     }
-    const env = {};
+}
+function parseEnvLine(line) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith('#')) {
+        return null;
+    }
+    const firstEqualIndex = trimmedLine.indexOf('=');
+    if (firstEqualIndex === -1) {
+        return null;
+    }
+    const key = trimmedLine.substring(0, firstEqualIndex).trim();
+    const value = trimmedLine.substring(firstEqualIndex + 1).trim();
+    return { key, value };
+}
+function readEnvFile() {
+    if (!fs.existsSync(ENV_FILE_PATH)) {
+        throw new Error(`Environment file not found.`);
+    }
+    const envData = loadEnvContent();
+    const envVars = {};
     const lines = envData.split('\n');
     for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (!trimmedLine || trimmedLine.startsWith('#')) {
-            continue;
-        }
-        const firstEqualIndex = trimmedLine.indexOf('=');
-        if (firstEqualIndex === -1) {
-            continue;
-        }
-        const key = trimmedLine.substring(0, firstEqualIndex).trim();
-        const value = trimmedLine.substring(firstEqualIndex + 1).trim();
-        if (key && REQUIRED_ENV_VARS.includes(key)) {
-            env[key] = value;
+        const parsed = parseEnvLine(line);
+        if (parsed && parsed.key && REQUIRED_ENV_VARS.includes(parsed.key)) {
+            envVars[parsed.key] = parsed.value;
         }
     }
-    return env;
+    return envVars;
 }
-export function getConfig(api) {
-    if (cachedConfig) {
-        return cachedConfig;
-    }
-    const configPath = path.join(__dirname, CONFIG_FILE_NAME);
-    if (!fs.existsSync(configPath)) {
-        throw new Error(`Config file not found: ${CONFIG_FILE_NAME}`);
-    }
+function loadConfigFile(configPath) {
     let configData;
     try {
         configData = fs.readFileSync(configPath, 'utf-8');
@@ -52,58 +54,65 @@ export function getConfig(api) {
     catch (error) {
         throw new Error(`Failed to read config file: ${CONFIG_FILE_NAME}.`);
     }
-    let parsedConfig;
     try {
-        parsedConfig = JSON.parse(configData);
+        return JSON.parse(configData);
     }
     catch (error) {
         throw new Error(`Failed to parse config file: ${CONFIG_FILE_NAME}.`);
     }
-    if (!parsedConfig || typeof parsedConfig !== 'object') {
-        throw new Error(`Invalid config structure: ${CONFIG_FILE_NAME}. Expected an object.`);
-    }
-    const config = parsedConfig;
-    if (!config.api || typeof config.api !== 'object') {
-        throw new Error(`Invalid config: missing or invalid 'api' section in ${CONFIG_FILE_NAME}`);
-    }
-    if (!config.api.timeout || typeof config.api.timeout !== 'number') {
-        throw new Error(`Invalid config: missing or invalid 'api.timeout' in ${CONFIG_FILE_NAME}`);
-    }
-    if (!config.skillId || typeof config.skillId !== 'string') {
-        throw new Error(`Invalid config: missing or invalid 'skillId' in ${CONFIG_FILE_NAME}`);
-    }
-    if (!config.requestFrom || typeof config.requestFrom !== 'string') {
-        throw new Error(`Invalid config: missing or invalid 'requestFrom' in ${CONFIG_FILE_NAME}`);
-    }
-    if (!config.textSource || typeof config.textSource !== 'string') {
-        throw new Error(`Invalid config: missing or invalid 'textSource' in ${CONFIG_FILE_NAME}`);
-    }
-    if (!config.action || typeof config.action !== 'string') {
-        throw new Error(`Invalid config: missing or invalid 'action' in ${CONFIG_FILE_NAME}`);
+}
+function validateConfigStructure(config) {
+    const validators = [
+        { field: 'api', check: () => !config.api || typeof config.api !== 'object' },
+        { field: 'api.timeout', check: () => !config.api?.timeout || typeof config.api.timeout !== 'number' },
+        { field: 'skillId', check: () => !config.skillId || typeof config.skillId !== 'string' },
+        { field: 'requestFrom', check: () => !config.requestFrom || typeof config.requestFrom !== 'string' },
+        { field: 'textSource', check: () => !config.textSource || typeof config.textSource !== 'string' },
+    ];
+    for (const { field, check } of validators) {
+        if (check()) {
+            throw new Error(`Invalid config: missing or invalid '${field}' in ${CONFIG_FILE_NAME}`);
+        }
     }
-    let env;
+}
+function validateEnvVars() {
+    let envVars;
     try {
-        env = readEnvFile();
+        envVars = readEnvFile();
     }
     catch (error) {
         const err = error;
         throw new Error(`Failed to load environment variables from env files: ${err.message}`);
     }
-    const personalApiKey = env['PERSONAL-API-KEY'];
+    const personalApiKey = envVars['PERSONAL-API-KEY'];
     if (!personalApiKey || typeof personalApiKey !== 'string' || personalApiKey.trim() === '') {
         throw new Error(`Missing or empty 'PERSONAL-API-KEY' in env files`);
     }
-    const personalUid = env['PERSONAL-UID'];
+    const personalUid = envVars['PERSONAL-UID'];
     if (!personalUid || typeof personalUid !== 'string' || personalUid.trim() === '') {
         throw new Error(`Missing or empty 'PERSONAL-UID' in env files`);
     }
-    const serviceUrl = env['SERVICE_URL'];
+    const serviceUrl = envVars.SERVICE_URL;
     if (!serviceUrl || typeof serviceUrl !== 'string' || serviceUrl.trim() === '') {
         throw new Error(`Missing or empty 'SERVICE_URL' in env files`);
     }
-    config.apiKey = personalApiKey.trim();
-    config.uid = personalUid.trim();
-    config.api.url = serviceUrl.trim();
+    return envVars;
+}
+export function getConfig(api) {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = path.join(__dirname, CONFIG_FILE_NAME);
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${CONFIG_FILE_NAME}`);
+    }
+    const parsedConfig = loadConfigFile(configPath);
+    const config = parsedConfig;
+    validateConfigStructure(config);
+    const envVars = validateEnvVars();
+    config.apiKey = envVars['PERSONAL-API-KEY'].trim();
+    config.uid = envVars['PERSONAL-UID'].trim();
+    config.api.url = envVars.SERVICE_URL.trim();
     cachedConfig = config;
     logger.log(`[SENTINEL HOOK] Config loaded successfully`);
     return cachedConfig;

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

@@ -11,7 +11,42 @@ export interface ApiPayload {
     questionText: string;
     textSource: string;
     action: string;
-    extra?: string;
+}
+export declare const RESULT_CODE_MAP: Record<number, string>;
+export interface NewRequestPayload {
+    taskID: string;
+    sessionID: string;
+    uid: string;
+    businessID: string;
+    sceneID: string;
+    checkPoint: number;
+    interActionID: number;
+    loginType?: string;
+    reqTime?: string;
+    message: object;
+}
+export interface NewApiResponse {
+    data: {
+        taskID: string;
+        resultCode: number;
+        resultMessage?: string;
+        securityResult: string;
+        riskLabels?: string[];
+        riskDegree?: Array<{
+            riskLabel: string;
+            score: number;
+        }>;
+        riskLabelCount?: Array<{
+            riskLabel: string;
+            count: number;
+        }>;
+        actionRiskResult?: {
+            riskScore: number;
+            riskTag: string[];
+        };
+    };
+    retCode?: string;
+    retMsg?: string;
 }
 export interface ApiResponse {
     [key: string]: any;

package/dist/src/cspl/constants.js

@@ -1,6 +1,15 @@
 /*
  * 版权所有 (c) 华为技术有限公司 2026-2026
  */
+// resultCode 错误码映射
+export const RESULT_CODE_MAP = {
+    0: 'Success',
+    1: 'Parameter is invalid',
+    2: "Parameter's format is invalid",
+    3: 'The request frequency exceeds the limit',
+    4: "Parameter's size is invalid",
+    5: 'The text detection is abnormal',
+};
 // 常量配置
 export const MIN_TEXT_LENGTH = 0;
 export const MAX_TEXT_LENGTH = 4096;

package/dist/src/cspl/sentinel_hook.js

@@ -2,32 +2,34 @@
  * 版权所有 (c) 华为技术有限公司 2026-2026
  */
 import crypto from 'crypto';
-import { callApi } from './call_api.js';
-import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput } from './utils.js';
-import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, TOOL_OUTPUT_ACTION } from './constants.js';
 import { logger } from '../utils/logger.js';
-import { getSessionContext } from '../tools/session-manager.js';
+import { callApi } from './call_api.js';
+import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput, buildToolOutputPayload, extractInterActionId } from './utils.js';
+import { ALLOWED_TOOLS, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, MAX_TEXT_LENGTH, STEER_ABORT_MESSAGE } from './constants.js';
+import { getCurrentSessionContext } from '../tools/session-manager.js';
 import { tryInjectSteer } from './steer-context.js';
 // 主入口模块
 export default function register(api) {
     api.on("before_tool_call", async (event, ctx) => {
         logger.log(`[SENTINEL HOOK] before_tool_call_event toolName: ${event.toolName}`);
-        // 生成sessionID
-        const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-        logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+        // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+        const sessionCtx = getCurrentSessionContext();
+        const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+        const taskId = sessionCtx?.taskId || event.runId;
+        logger.log(`[SENTINEL HOOK] Session ID: ${sessionId}, Task ID: ${taskId} (fromALS: ${!!sessionCtx?.sessionId})`);
         // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
             let scanResult = null;
             if (event.toolName === 'exec') {
-                scanResult = await handleExecToolInput(event, api, sessionId);
+                scanResult = await handleExecToolInput(event, api, sessionId, taskId);
             }
             else if (event.toolName === 'message') {
-                scanResult = await handleMessageToolInput(event, api, sessionId);
+                scanResult = await handleMessageToolInput(event, api, sessionId, taskId);
             }
             else {
-                scanResult = await handleOtherToolInput(event, api, sessionId);
+                scanResult = await handleOtherToolInput(event, api, sessionId, taskId);
             }
-            if (scanResult?.status === 'REJECT') {
+            if (scanResult?.status === 'reject') {
                 logger.warn(`[SENTINEL HOOK] TOOL_INPUT REJECT, blocking tool call: ${event.toolName}`);
                 return { block: true, blockReason: `安全扫描检测到风险，已阻止工具调用: ${event.toolName}` };
             }
@@ -43,10 +45,12 @@ export default function register(api) {
         }
         try {
             logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
-            // 生成sessionID
-            const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-            logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
-            // 处理TOOL_OUTPUT数据采集（保持现有逻辑）
+            // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+            const sessionCtx = getCurrentSessionContext();
+            const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+            const taskId = sessionCtx?.taskId || event.runId;
+            logger.log(`[SENTINEL HOOK] Session ID: ${sessionId}, Task ID: ${taskId} (fromALS: ${!!sessionCtx?.sessionId})`);
+            // 处理TOOL_OUTPUT数据采集
             const resultText = extractResultText(event, event.toolName);
             const resultTextLength = resultText.length;
             if (resultTextLength > MAX_TOTAL_LENGTH) {
@@ -58,27 +62,24 @@ export default function register(api) {
                 return;
             }
             // 处理和验证文本
-            const questionText = { subSceneID: 'TOOL_OUTPUT', tool: `${event.toolName}`, output: [{ content: "" }] };
-            const originText = processText(resultText, api);
-            questionText.output[0].content = `${originText}`;
-            const finalText = JSON.stringify(questionText);
-            if (finalText.length > MAX_TEXT_LENGTH) {
-                const diff_length = finalText.length - MAX_TEXT_LENGTH;
-                const { text: filterText, truncated } = validateAndTruncateText(originText, MAX_TEXT_LENGTH - diff_length);
+            const originText = processText(resultText);
+            let content = originText;
+            if (originText.length > MAX_TEXT_LENGTH) {
+                const { text: filterText, truncated } = validateAndTruncateText(originText, MAX_TEXT_LENGTH);
                 if (truncated) {
-                    questionText.output[0].content = `${filterText}`;
+                    content = filterText;
                     logger.warn(`[SENTINEL HOOK] postText exceeds ${MAX_TEXT_LENGTH}.`);
                 }
             }
-            const postText = JSON.stringify(questionText);
-            logger.log(`[SENTINEL HOOK] Content extracted successfully. Length: ${postText.length}`);
+            const interActionID = extractInterActionId(taskId);
+            const outputPayload = buildToolOutputPayload(taskId, sessionId, event.toolName, content, event.toolCallId, interActionID);
+            logger.log(`[SENTINEL HOOK] Content extracted successfully. Length: ${JSON.stringify(outputPayload).length}`);
             try {
-                const response = await callApi(postText, api, sessionId, TOOL_OUTPUT_ACTION);
+                const response = await callApi(outputPayload, api, sessionId);
                 const result = parseSecurityResult(response);
                 logger.log(`[SENTINEL HOOK] TOOL_OUTPUT response: status=${result.status}.`);
-                if (result.status === 'REJECT') {
+                if (result.status === 'reject') {
                     logger.warn('[SENTINEL HOOK] REJECT detected, attempting steer injection');
-                    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
                     if (sessionCtx?.sessionId && sessionCtx?.taskId) {
                         await tryInjectSteer({
                             sessionId: sessionCtx.sessionId,