@workclaw/openclaw-workclaw 1.0.19 → 1.0.23

package/dist/src/gateway/message-dispatcher.js

@@ -5,7 +5,7 @@ import { parseWorkClawMessage } from "./message-context.js";
 import { buildInboundContext } from "./message-context.js";
 import { handleAgentCreated, handleAgentUpdated, handleAgentDeleted } from "./agent-handlers.js";
 import { saveOpenConversationId, initWorkclawAgent } from "./config-writer.js";
-import { getWorkclawWsConnection, setLastInboundAt } from "../runtime.js";
+import { getWorkclawWsConnection } from "../runtime.js";
 import { getWorkclawRuntime } from "../runtime.js";
 import { sendMessageWorkclaw } from "../outbound/index.js";
 import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from "../accounts.js";
@@ -13,8 +13,8 @@ import { getWorkclawAccessToken, getWorkclawModelConfigByAppKey } from "../conne
 import { setToolContext } from "../runtime.js";
 import { handleSkillsEvent } from "./skills-handler.js";
 import { handleToolsListEvent as doHandleToolsListEvent } from "./tools-list-handler.js";
-import { handleSkillsListEvent as doHandleSkillsListEvent } from "./skills-list-handler.js";
 import { request } from "undici";
+import { resolveNativeCommandSessionTargets, maybeResolveTextAlias } from "openclaw/plugin-sdk/command-auth";
 /** Log an error safely */
 function logError(log, context, err) {
     const errAny = err;
@@ -153,8 +153,9 @@ async function handleSkillsListEvent(ctx, result) {
     if (!result.eventData)
         return;
     try {
+        const { handleSkillsListEvent } = await import('./skills-handler.js');
         const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
+            baseUrl: baseConfig.baseUrl || '',
             websocketUrl: baseConfig.websocketUrl,
             appKey: baseConfig.appKey,
             appSecret: baseConfig.appSecret,
@@ -162,351 +163,410 @@ async function handleSkillsListEvent(ctx, result) {
             allowInsecureTls: baseConfig.allowInsecureTls,
             requestTimeout: baseConfig.requestTimeout,
         };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await doHandleSkillsListEvent(result.eventData, connConfig.baseUrl, token, log);
-    }
-    catch (err) {
-        logError(log, "handleSkillsListEvent failed", err);
     }
-}
-async function handleInitAgentEvent(ctx, result) {
-    const { accountId, cfg, baseConfig, log } = ctx;
-    const initStartedAt = Date.now();
-    const eventData = result.eventData;
-    if (!eventData) {
-        log?.warn?.(`init_agent received but no data`);
-        return;
-    }
-    log?.info?.(`init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`);
-    const connConfig = {
-        baseUrl: baseConfig.baseUrl || "",
-        websocketUrl: baseConfig.websocketUrl,
-        appKey: baseConfig.appKey,
-        appSecret: baseConfig.appSecret,
-        localIp: baseConfig.localIp,
-        allowInsecureTls: baseConfig.allowInsecureTls,
-        requestTimeout: baseConfig.requestTimeout,
-    };
-    // Fetch apiKey and init agent config in one write
-    try {
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig);
-        const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : "missing";
-        log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`);
-        const agentId = String(eventData?.id || eventData?.agentId || "");
-        const userId = String(eventData?.futureId || eventData?.userId || "");
-        await initWorkclawAgent({ apiKey, agentId, userId, accountId: "default" }, cfg, log);
-        log?.info?.(`init_agent config saved elapsedMs=${Date.now() - initStartedAt}`);
-    }
-    catch (err) {
-        logError(log, "init_agent failed", err);
+    finally {
     }
-    log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`);
-}
-async function handleAgentMessage(ctx, data, result) {
-    const { accountId, account, cfg, accountConfig, log } = ctx;
-    const { message } = result;
-    if (!message)
-        return;
-    // 这里的msgAgentId是云平台的agentId
-    const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message;
-    // Resolve account from message
-    let messageAccountId = accountId;
-    let messageAccount = account;
-    if (userId && msgAgentId) {
-        const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId));
-        if (resolvedAccountId) {
-            const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
-            messageAccountId = resolvedAccountId;
-            messageAccount = resolved;
-            log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`);
-        }
-        else if (String(msgAgentId) !== String(accountConfig.agentId)) {
-            log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`);
+    async function handleInitAgentEvent(ctx, result) {
+        const { accountId, cfg, baseConfig, log } = ctx;
+        const initStartedAt = Date.now();
+        const eventData = result.eventData;
+        if (!eventData) {
+            log?.warn?.(`init_agent received but no data`);
             return;
         }
-    }
-    const resolvedAccountConfig = messageAccount.config;
-    const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
-    // Save openConversationId if new
-    if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
+        log?.info?.(`init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`);
+        const connConfig = {
+            baseUrl: baseConfig.baseUrl || "",
+            websocketUrl: baseConfig.websocketUrl,
+            appKey: baseConfig.appKey,
+            appSecret: baseConfig.appSecret,
+            localIp: baseConfig.localIp,
+            allowInsecureTls: baseConfig.allowInsecureTls,
+            requestTimeout: baseConfig.requestTimeout,
+        };
+        // Fetch apiKey and init agent config in one write
         try {
-            await saveOpenConversationId(messageAccountId, userId, openConversationId, cfg, log);
-            log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`);
+            const tokenCacheKey = baseConfig.appKey || accountId;
+            const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig);
+            const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : "missing";
+            log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`);
+            const agentId = String(eventData?.id || eventData?.agentId || "");
+            const userId = String(eventData?.futureId || eventData?.userId || "");
+            await initWorkclawAgent({ apiKey, agentId, userId, accountId: "default" }, cfg, log);
+            log?.info?.(`init_agent config saved elapsedMs=${Date.now() - initStartedAt}`);
         }
         catch (err) {
-            logError(log, "saveOpenConversationId failed", err);
+            logError(log, "init_agent failed", err);
         }
