@yanhaidao/wecom 2.4.120 → 2.5.110

package/dist/src/capability/bot/stream-orchestrator.js

@@ -0,0 +1,318 @@
+import { pathToFileURL } from "node:url";
+import { resolveWecomMediaMaxBytes, shouldRejectWecomDefaultRoute } from "../../config/index.js";
+import { ensureDynamicAgentListed, generateAgentId, shouldUseDynamicAgent } from "../../dynamic-agent.js";
+import { getWecomRuntime } from "../../runtime.js";
+import { buildWecomUnauthorizedCommandPrompt, resolveWecomCommandAuthorization } from "../../shared/command-auth.js";
+import { looksLikeSendLocalFileIntent, processBotInboundMessage } from "../../transport/bot-webhook/inbound-normalizer.js";
+import { resolveWecomSenderUserId } from "../../transport/bot-webhook/message-shape.js";
+import { buildWecomBotDispatchConfig } from "./dispatch-config.js";
+import { sendBotFallbackPromptNow } from "./fallback-delivery.js";
+import { finalizeBotStream } from "./stream-finalizer.js";
+import { handleDirectLocalPathIntent } from "./local-path-delivery.js";
+import { stageWecomInboundMediaForSession } from "./sandbox-media.js";
+import { createBotReplyDispatcher } from "./stream-delivery.js";
+export function createBotStreamOrchestrator(params) {
+    const { streamStore, recordBotOperationalEvent } = params;
+    const logVerbose = (target, message) => {
+        const should = target.core.logging?.shouldLogVerbose?.() ??
+            (() => {
+                try {
+                    return getWecomRuntime().logging.shouldLogVerbose();
+                }
+                catch {
+                    return false;
+                }
+            })();
+        if (!should)
+            return;
+        target.runtime.log?.(`[wecom] ${message}`);
+    };
+    const logInfo = (target, message) => {
+        target.runtime.log?.(`[wecom] ${message}`);
+    };
+    const truncateUtf8Bytes = (text, maxBytes) => {
+        const buf = Buffer.from(text, "utf8");
+        if (buf.length <= maxBytes)
+            return text;
+        return buf.subarray(buf.length - maxBytes).toString("utf8");
+    };
+    const computeTaskKey = (target, msg) => {
+        const msgid = msg.msgid ? String(msg.msgid) : "";
+        if (!msgid)
+            return undefined;
+        const aibotid = String(msg.aibotid ?? "unknown").trim() || "unknown";
+        return `bot:${target.account.accountId}:${aibotid}:${msgid}`;
+    };
+    async function flushPending(pending) {
+        const { streamId, target, msg, contents, msgids, conversationKey, batchKey } = pending;
+        const mergedContents = contents.filter((c) => c.trim()).join("\n").trim();
+        let core = null;
+        try {
+            core = getWecomRuntime();
+        }
+        catch (err) {
+            logVerbose(target, `flush pending: runtime not ready: ${String(err)}`);
+            streamStore.markFinished(streamId);
+            logInfo(target, `queue: runtime not ready，结束批次并推进 streamId=${streamId}`);
+            streamStore.onStreamFinished(streamId);
+            return;
+        }
+        if (!core)
+            return;
+        streamStore.markStarted(streamId);
+        const enrichedTarget = { ...target, core };
+        logInfo(target, `flush pending: start batch streamId=${streamId} batchKey=${batchKey} conversationKey=${conversationKey} mergedCount=${contents.length}`);
+        logVerbose(target, `防抖结束: 开始处理聚合消息 数量=${contents.length} streamId=${streamId}`);
+        startAgentForStream({
+            target: enrichedTarget,
+            accountId: target.account.accountId,
+            msg,
+            streamId,
+            mergedContents: contents.length > 1 ? mergedContents : undefined,
+            mergedMsgids: msgids.length > 1 ? msgids : undefined,
+        }).catch((err) => {
+            streamStore.updateStream(streamId, (state) => {
+                state.error = err instanceof Error ? err.message : String(err);
+                state.content = state.content || `Error: ${state.error}`;
+                state.finished = true;
+            });
+            target.runtime.error?.(`[${target.account.accountId}] wecom agent failed (处理失败): ${String(err)}`);
+            streamStore.onStreamFinished(streamId);
+        });
+    }
+    async function startAgentForStream(params) {
+        const { target, msg, streamId } = params;
+        const core = target.core;
+        const config = target.config;
+        const account = target.account;
+        const userId = resolveWecomSenderUserId(msg) || "unknown";
+        const chatType = msg.chattype === "group" ? "group" : "direct";
+        const chatId = msg.chattype === "group" ? (msg.chatid?.trim() || "unknown") : userId;
+        const taskKey = computeTaskKey(target, msg);
+        const aibotid = String(msg.aibotid ?? "").trim() || undefined;
+        streamStore.updateStream(streamId, (s) => {
+            s.userId = userId;
+            s.chatType = chatType;
+            s.chatId = chatId;
+            s.taskKey = taskKey;
+            s.aibotid = aibotid;
+        });
+        let { body: rawBody, media } = await processBotInboundMessage({
+            target,
+            msg,
+            recordOperationalIssue: (event) => recordBotOperationalEvent(target, event),
+        });
+        if (params.mergedContents) {
+            rawBody = Array.isArray(params.mergedContents) ? params.mergedContents.join("\n") : params.mergedContents;
+        }
+        const handledLocalPath = await handleDirectLocalPathIntent({
+            streamStore,
+            target,
+            streamId,
+            rawBody,
+            userId,
+            chatType,
+            logVerbose,
+            looksLikeSendLocalFileIntent,
+        });
+        if (handledLocalPath)
+            return;
+        let mediaPath;
+        let mediaType;
+        const mediaFilename = media?.filename;
+        if (media) {
+            try {
+                const maxBytes = resolveWecomMediaMaxBytes(target.config, target.account.accountId);
+                const saved = await core.channel.media.saveMediaBuffer(media.buffer, media.contentType, "inbound", maxBytes, media.filename);
+                mediaPath = saved.path;
+                mediaType = saved.contentType;
+                logVerbose(target, `saved inbound media to ${mediaPath} (${mediaType})`);
+            }
+            catch (err) {
+                target.runtime.error?.(`Failed to save inbound media: ${String(err)}`);
+            }
+        }
+        const route = core.channel.routing.resolveAgentRoute({
+            cfg: config,
+            channel: "wecom",
+            accountId: account.accountId,
+            peer: { kind: chatType === "group" ? "group" : "direct", id: chatId },
+        });
+        const useDynamicAgent = shouldUseDynamicAgent({
+            chatType: chatType === "group" ? "group" : "dm",
+            senderId: userId,
+            config,
+        });
+        if (shouldRejectWecomDefaultRoute({ cfg: config, matchedBy: route.matchedBy, useDynamicAgent })) {
+            const prompt = `当前账号（${account.accountId}）未绑定 OpenClaw Agent，已拒绝回退到默认主智能体。` +
+                `请在 bindings 中添加：{"agentId":"你的Agent","match":{"channel":"wecom","accountId":"${account.accountId}"}}`;
+            target.runtime.error?.(`[wecom] routing guard: blocked default fallback accountId=${account.accountId} matchedBy=${route.matchedBy} streamId=${streamId}`);
+            streamStore.updateStream(streamId, (s) => {
+                s.finished = true;
+                s.content = prompt;
+            });
+            try {
+                await sendBotFallbackPromptNow({ streamId, text: prompt });
+            }
+            catch (err) {
+                target.runtime.error?.(`routing guard prompt push failed streamId=${streamId}: ${String(err)}`);
+            }
+            streamStore.onStreamFinished(streamId);
+            return;
+        }
+        if (useDynamicAgent) {
+            const targetAgentId = generateAgentId(chatType === "group" ? "group" : "dm", chatId, account.accountId);
+            route.agentId = targetAgentId;
+            route.sessionKey = `agent:${targetAgentId}:wecom:${account.accountId}:${chatType === "group" ? "group" : "dm"}:${chatId}`;
+            ensureDynamicAgentListed(targetAgentId, core).catch(() => { });
+            logVerbose(target, `dynamic agent routing: ${targetAgentId}, sessionKey=${route.sessionKey}`);
+        }
+        if (mediaPath) {
+            try {
+                const stagedSessionPath = await stageWecomInboundMediaForSession({
+                    cfg: target.config,
+                    accountId: target.account.accountId,
+                    agentId: route.agentId,
+                    sessionKey: route.sessionKey,
+                    mediaPath,
+                    filename: mediaFilename,
+                });
+                mediaPath = stagedSessionPath;
+                logVerbose(target, `session media staged to ${mediaPath}`);
+            }
+            catch (err) {
+                target.runtime.error?.(`Failed to stage inbound media for session workspace: ${String(err)}`);
+            }
+        }
+        logVerbose(target, `starting agent processing (streamId=${streamId}, agentId=${route.agentId}, peerKind=${chatType}, peerId=${chatId})`);
+        logVerbose(target, `启动 Agent 处理: streamId=${streamId} 路由=${route.agentId} 类型=${chatType} ID=${chatId}`);
+        const fromLabel = chatType === "group" ? `group:${chatId}` : `user:${userId}`;
+        const storePath = core.channel.session.resolveStorePath(config.session?.store, { agentId: route.agentId });
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
+        const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+            storePath,
+            sessionKey: route.sessionKey,
+        });
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "WeCom",
+            from: fromLabel,
+            previousTimestamp,
+            envelope: envelopeOptions,
+            body: rawBody,
+        });
+        const authz = await resolveWecomCommandAuthorization({
+            core,
+            cfg: config,
+            accountConfig: account.config,
+            rawBody,
+            senderUserId: userId,
+        });
+        const commandAuthorized = authz.commandAuthorized;
+        logVerbose(target, `authz: dmPolicy=${authz.dmPolicy} shouldCompute=${authz.shouldComputeAuth} sender=${userId.toLowerCase()} senderAllowed=${authz.senderAllowed} authorizerConfigured=${authz.authorizerConfigured} commandAuthorized=${String(authz.commandAuthorized)}`);
+        if (authz.shouldComputeAuth && authz.commandAuthorized !== true) {
+            const prompt = buildWecomUnauthorizedCommandPrompt({ senderUserId: userId, dmPolicy: authz.dmPolicy, scope: "bot" });
+            streamStore.updateStream(streamId, (s) => {
+                s.finished = true;
+                s.content = prompt;
+            });
+            try {
+                await sendBotFallbackPromptNow({ streamId, text: prompt });
+                logInfo(target, `authz: 未授权命令已提示用户 streamId=${streamId}`);
+            }
+            catch (err) {
+                target.runtime.error?.(`authz: 未授权命令提示推送失败 streamId=${streamId}: ${String(err)}`);
+            }
+            streamStore.onStreamFinished(streamId);
+            return;
+        }
+        const attachments = mediaPath
+            ? [
+                {
+                    name: media?.filename || "file",
+                    mimeType: mediaType,
+                    url: pathToFileURL(mediaPath).href,
+                },
+            ]
+            : undefined;
+        const ctxPayload = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            RawBody: rawBody,
+            CommandBody: rawBody,
+            Attachments: attachments,
+            From: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${userId}`,
+            To: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${chatId}`,
+            SessionKey: route.sessionKey,
+            AccountId: route.accountId,
+            ChatType: chatType,
+            ConversationLabel: fromLabel,
+            SenderName: userId,
+            SenderId: userId,
+            Provider: "wecom",
+            Surface: "wecom",
+            MessageSid: msg.msgid,
+            CommandAuthorized: commandAuthorized,
+            OriginatingChannel: "wecom",
+            OriginatingTo: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${chatId}`,
+            MediaPath: mediaPath,
+            MediaType: mediaType,
+            MediaUrl: mediaPath,
+        });
+        await core.channel.session.recordInboundSession({
+            storePath,
+            sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+            ctx: ctxPayload,
+            onRecordError: (err) => {
+                target.runtime.error?.(`wecom: failed updating session meta: ${String(err)}`);
+            },
+        });
+        const tableMode = core.channel.text.resolveMarkdownTableMode({
+            cfg: config,
+            channel: "wecom",
+            accountId: account.accountId,
+        });
+        const cfgForDispatch = buildWecomBotDispatchConfig(config);
+        logVerbose(target, "tool-policy: WeCom Bot 会话已禁用 message 工具（tools.deny += message；并同步到 tools.sandbox.tools.deny，防止绕过 Bot 交付）");
+        await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg: cfgForDispatch,
+            replyOptions: { disableBlockStreaming: false },
+            dispatcherOptions: createBotReplyDispatcher({
+                streamStore,
+                target,
+                accountId: account.accountId,
+                config,
+                msg,
+                streamId,
+                rawBody,
+                chatType,
+                userId,
+                core,
+                tableMode,
+                logVerbose,
+                truncateUtf8Bytes,
+                recordBotOperationalEvent,
+            }),
+        });
+        const rawBodyNormalized = rawBody.trim();
+        const isResetCommand = /^\/(new|reset)(?:\s|$)/i.test(rawBodyNormalized);
+        const resetCommandKind = isResetCommand ? (rawBodyNormalized.match(/^\/(new|reset)/i)?.[1]?.toLowerCase() ?? "new") : null;
+        await finalizeBotStream({
+            streamStore,
+            target,
+            streamId,
+            chatType,
+            core,
+            config,
+            accountId: account.accountId,
+            isResetCommand,
+            resetCommandKind,
+            logInfo,
+            logVerbose,
+            recordBotOperationalEvent,
+        });
+    }
+    return {
+        flushPending,
+        startAgentForStream,
+    };
+}

package/dist/src/capability/bot/types.js

@@ -0,0 +1 @@
+export {};