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

package/dist/index.d.ts

@@ -1,8 +1,3 @@
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
-    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
-} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
-export default _default;
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
+declare const pluginEntry: ReturnType<typeof definePluginEntry>;
+export default pluginEntry;

package/dist/index.js

@@ -10,6 +10,57 @@ import { getAllPushIds } from "./src/utils/pushid-manager.js";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
+import { registerCLIHook } from "./src/tools/hmos-cli.js";
+import { writeSkillUsage } from "./src/utils/skills-logger.js";
+import { getSteerQueue } from "./src/steer-queue.js";
+import { logger } from "./src/utils/logger.js";
+import fs from "node:fs";
+import path from "node:path";
+// Diagnostic: write marker file to confirm hook fires
+function touchHookMarker(label) {
+    try {
+        const dir = "/tmp/xy-steer-diag";
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, `${Date.now()}_${label}.txt`), `${new Date().toISOString()} ${label}\n`);
+    }
+    catch { }
+}
+/**
+ * Parse a file path string to detect if it refers to a SKILL.md file within
+ * a skills directory. Returns the skill name (parent directory) if so.
+ *
+ * Matches paths like:
+ *   ~/.openclaw/workspace/skills/my-skill/SKILL.md
+ *   /home/user/core_skills/my-skill/SKILL.md
+ *   skills/my-skill/SKILL.md
+ */
+function extractSkillNameFromPath(filePath) {
+    if (typeof filePath !== "string" || !filePath)
+        return null;
+    // Normalize common path prefixes
+    const normalized = filePath.replace(/^~\//, "/home/").replace(/\\/g, "/");
+    // Match: .../skills/<skillName>/SKILL.md  or  .../skills/<skillName>/...
+    // Also match: .../core_skills/<skillName>/SKILL.md
+    const match = normalized.match(/\/(?:core_)?skills\/([^/]+)\/SKILL\.md$/i);
+    return match ? match[1] : null;
+}
+/**
+ * Register the skills diagnostic event listener via after_tool_call hook.
+ *
+ * When openclaw fires a `skill.used` diagnostic event, the skill's SKILL.md
+ * is typically read by the model first.  We detect SKILL.md reads through
+ * the `after_tool_call` hook and write the skill name to the skills log.
+ */
+function registerSkillsDiagnosticHook(api) {
+    api.on("after_tool_call", async (event, _ctx) => {
+        if (event.toolName !== "read")
+            return;
+        const skillName = extractSkillNameFromPath(event.params?.path);
+        if (skillName) {
+            writeSkillUsage(skillName);
+        }
+    });
+}
 /**
  * Register the cron detection hook.
  *
@@ -177,11 +228,46 @@ function registerFullHooks(api) {
         envFilePath: "~/.openclaw/.xiaoyienv",
         timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
     });
-    const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
-    api.on("before_prompt_build", beforePromptBuildHandler);
+    const baseBeforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
+    // STEER INJECTION: merged into the before_prompt_build handler so it runs
+    // in the same hook registration call that we know already works (skill-retriever).
+    // This avoids any issues with separate api.on() registrations not being
+    // picked up by the global hook runner.
+    touchHookMarker("register_hook");
+    api.on("before_prompt_build", async (event, ctx) => {
+        touchHookMarker(`hook_fired_sessionKey=${ctx.sessionKey || "undefined"}`);
+        // Run skill-retriever first
+        const baseResult = await baseBeforePromptBuildHandler(event, ctx);
+        // Check for pending steer messages queued by bot.ts.
+        // Use ctx.sessionKey (NOT ctx.sessionId) because sessionId is
+        // OpenClaw's internal random UUID, while sessionKey contains the
+        // A2A conversationId and matches route.sessionKey from bot.ts.
+        const sessionKey = ctx.sessionKey;
+        if (!sessionKey)
+            return baseResult;
+        const queue = getSteerQueue();
+        const pending = queue.get(sessionKey);
+        if (!pending || pending.length === 0)
+            return baseResult;
+        // Drain pending steer messages
+        queue.delete(sessionKey);
+        const steerText = pending.splice(0).join("\n\n");
+        const steerAppend = `\n用户追加诉求：${steerText}`;
+        logger.log(`[STEER-HOOK] Injecting steer: sessionKey=${sessionKey} textLen=${steerText.length}`);
+        touchHookMarker(`steer_injected_sessionKey=${sessionKey}_len=${steerText.length}`);
+        // Merge steer appendContext with skill-retriever's result
+        const merged = { ...(baseResult ?? {}) };
+        if (merged.appendContext) {
+            merged.appendContext = `${merged.appendContext}\n\n${steerAppend}`;
+        }
+        else {
+            merged.appendContext = steerAppend;
+        }
+        return merged;
+    });
     registerSelfEvolutionToolResultNudge(api);
 }
-export default definePluginEntry({
+const pluginEntry = definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
     description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
@@ -208,6 +294,11 @@ export default definePluginEntry({
             registerSentinelHook(api);
             // Cron detection hook: marks toolCallIds from cron sessions
             registerCronDetectionHook(api);
+            // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools
+            registerCLIHook(api);
+            // Skills diagnostic hook: log skill usage (detected via SKILL.md reads)
+            registerSkillsDiagnosticHook(api);
         }
     },
 });
+export default pluginEntry;

package/dist/src/bot.d.ts

@@ -24,8 +24,3 @@ export interface HandleXYMessageParams {
  * Runtime is expected to be validated before calling this function.
  */
 export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
-/**
- * 由 provider.ts 在 wrapStreamFn 调用时触发。
- * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
- */
-export declare function notifyModelStreaming(sessionId: string): void;

package/dist/src/bot.js

@@ -15,6 +15,7 @@ import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { saveRuntimeInfo } from "./utils/runtime-manager.js";
 import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
 import { setCsplSteerContext } from "./cspl/steer-context.js";
+import { getSteerQueue } from "./steer-queue.js";
 import { registerTaskId, decrementTaskIdRef, hasActiveTask, } from "./task-manager.js";
 import { logger } from "./utils/logger.js";
 /**
@@ -241,18 +242,20 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新
-            log.log(`[BOT] Sending initial status update`);
-            void sendStatusUpdate({
-                config,
-                sessionId: parsed.sessionId,
-                taskId: parsed.taskId,
-                messageId: parsed.messageId,
-                text: "任务正在处理中，请稍候~",
-                state: "working",
-            }).catch((err) => {
-                log.error(`Failed to send initial status update:`, err);
-            });
+            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
+            if (!isUpdate) {
+                log.log(`[BOT] Sending initial status update`);
+                void sendStatusUpdate({
+                    config,
+                    sessionId: parsed.sessionId,
+                    taskId: parsed.taskId,
+                    messageId: parsed.messageId,
+                    text: "任务正在处理中，请稍候~",
+                    state: "working",
+                }).catch((err) => {
+                    log.error(`Failed to send initial status update:`, err);
+                });
+            }
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -277,49 +280,26 @@ export async function handleXYMessage(params) {
                 log.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
-        // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
-        // /steer 前缀由 dispatchSteerWhenReady 内部添加
-        if (isUpdate) {
-            // 立即释放 init gate——steer 不走 withReplyDispatcher 的 run()
-            // 回调，onInitComplete 永远不会被触发。如果不释放，后续消息
-            // 会被 globalDispatchInitGate 永久阻塞。
-            params.onInitComplete?.();
-            // Steer 也支持文件 —— 提取并下载，附带到 mediaPayload
-            const steerFileParts = extractFileParts(parsed.parts);
-            const steerDownloadedFiles = await downloadFilesFromParts(steerFileParts);
-            const steerMediaPayload = buildXYMediaPayload(steerDownloadedFiles);
-            if (steerFileParts.length > 0) {
-                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`);
-            }
-            await enqueueSteer({
-                sessionId: parsed.sessionId,
-                sessionKey: route.sessionKey,
-                steerText: textForAgent, // 原始文本，不带 /steer 前缀
-                mediaPayload: steerMediaPayload,
-                cfg,
-                runtime,
-                parsed,
-                route,
-                deviceType,
-            });
-            log.log(`[BOT] Steer queue completed`);
-            return;
-        }
-        // ── First message (non-steer) path below ──────────────────────
-        // 🔑 立即创建 streaming 信号——必须在文件下载等耗时操作之前，
-        // 否则 steer 消息的 dispatchSteerWhenReady 会找不到信号而跳过等待。
-        createStreamingSignal(parsed.sessionId);
-        // File download — only for real user messages, steer injections have no files
+        // ── Build message and dispatch via auto-reply pipeline ──────────
+        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
+        // detects active runs and handles steer injection natively — the channel
+        // does not need its own steer detection or polling logic.
+        // File download
         let mediaPayload = {};
-        if (!skipReg) {
+        if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
             const downloadedFiles = await downloadFilesFromParts(fileParts);
             log.log(`[BOT] Downloaded ${downloadedFiles.length} file(s)`);
             mediaPayload = buildXYMediaPayload(downloadedFiles);
         }
+        // 🔑 对于 steer 消息，将文件路径附加到消息文本中。
+        // auto-reply 管道的 steer 注入只携带 prompt 文本（followupRun.prompt），
+        // 不携带 mediaPayload，所以模型需要以文本形式看到附件路径。
+        if (isUpdate && mediaPayload.MediaPaths?.length) {
+            const fileHint = `\n【用户上传附件】：${JSON.stringify(mediaPayload.MediaPaths)}`;
+            textForAgent = `${textForAgent}${fileHint}`;
+            log.log(`[BOT] Steer: appended file paths to text`);
+        }
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
@@ -360,8 +340,44 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // 🔑 Streaming 信号已在上方创建（在文件下载之前）
-        const steerState = { steered: false };
+        // 🔑 Steer bypass: queue the message for agent_turn_prepare hook injection
+        // instead of going through dispatchReplyFromConfig which blocks on admitReplyTurn
+        // waiting for the active reply operation to complete.
+        //
+        // This covers BOTH:
+        //   1. Normal A2A steer (isUpdate && !skipReg) — user sends a message during
+        //      an active agent run
+        //   2. CSPL/self-evolution steer (isUpdate && skipReg) — hook-triggered
+        //      injection via tryInjectSteer. Without the bypass, CSPL steer would
+        //      deadlock: it runs inside the agent turn, so admitReplyTurn's
+        //      waitForIdle waits for the reply operation to finish, but the
+        //      operation is owned by the very same agent turn.
+        //
+        // The hook fires before every agent prompt build, so the steer text reaches
+        // the model on the next turn without blocking.
+        if (isUpdate) {
+            const steerQueue = getSteerQueue();
+            // Use route.sessionKey as the queue key. The hook looks up by
+            // ctx.sessionKey which is the same value (agent:main:direct:<peerId>).
+            // Do NOT use parsed.sessionId because ctx.sessionId in the hook
+            // context is OpenClaw's internal random UUID, not the A2A sessionId.
+            const queueKey = route.sessionKey;
+            const pending = steerQueue.get(queueKey) ?? [];
+            pending.push(textForAgent);
+            steerQueue.set(queueKey, pending);
+            log.log(`[BOT] Steer bypass: queued for agent_turn_prepare hook, queueKey=${queueKey}, sessionKey=${route.sessionKey}, queueDepth=${pending.length}, skipReg=${skipReg}`);
+            // Only decrement refCount when registerTaskId was called (non-skipReg).
+            // skipReg callers (CSPL/self-evolution) don't increment refCount.
+            if (!skipReg) {
+                decrementTaskIdRef(parsed.sessionId);
+            }
+            // Release the global dispatch init gate — steer doesn't need it.
+            params.onInitComplete?.();
+            return;
+        }
+        // 🔑 For steer messages, pre-set steered=true so the dispatcher skips final
+        // response and cleanup — the first message's dispatcher handles those.
+        const steerState = { steered: isUpdate };
         // 🔑 创建dispatcher
         log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
         // Cleanup: 必须在 onIdle 内部执行（参见 reply-dispatcher.ts 中 onIdleComplete 的注释）
@@ -371,7 +387,6 @@ export async function handleXYMessage(params) {
                 return;
             cleaned = true;
             log.log(`[BOT] Cleanup started`);
-            streamingSignals.delete(parsed.sessionId);
             decrementTaskIdRef(parsed.sessionId);
             log.log(`[BOT] Cleanup completed`);
         };
@@ -387,8 +402,9 @@ export async function handleXYMessage(params) {
         });
         // 🔑 注册 dispatcher 的 fallback taskId 更新函数，供 steer 路径调用
         dispatcherUpdaters.set(parsed.sessionId, updateFallbackTaskId);
-        // Steer injections don't need status intervals
-        if (!skipReg) {
+        // Steer messages don't need a status interval — the first message's
+        // dispatcher already has one running.
+        if (!isUpdate) {
             startStatusInterval();
         }
         // Build session context for AsyncLocalStorage
@@ -426,8 +442,9 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=false`);
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
+                    const isSteerDispatch = isUpdate && !skipReg;
+                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}, isSteer=${isSteerDispatch}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -435,7 +452,13 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
+                        // 区分 steer 成功（undefined）和 steer 失败/正常 run（有结果）
+                        if (result === undefined) {
+                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned undefined — steer injected successfully`);
+                        }
+                        else {
+                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, resultType=${typeof result}, isSteer=${isSteerDispatch}, steered=${steerState.steered}`);
+                        }
                         return result;
                     }
                     catch (dispatchErr) {
@@ -494,177 +517,12 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
+// ─────────────────────────────────────────────────────────────
+// Dispatcher updaters (cross-chain taskId bridging)
+// ─────────────────────────────────────────────────────────────
 // Use globalThis to survive module deduplication — provider.ts may load a
 // different copy of bot.ts, so a plain module-level Map would be two objects.
 const _g = globalThis;
-if (!_g.__xyStreamingSignals)
-    _g.__xyStreamingSignals = new Map();
-if (!_g.__xySteerQueues)
-    _g.__xySteerQueues = new Map();
 if (!_g.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();
-const streamingSignals = _g.__xyStreamingSignals;
-const steerQueues = _g.__xySteerQueues;
 const dispatcherUpdaters = _g.__xyDispatcherUpdaters;
-/**
- * 由 provider.ts 在 wrapStreamFn 调用时触发。
- * 这是模型 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();
-        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);
-    log.log(`[STEER-QUEUE] Streaming signal created`);
-    return signal;
-}
-/**
- * 将 steer 消息放入 per-session 串行队列。
- * 等待第一条消息的 streaming 信号（deliver 首次触发），然后 dispatch。
- * 多个 steer 按到达顺序串行处理，无需重试。
- */
-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) => {
-        log.error(`[STEER-QUEUE] Steer chain failed: ${String(err)}`);
-    }).finally(() => {
-        if (steerQueues.get(sessionId) === next) {
-            steerQueues.delete(sessionId);
-        }
-    });
-    return next;
-}
-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) {
-        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)) {
-                log.log(`[STEER-QUEUE] First message completed while waiting, skip steer`);
-                return;
-            }
-        }
-    }
-    if (signal) {
-        log.log(`[STEER-QUEUE] Waiting for streaming signal`);
-        await signal.promise;
-        log.log(`[STEER-QUEUE] Streaming signal received`);
-    }
-    else {
-        // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
-        // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
-        log.log(`[STEER-QUEUE] Signal never appeared after polling, skip steer to avoid collision`);
-        return;
-    }
-    // 2. 第一条消息已结束 → 放弃
-    if (!hasActiveTask(sessionId)) {
-        log.log(`[STEER-QUEUE] First message completed, skip steer`);
-        return;
-    }
-    // 3. 构建 dispatch 上下文并 dispatch /steer
-    const core = getXYRuntime();
-    const speaker = sessionId;
-    // 如果有文件附件，把路径拼到 steer 文本末尾，让模型通过工具读取
-    const mediaPaths = params.mediaPayload?.MediaPaths;
-    const fileHint = mediaPaths && mediaPaths.length > 0
-        ? `\n【用户上传附件】：${JSON.stringify(mediaPaths)}`
-        : "";
-    const steerCommand = `/steer ${steerText}${fileHint}`;
-    const messageBody = `${speaker}: ${steerCommand}`;
-    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
-    const body = core.channel.reply.formatAgentEnvelope({
-        channel: "xiaoyi-channel",
-        from: speaker,
-        timestamp: new Date(),
-        envelope: envelopeOptions,
-        body: messageBody,
-    });
-    const ctxPayload = core.channel.reply.finalizeInboundContext({
-        Body: body,
-        RawBody: steerCommand,
-        CommandBody: steerCommand,
-        From: sessionId,
-        To: sessionId,
-        SessionKey: params.route.sessionKey,
-        AccountId: params.route.accountId,
-        ChatType: "direct",
-        GroupSubject: undefined,
-        SenderName: sessionId,
-        SenderId: sessionId,
-        Provider: "xiaoyi-channel",
-        Surface: "xiaoyi-channel",
-        MessageSid: `xiaoyi_${params.parsed.taskId}_${params.deviceType}`,
-        Timestamp: Date.now(),
-        WasMentioned: false,
-        CommandAuthorized: true,
-        OriginatingChannel: "xiaoyi-channel",
-        OriginatingTo: sessionId,
-        ReplyToBody: undefined,
-        ...params.mediaPayload,
-    });
-    const steerState = { steered: true };
-    const { dispatcher, replyOptions } = createXYReplyDispatcher({
-        cfg: params.cfg,
-        runtime: params.runtime,
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        accountId: params.route.accountId,
-        steerState,
-    });
-    const sessionContext = {
-        config: resolveXYConfig(params.cfg),
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        agentId: params.route.accountId,
-        deviceType: params.deviceType,
-    };
-    log.log(`[STEER-QUEUE] Dispatching steer`);
-    await core.channel.reply.withReplyDispatcher({
-        dispatcher,
-        onSettled: () => {
-            log.log(`[STEER-QUEUE] Steer dispatch settled`);
-        },
-        run: () => {
-            return runWithSessionContext(sessionContext, async () => {
-                log.log(`[ALS-PROOF] bot entered steer dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=true`);
-                const result = await core.channel.reply.dispatchReplyFromConfig({
-                    ctx: ctxPayload,
-                    cfg: params.cfg,
-                    dispatcher,
-                    replyOptions,
-                });
-                log.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
-                return result;
-            });
-        },
-    });
-    log.log(`[STEER-QUEUE] Steer dispatch completed`);
-}

package/dist/src/channel.js

@@ -27,6 +27,7 @@ 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";
+import { invokeTool } from "./tools/invoke.js";
 const ALL_TOOLS = [
     locationTool,
     discoverCrossDevicesTool,
@@ -50,6 +51,7 @@ const ALL_TOOLS = [
     loginTokenTool,
     agentAsSkillTool,
     checkPluginPrivilegeTool,
+    invokeTool,
 ];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.

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

@@ -3,9 +3,9 @@
  */
 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 { getConfig } from './config.js';
+import { DEFAULT_HTTPS_PORT, 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');
@@ -23,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,
@@ -70,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);
@@ -79,18 +80,15 @@ 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);
+    // 确保 uid 存在于消息体中（从 config 注入）
+    const payloadWithUid = { ...payload, uid: config.uid };
+    const httpBody = JSON.stringify(payloadWithUid);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
-    logger.log(`[SENTINEL HOOK] callApi: action=${action}, x-hag-trace-id=${sessionId}, url=${apiUrl}`);
+    logger.log(`[SENTINEL HOOK] callApi URL: ${apiUrl}`);
+    logger.log(`[SENTINEL HOOK] callApi request body: ${httpBody}`);
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {

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;