+        log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`);
     }
-    const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
-    const to = userId;
-    const bodyText = text || data;
-    if (!bodyText) {
-        log?.warn?.(`Empty body, ignoring`);
-        return;
-    }
-    // Route via bindings
-    const bindings = cfg?.bindings ?? [];
-    let targetAgentId = "default";
-    const matchedBinding = bindings.find((binding) => {
-        const match = binding?.match;
-        if (!match || match.channel !== "openclaw-workclaw")
-            return false;
-        return match.accountId === messageAccountId || match.accountId === "*";
-    });
-    if (matchedBinding) {
-        targetAgentId = matchedBinding.agentId;
-        log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`);
-    }
-    if (!targetAgentId) {
-        log?.warn?.(`Missing target, ignoring`);
-        return;
-    }
-    // 构建用于解析 sessionKey 的消息对象
-    // to = agentId (智能体/机器人), from = userId (用户)
-    const attachments = message.attachments;
-    const inboundMessage = {
-        text: bodyText,
-        to: to,
-        from: userId,
-        chatType: "dm",
-        messageId: parsedMessageId,
-        rawPayload: data,
-        timestamp: Date.now(),
-        attachments: attachments,
-    };
-    log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}`);
-    const pluginRuntime = getWorkclawRuntime();
-    // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
-    const finalized = await buildInboundContext(inboundMessage, messageAccountId, messageAccount.config, targetAgentId, pluginRuntime, true, log);
-    // 维护当前工具名称状态
-    let currentToolName = null;
-    // 追踪 final 是否已投递（框架在流式输出时会 drop final，需要手动补发 last: true）
-    let finalDelivered = false;
-    // 发送工具消息的辅助函数
-    const sendToolMessage = async (text, isStart = false) => {
+    async function handleCronTaskEvent(ctx, result) {
+        const { accountId, baseConfig, log } = ctx;
+        if (!result.cronTaskEvent)
+            return;
         try {
-            await sendMessageWorkclaw({
-                cfg,
-                to: to,
-                text,
-                accountId: messageAccountId,
-                openConversationId: resolvedOpenConversationId,
-                agentId: msgAgentIdResolved,
-                replyToMessageId: parsedMessageId,
-                last: false,
-            });
+            const { handleCronTaskEvent } = await import('./cron-tasks-handler.js');
+            const connConfig = {
+                baseUrl: baseConfig.baseUrl || '',
+                websocketUrl: baseConfig.websocketUrl,
+                appKey: baseConfig.appKey,
+                appSecret: baseConfig.appSecret,
+                localIp: baseConfig.localIp,
+                allowInsecureTls: baseConfig.allowInsecureTls,
+                requestTimeout: baseConfig.requestTimeout,
+            };
+            const tokenCacheKey = baseConfig.appKey || accountId;
+            const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
+            await handleCronTaskEvent(result.cronTaskEvent, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
         }
         catch (err) {
-            logError(log, isStart ? "Tool start message send failed" : "Tool result message send failed", err);
+            logError(log, 'handleCronTaskEvent failed', err);
         }
-    };
-    await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-        ctx: finalized,
-        cfg,
-        replyOptions: {
-            onAgentRunStart(runId) {
-                // 保存 runId 和 ctx 的关联，供 hook 使用
-                setToolContext(runId, {
-                    target: targetAgentId,
-                    replyToMessageId: parsedMessageId,
-                    openConversationId: resolvedOpenConversationId,
+    }
+    async function handleAgentMessage(ctx, data, result) {
+        const { accountId, account, cfg, accountConfig, log } = ctx;
+        const { message } = result;
+        if (!message)
+            return;
+        // 这里的msgAgentId是云平台的agentId
+        const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message;
+        // Resolve account from message
+        let messageAccountId = accountId;
+        let messageAccount = account;
+        if (userId && msgAgentId) {
+            const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId));
+            if (resolvedAccountId) {
+                const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
+                messageAccountId = resolvedAccountId;
+                messageAccount = resolved;
+                log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`);
+            }
+            else if (String(msgAgentId) !== String(accountConfig.agentId)) {
+                log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`);
+                return;
+            }
+        }
+        const resolvedAccountConfig = messageAccount.config;
+        const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
+        // Save openConversationId if new
+        if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
+            try {
+                await saveOpenConversationId(messageAccountId, userId, openConversationId, cfg, log);
+                log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`);
+            }
+            catch (err) {
+                logError(log, "saveOpenConversationId failed", err);
+            }
+        }
+        const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
+        const to = userId;
+        const bodyText = text || data;
+        if (!bodyText) {
+            log?.warn?.(`Empty body, ignoring`);
+            return;
+        }
+        // Route via bindings
+        const bindings = cfg?.bindings ?? [];
+        let targetAgentId = "default";
+        const matchedBinding = bindings.find((binding) => {
+            const match = binding?.match;
+            if (!match || match.channel !== "openclaw-workclaw")
+                return false;
+            return match.accountId === messageAccountId || match.accountId === "*";
+        });
+        if (matchedBinding) {
+            targetAgentId = matchedBinding.agentId;
+            log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`);
+        }
+        if (!targetAgentId) {
+            log?.warn?.(`Missing target, ignoring`);
+            return;
+        }
+        // 构建用于解析 sessionKey 的消息对象
+        // to = agentId (智能体/机器人), from = userId (用户)
+        const attachments = message.attachments;
+        const inboundMessage = {
+            text: bodyText,
+            to: to,
+            from: userId,
+            chatType: "dm",
+            messageId: parsedMessageId,
+            rawPayload: data,
+            timestamp: Date.now(),
+            attachments: attachments,
+        };
+        log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}, rawPayload=${data.substring(0, 300)}`);
+        const pluginRuntime = getWorkclawRuntime();
+        // 检测是否是框架命令（如 /new）
+        const textForCommandCheck = bodyText?.replace(/^\[引用[^\]]*\]\s*/, "").trim() || "";
+        const resolvedCommand = maybeResolveTextAlias(textForCommandCheck, messageAccount.config);
+        const isFrameworkCommand = resolvedCommand !== null;
+        if (isFrameworkCommand) {
+            log?.info?.(`[DELIVER] Framework command detected: ${bodyText}, will set CommandSource=native`);
+        }
+        // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
+        const finalized = await buildInboundContext(inboundMessage, messageAccountId, messageAccount.config, targetAgentId, pluginRuntime, true, log);
+        // 如果是框架命令，设置 CommandSource 等字段，让 OpenClaw 框架识别为原生命令
+        if (isFrameworkCommand) {
+            const targetSessionKey = finalized.SessionKey;
+            const { sessionKey: commandSessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
+                agentId: targetAgentId,
+                sessionPrefix: "openclaw-workclaw:new",
+                userId: String(userId ?? ""),
+                targetSessionKey,
+            });
+            finalized.SessionKey = commandSessionKey;
+            finalized.CommandTargetSessionKey = commandTargetSessionKey;
+            finalized.CommandSource = "native";
+            finalized.CommandAuthorized = true;
+            log?.info?.(`[DELIVER] Set CommandSource=native, commandSessionKey=${commandSessionKey}, targetSessionKey=${targetSessionKey}`);
+        }
+        // 维护当前工具名称状态
+        let currentToolName = null;
+        // 追踪 final 是否已投递（框架在流式输出时会 drop final，需要手动补发 last: true）
+        let finalDelivered = false;
+        // 追踪是否有文本被 deliver 过
+        let textDelivered = false;
+        // 发送工具消息的辅助函数
+        const sendToolMessage = async (text, isStart = false) => {
+            try {
+                await sendMessageWorkclaw({
+                    cfg,
+                    to: to,
+                    text,
                     accountId: messageAccountId,
-                    agentId: String(msgAgentIdResolved),
-                    sessionKey: finalized.SessionKey || "",
+                    openConversationId: resolvedOpenConversationId,
+                    agentId: msgAgentIdResolved,
+                    replyToMessageId: parsedMessageId,
+                    last: false,
                 });
-                log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
-            },
-            /*onToolStart(payload) {
-                log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
-                if (payload.phase === "start") {
-                    currentToolName = payload.name ?? null;
-                    const hint = getToolStartHint(currentToolName);
-                    log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
-                    sendToolMessage(hint, true).catch((err) => {
-                        logError(log, "Tool start hint send failed", err);
+            }
+            catch (err) {
+                logError(log, isStart ? "Tool start message send failed" : "Tool result message send failed", err);
+            }
+        };
+        await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: finalized,
+            cfg,
+            replyOptions: {
+                onAgentRunStart(runId) {
+                    // 保存 runId 和 ctx 的关联，供 hook 使用
+                    setToolContext(runId, {
+                        target: targetAgentId,
+                        replyToMessageId: parsedMessageId,
+                        openConversationId: resolvedOpenConversationId,
+                        accountId: messageAccountId,
+                        agentId: String(msgAgentIdResolved),
+                        sessionKey: finalized.SessionKey || "",
                     });
-                }
-            }*/
-        },
-        dispatcherOptions: {
-            deliver: async (payload, info) => {
-                // 记录每次 deliver 调用，帮助调试 info.kind 问题
-                log?.info?.(`[DELIVER] deliver called: info.kind=${info?.kind}, payload.text=${String(payload?.text ?? "").substring(0, 100)}`);
-                const resolvedReplyToId = payload?.replyToId || parsedMessageId;
-                let textOut = String(payload.text ?? payload.body ?? "");
-                const target = to || String(payload.to ?? "");
-                if (!target) {
-                    log?.warn?.(`Skipping reply: no target`);
-                    return;
-                }
-                if (!textOut.trim()) {
-                    log?.warn?.(`Empty reply text, skipping`);
-                    return;
-                }
-                if (info?.kind === "tool")
-                    return;
-                // 处理工具类型的 deliver
-                /*if (info?.kind === "tool") {
-                    // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
-                    const toolText = payload.text ?? "";
-                    if (toolText.trim()) {
-                        // 使用 formattedToolOutput 格式发送
-                        try {
-                            await sendMessageWorkclaw({
-                                cfg,
-                                to: targetAgentId,
-                                text: JSON.stringify({
-                                    name: currentToolName || "Unknown",
-                                    content: toolText,
-                                    state: "result",
-                                }),
-                                msgType: "26",
-                                accountId: messageAccountId,
-                                openConversationId: resolvedOpenConversationId,
-                                agentId: msgAgentIdResolved,
-                                replyToMessageId: parsedMessageId,
-                            });
-                        } catch (err) {
-                            logError(log, "Tool result send failed", err);
-                        }
+                    log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
+                },
+                /*onToolStart(payload) {
+                    log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
+                    if (payload.phase === "start") {
+                        currentToolName = payload.name ?? null;
+                        const hint = getToolStartHint(currentToolName);
+                        log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
+                        sendToolMessage(hint, true).catch((err) => {
+                            logError(log, "Tool start hint send failed", err);
+                        });
                     }
-                    return;
                 }*/
-                // final 时清空工具状态
-                if (info?.kind === "final") {
-                    currentToolName = null;
-                    finalDelivered = true;
-                    log?.info?.(`[DELIVER] final received, cleared currentToolName`);
-                }
-                // 明确设置 last：final 时为 true，否则为 false（显式转换，避免 undefined）
-                const isFinal = info?.kind === "final";
-                const isLast = isFinal ? true : false;
-                log?.info?.(`[DELIVER] is last: ${isLast} (info.kind=${info?.kind})`);
-                try {
-                    const result = await sendMessageWorkclaw({
-                        cfg, to: target, text: textOut,
-                        accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                        agentId: msgAgentIdResolved, replyToMessageId: resolvedReplyToId,
-                        last: isLast,
-                    });
-                    log?.info?.(`Reply sent messageId=${result.messageId}`);
-                }
-                catch (err) {
-                    logError(log, "Reply send failed", err);
-                    throw err;
-                }
             },
-        },
-    });
-    // 框架在流式输出时会 drop final payload，检测到时应手动补发 last: true
-    if (!finalDelivered) {
-        log?.warn?.(`[DELIVER] final was dropped by framework, sending last: true`);
-        try {
-            // 发送一个空格作为占位内容，确保 last: true 能被服务端接受
-            await sendMessageWorkclaw({
-                cfg, to: to || String(userId || ""),
-                text: "",
-                accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
-                last: true,
-            });
+            dispatcherOptions: {
+                deliver: async (payload, info) => {
+                    // 记录每次 deliver 调用，帮助调试 info.kind 问题
+                    log?.info?.(`[DELIVER] deliver called: info.kind=${info?.kind}, payload.text=${String(payload?.text ?? "").substring(0, 100)}`);
+                    const resolvedReplyToId = payload?.replyToId || parsedMessageId;
+                    let textOut = String(payload.text ?? payload.body ?? "");
+                    const target = to || String(payload.to ?? "");
+                    if (!target) {
+                        log?.warn?.(`Skipping reply: no target`);
+                        return;
+                    }
+                    if (!textOut.trim()) {
+                        log?.warn?.(`Empty reply text, skipping`);
+                        return;
+                    }
+                    if (info?.kind === "tool")
+                        return;
+                    // 处理工具类型的 deliver
+                    /*if (info?.kind === "tool") {
+                        // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
+                        const toolText = payload.text ?? "";
+                        if (toolText.trim()) {
+                            // 使用 formattedToolOutput 格式发送
+                            try {
+                                await sendMessageWorkclaw({
+                                    cfg,
+                                    to: targetAgentId,
+                                    text: JSON.stringify({
+                                        name: currentToolName || "Unknown",
+                                        content: toolText,
+                                        state: "result",
+                                    }),
+                                    msgType: "26",
+                                    accountId: messageAccountId,
+                                    openConversationId: resolvedOpenConversationId,
+                                    agentId: msgAgentIdResolved,
+                                    replyToMessageId: parsedMessageId,
+                                });
+                            } catch (err) {
+                                logError(log, "Tool result send failed", err);
+                            }
+                        }
+                        return;
+                    }*/
+                    // final 时清空工具状态
+                    if (info?.kind === "final") {
+                        currentToolName = null;
+                        finalDelivered = true;
+                        log?.info?.(`[DELIVER] final received, cleared currentToolName`);
+                    }
+                    // 明确设置 last：final 时为 true，否则为 false（显式转换，避免 undefined）
+                    const isFinal = info?.kind === "final";
+                    const isLast = isFinal ? true : false;
+                    log?.info?.(`[DELIVER] is last: ${isLast} (info.kind=${info?.kind})`);
+                    try {
+                        const result = await sendMessageWorkclaw({
+                            cfg, to: target, text: textOut,
+                            accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
+                            agentId: msgAgentIdResolved, replyToMessageId: resolvedReplyToId,
+                            last: isLast,
+                        });
+                        textDelivered = true;
+                        log?.info?.(`Reply sent messageId=${result.messageId}`);
+                    }
+                    catch (err) {
+                        logError(log, "Reply send failed", err);
+                        throw err;
+                    }
+                },
+            },
+        });
+        // 原始消息是命令但 AI 没有回复文本时，发送"命令已执行"确认
+        if (!textDelivered && bodyText?.startsWith('/')) {
+            log?.info?.(`[DELIVER] command ${bodyText} executed with no text reply, sending confirmation`);
+            try {
+                await sendMessageWorkclaw({
+                    cfg, to: to || String(userId || ""),
+                    text: `${bodyText} 已执行`,
+                    accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
+                    agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
+                    last: false,
+                });
+            }
+            catch (err) {
+                logError(log, "Command confirmation send failed", err);
+            }
         }
-        catch (err) {
-            // 服务端可能拒绝空内容的 last 信号，忽略即可
-            const errStr = String(err);
-            if (errStr.includes("content can't be empty")) {
-                log?.info?.(`[DELIVER] last signal skipped (empty content not supported)`);
+        // 框架在流式输出时会 drop final payload，检测到时应手动补发 last: true
+        if (!finalDelivered) {
+            log?.warn?.(`[DELIVER] final was dropped by framework, sending last: true`);
+            try {
+                // 发送一个空格作为占位内容，确保 last: true 能被服务端接受
+                await sendMessageWorkclaw({
+                    cfg, to: to || String(userId || ""),
+                    text: "",
+                    accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
+                    agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
+                    last: true,
+                });
             }
-            else {
-                logError(log, "Final/last signal send failed", err);
+            catch (err) {
+                // 服务端可能拒绝空内容的 last 信号，忽略即可
+                const errStr = String(err);
+                if (errStr.includes("content can't be empty")) {
+                    log?.info?.(`[DELIVER] last signal skipped (empty content not supported)`);
+                }
+                else {
+                    logError(log, "Final/last signal send failed", err);
+                }
             }
         }
     }
-}
-// ---------------------------------------------------------------------------
-// Main dispatcher
-// ---------------------------------------------------------------------------
-export async function dispatchWorkclawMessage(data, ctx) {
-    const { log } = ctx;
-    const rawHasAuthToken = data.includes("authToken") ||
-        data.toLowerCase().includes("authorization") ||
-        data.toLowerCase().includes("bearer ");
-    const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data;
-    /*log?.info?.(
-        `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
-    );*/
-    const result = parseWorkClawMessage(data, log);
-    if (!result) {
-        log?.warn?.(`Failed to parse message`);
-        return;
-    }
-    log?.info?.(`Message type=${result.type}`);
-    // 更新上次消息时间（始终用 accountId，因为每个账号的入站时间需要独立追踪）
-    const { accountId } = ctx;
-    if (accountId) {
-        setLastInboundAt(accountId, Date.now());
-    }
-    switch (result.type) {
-        case "ping":
-            await handlePing(ctx, result);
-            return;
-        case "disconnect":
-            await handleDisconnect(ctx);
-            return;
-        case "agent_created":
-        case "agent_updated":
-        case "agent_deleted":
-            await handleAgentEvent(ctx, result);
-            return;
-        case "skills_event":
-            await handleSkillsProcessingEvent(ctx, result);
-            return;
-        case "tools_list":
-            await handleToolsListEvent(ctx, result);
-            return;
-        case "skills_list":
-            await handleSkillsListEvent(ctx, result);
-            return;
-        case "init_agent":
-            await handleInitAgentEvent(ctx, result);
-            return;
-        case "ignored":
-            log?.info?.(`Ignoring message type=${result.type}`);
+    // ---------------------------------------------------------------------------
+    // Main dispatcher
+    // ---------------------------------------------------------------------------
+    export async function dispatchWorkclawMessage(data, ctx) {
+        const { log } = ctx;
+        const rawHasAuthToken = data.includes("authToken") ||
+            data.toLowerCase().includes("authorization") ||
+            data.toLowerCase().includes("bearer ");
+        const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data;
+        /*log?.info?.(
+            `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
+        );*/
+        const result = parseWorkClawMessage(data, log);
+        if (!result) {
+            log?.warn?.(`Failed to parse message`);
             return;
-        case "agent_message":
-            await handleAgentMessage(ctx, data, result);
-            return;
-        default:
-            log?.info?.(`Unknown message type: ${result.type}, ignoring`);
-    }
-}
-// 创建成功回调
-async function handleAgentCreatedMessage(baseConfig, agentId, accountId, log) {
-    // 通知
-    try {
-        const callbackUrl = `${baseConfig.baseUrl}/open-apis/instance/agent-created/status`;
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const callbackData = {
-            "agentId": agentId,
-            "success": true
-        };
-        log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`);
-        const token = await getWorkclawAccessToken(tokenCacheKey, baseConfig);
-        const response = await request(callbackUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${token}`,
-            },
-            body: JSON.stringify(callbackData),
-        });
-        const responseBody = await response.body.text();
-        log?.info?.(`[AgentCreated] Callback API response: status=${response.statusCode}, body=${responseBody}`);
+        }
+        log?.info?.(`Message type=${result.type}`);
+        switch (result.type) {
+            case 'ping':
+                await handlePing(ctx, result);
+                return;
+            case 'disconnect':
+                await handleDisconnect(ctx);
+                return;
+            case 'agent_created':
+            case 'agent_updated':
+            case 'agent_deleted':
+                await handleAgentEvent(ctx, result);
+                return;
+            case 'skills_event':
+                await handleSkillsProcessingEvent(ctx, result);
+                return;
+            case 'tools_list':
+                await handleToolsListEvent(ctx, result);
+                return;
+            case 'skills_list':
+                await handleSkillsListEvent(ctx, result);
+                return;
+            case 'init_agent':
+                await handleInitAgentEvent(ctx, result);
+                return;
+            case 'cron_task_event':
+                await handleCronTaskEvent(ctx, result);
+                return;
+            case 'ignored':
+                log?.info?.(`Ignoring message type=${result.type}`);
+                return;
+            case 'agent_message':
+                await handleAgentMessage(ctx, data, result);
+                return;
+            default:
+                log?.info?.(`Unknown message type: ${result.type}, ignoring`);
+        }
     }
-    catch (callbackErr) {
-        // 接口调用失败不影响主流程，只记录错误
-        log?.error?.(`[AgentCreated] Callback API failed: ${String(callbackErr)}`);
+    // 创建成功回调
+    async function handleAgentCreatedMessage(baseConfig, agentId, accountId, log) {
+        // 通知
+        try {
+            const base = baseConfig.baseUrl.replace(/\/$/, ""); // 去掉末尾多余的 /
+            const callbackUrl = `${base}/open-apis/instance/agent-created/status`;
+            const tokenCacheKey = baseConfig.appKey || accountId;
+            const callbackData = {
+                "agentId": agentId,
+                "success": true
+            };
+            log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`);
+            const token = await getWorkclawAccessToken(tokenCacheKey, baseConfig);
+            const response = await request(callbackUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${token}`,
+                },
+                body: JSON.stringify(callbackData),
+            });
+            const responseBody = await response.body.text();
+            log?.info?.(`[AgentCreated] Callback API response: status=${response.statusCode}, body=${responseBody}`);
+        }
+        catch (callbackErr) {
+            // 接口调用失败不影响主流程，只记录错误
+            log?.error?.(`[AgentCreated] Callback API failed: ${String(callbackErr)}`);
+        }
     }
 }