@yanhaidao/wecom 2.4.160 → 2.5.110

package/dist/src/agent/index.js

@@ -0,0 +1,5 @@
+/**
+ * WeCom Agent 模块导出
+ */
+export { handleAgentWebhook } from "./handler.js";
+export { getAccessToken, sendText, uploadMedia, sendMedia, downloadMedia, } from "../transport/agent-api/core.js";

package/dist/src/app/account-runtime.js

@@ -0,0 +1,216 @@
+import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
+import { WecomAuditLog } from "../observability/audit-log.js";
+import { WecomStatusRegistry } from "../observability/status-registry.js";
+import { summarizeTransportSessions } from "../observability/transport-session-view.js";
+import { dispatchInboundEvent } from "../runtime/dispatcher.js";
+import { WecomMediaService } from "../shared/media-service.js";
+import { InMemoryRuntimeStore } from "../store/memory-store.js";
+export class WecomAccountRuntime {
+    core;
+    cfg;
+    resolved;
+    log;
+    statusSink;
+    store = new InMemoryRuntimeStore();
+    mediaService;
+    auditLog = new WecomAuditLog();
+    statusRegistry = new WecomStatusRegistry();
+    runtimeStatus;
+    constructor(core, cfg, resolved, log = {}, statusSink) {
+        this.core = core;
+        this.cfg = cfg;
+        this.resolved = resolved;
+        this.log = log;
+        this.statusSink = statusSink;
+        this.mediaService = new WecomMediaService(core, cfg);
+        this.runtimeStatus = {
+            accountId: resolved.account.accountId,
+            health: "idle",
+            ownerId: null,
+            ownerDriftAt: null,
+            lastError: null,
+            lastErrorAt: null,
+            lastInboundAt: null,
+            lastOutboundAt: null,
+            recentInboundSummary: null,
+            recentOutboundSummary: null,
+            recentIssueCategory: null,
+            recentIssueSummary: null,
+            transportSessions: [],
+        };
+    }
+    get account() {
+        return this.resolved.account;
+    }
+    async handleEvent(event, replyHandle) {
+        const dispatchStartedAt = Date.now();
+        this.runtimeStatus.lastInboundAt = Date.now();
+        this.runtimeStatus.recentInboundSummary = `${event.transport} ${event.inboundKind} ${event.messageId}`;
+        this.log.info?.(`[wecom-runtime] inbound account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} peer=${event.conversation.peerKind}:${event.conversation.peerId}`);
+        this.log.info?.(`[wecom-runtime] dispatch-start account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId}`);
+        this.emitStatus();
+        const trackedReplyHandle = {
+            context: replyHandle.context,
+            deliver: async (payload, info) => {
+                const deliverStartedAt = Date.now();
+                const textLen = payload.text?.trim().length ?? 0;
+                const mediaCount = (payload.mediaUrls?.length ?? 0) + (payload.mediaUrl ? 1 : 0);
+                this.log.info?.(`[wecom-runtime] deliver-start account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} textLen=${textLen} mediaCount=${mediaCount} reasoning=${String(payload.isReasoning === true)}`);
+                await replyHandle.deliver(payload, info);
+                this.runtimeStatus.lastOutboundAt = Date.now();
+                const outboundSummary = payload.text?.trim() || payload.mediaUrl || payload.mediaUrls?.[0] || info.kind;
+                this.runtimeStatus.recentOutboundSummary = `${replyHandle.context.transport} ${outboundSummary.slice(0, 120)}`;
+                this.log.info?.(`[wecom-runtime] outbound account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} summary=${JSON.stringify(this.runtimeStatus.recentOutboundSummary)}`);
+                this.log.info?.(`[wecom-runtime] deliver-done account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} durationMs=${Date.now() - deliverStartedAt}`);
+                this.emitStatus();
+            },
+            fail: async (error) => {
+                const formattedError = formatErrorMessage(error);
+                this.recordOperationalIssue({
+                    transport: replyHandle.context.transport,
+                    category: "runtime-error",
+                    messageId: event.messageId,
+                    raw: replyHandle.context.raw,
+                    summary: `reply-fail ${formattedError}`,
+                    error: formattedError,
+                });
+                this.log.error?.(`[wecom-runtime] reply-fail account=${event.accountId} transport=${replyHandle.context.transport} messageId=${event.messageId} error=${formattedError}`);
+                await replyHandle.fail?.(error);
+            },
+            markExternalActivity: () => {
+                replyHandle.markExternalActivity?.();
+            },
+        };
+        try {
+            await dispatchInboundEvent({
+                core: this.core,
+                cfg: this.cfg,
+                store: this.store,
+                auditLog: this.auditLog,
+                mediaService: this.mediaService,
+                event,
+                replyHandle: trackedReplyHandle,
+            });
+            this.log.info?.(`[wecom-runtime] dispatch-done account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} durationMs=${Date.now() - dispatchStartedAt}`);
+        }
+        catch (error) {
+            this.log.error?.(`[wecom-runtime] dispatch-fail account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} durationMs=${Date.now() - dispatchStartedAt} error=${formatErrorMessage(error)}`);
+            throw error;
+        }
+    }
+    updateTransportSession(snapshot) {
+        const previous = this.store.readTransportSession(snapshot.accountId, snapshot.transport);
+        this.store.writeTransportSession(snapshot);
+        this.statusRegistry.write(snapshot);
+        this.log.info?.(`[wecom-runtime] session account=${snapshot.accountId} transport=${snapshot.transport} running=${snapshot.running} owner=${snapshot.ownerId ?? "none"} connected=${String(snapshot.connected ?? false)} authenticated=${String(snapshot.authenticated ?? false)} error=${snapshot.lastError ?? "none"}`);
+        if (previous?.ownerId &&
+            snapshot.ownerId &&
+            previous.ownerId !== snapshot.ownerId &&
+            previous.running) {
+            this.recordOperationalIssue({
+                transport: snapshot.transport,
+                category: "owner-drift",
+                summary: `owner drift ${previous.ownerId} -> ${snapshot.ownerId}`,
+            });
+        }
+        if (snapshot.lastError) {
+            this.runtimeStatus.lastError = snapshot.lastError;
+            this.runtimeStatus.lastErrorAt = Date.now();
+        }
+        else if (snapshot.running) {
+            this.runtimeStatus.lastError = null;
+        }
+        this.emitStatus();
+    }
+    touchTransportSession(transport, patch) {
+        const current = this.store.readTransportSession(this.account.accountId, transport);
+        const next = {
+            accountId: this.account.accountId,
+            transport,
+            running: patch.running ?? current?.running ?? true,
+            ownerId: patch.ownerId ?? current?.ownerId,
+            connected: patch.connected ?? current?.connected,
+            authenticated: patch.authenticated ?? current?.authenticated,
+            lastConnectedAt: patch.lastConnectedAt ?? current?.lastConnectedAt,
+            lastDisconnectedAt: patch.lastDisconnectedAt ?? current?.lastDisconnectedAt,
+            lastInboundAt: patch.lastInboundAt ?? current?.lastInboundAt,
+            lastOutboundAt: patch.lastOutboundAt ?? current?.lastOutboundAt,
+            lastError: "lastError" in patch ? (patch.lastError ?? undefined) : current?.lastError,
+        };
+        this.updateTransportSession(next);
+    }
+    listTransportSessions() {
+        return this.statusRegistry.read(this.account.accountId);
+    }
+    listAuditEntries() {
+        return this.auditLog.list();
+    }
+    buildRuntimeStatus() {
+        const sessions = this.listTransportSessions();
+        const primarySession = this.resolvePrimarySession(sessions);
+        return {
+            ...this.runtimeStatus,
+            health: this.computeHealth(sessions),
+            transport: primarySession?.transport,
+            ownerId: primarySession?.ownerId ?? this.runtimeStatus.ownerId ?? null,
+            connected: primarySession?.connected,
+            authenticated: primarySession?.authenticated,
+            lastError: primarySession?.lastError ??
+                (primarySession?.running ? null : (this.runtimeStatus.lastError ?? null)),
+            transportSessions: summarizeTransportSessions(sessions),
+        };
+    }
+    recordOperationalIssue(params) {
+        this.auditLog.appendOperational({
+            accountId: this.account.accountId,
+            transport: params.transport,
+            category: params.category,
+            messageId: params.messageId,
+            summary: params.summary,
+            raw: params.raw,
+            error: params.error,
+        });
+        if (params.category === "owner-drift" || params.category === "ws-kicked") {
+            this.runtimeStatus.ownerDriftAt = Date.now();
+        }
+        this.runtimeStatus.lastError = params.error ?? params.summary;
+        this.runtimeStatus.lastErrorAt = Date.now();
+        this.runtimeStatus.recentIssueCategory = params.category;
+        this.runtimeStatus.recentIssueSummary = params.summary;
+        const sink = params.category === "runtime-error" || params.category === "fallback-delivery-failed"
+            ? this.log.error
+            : this.log.warn;
+        sink?.(`[wecom-runtime] issue account=${this.account.accountId} transport=${params.transport} category=${params.category} messageId=${params.messageId ?? "n/a"} summary=${params.summary}`);
+        this.emitStatus();
+    }
+    emitStatus() {
+        this.statusSink?.(this.buildRuntimeStatus());
+    }
+    resolvePrimarySession(sessions) {
+        const primaryTransport = this.account.bot?.configured
+            ? this.account.bot.primaryTransport === "ws"
+                ? "bot-ws"
+                : "bot-webhook"
+            : this.account.agent?.callbackConfigured
+                ? "agent-callback"
+                : undefined;
+        if (!primaryTransport) {
+            return sessions[0];
+        }
+        return sessions.find((session) => session.transport === primaryTransport) ?? sessions[0];
+    }
+    computeHealth(sessions) {
+        if (sessions.length === 0) {
+            return this.runtimeStatus.lastError ? "down" : "idle";
+        }
+        const hasRunning = sessions.some((session) => session.running);
+        const hasError = sessions.some((session) => Boolean(session.lastError));
+        if (hasRunning && !hasError) {
+            return "healthy";
+        }
+        if (hasRunning) {
+            return "degraded";
+        }
+        return hasError ? "down" : "idle";
+    }
+}

package/dist/src/app/bootstrap.js

@@ -0,0 +1,19 @@
+import { resolveWecomRuntimeAccount } from "../config/runtime-config.js";
+import { WecomAccountRuntime } from "./account-runtime.js";
+import { getWecomRuntime } from "./index.js";
+export function createAccountRuntime(ctx) {
+    const resolved = resolveWecomRuntimeAccount({
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+    });
+    return new WecomAccountRuntime(getWecomRuntime(), ctx.cfg, resolved, {
+        info: (message) => ctx.log?.info(message),
+        warn: (message) => ctx.log?.warn(message),
+        error: (message) => ctx.log?.error(message),
+    }, (snapshot) => {
+        ctx.setStatus({
+            accountId: ctx.accountId,
+            ...snapshot,
+        });
+    });
+}

package/dist/src/app/index.js

@@ -0,0 +1,118 @@
+import { clearWecomSourceAccount } from "../runtime/source-registry.js";
+let runtime = null;
+const runtimes = new Map();
+const botWsPushHandles = new Map();
+const activeBotWsReplyHandlesBySession = new Map();
+const activeBotWsReplyHandlesByPeer = new Map();
+function normalizeOptional(value) {
+    const trimmed = String(value ?? "").trim();
+    return trimmed || undefined;
+}
+function normalizePeerId(value) {
+    const trimmed = normalizeOptional(value);
+    return trimmed ? trimmed.toLowerCase() : undefined;
+}
+function buildSessionHandleKey(accountId, sessionKey) {
+    return `${accountId}::session::${sessionKey}`;
+}
+function buildPeerHandleKey(accountId, peerKind, peerId) {
+    return `${accountId}::peer::${peerKind}::${peerId}`;
+}
+export function setWecomRuntime(next) {
+    runtime = next;
+}
+export function getWecomRuntime() {
+    if (!runtime) {
+        throw new Error("WeCom runtime not initialized");
+    }
+    return runtime;
+}
+export function registerAccountRuntime(accountRuntime) {
+    runtimes.set(accountRuntime.account.accountId, accountRuntime);
+    console.log(`[wecom-runtime] register account=${accountRuntime.account.accountId}`);
+}
+export function getAccountRuntime(accountId) {
+    return runtimes.get(accountId);
+}
+export function getAccountRuntimeSnapshot(accountId) {
+    return runtimes.get(accountId)?.buildRuntimeStatus();
+}
+export function registerBotWsPushHandle(accountId, handle) {
+    botWsPushHandles.set(accountId, handle);
+}
+export function getBotWsPushHandle(accountId) {
+    return botWsPushHandles.get(accountId);
+}
+export function registerActiveBotWsReplyHandle(params) {
+    const accountId = normalizeOptional(params.accountId);
+    const sessionKey = normalizeOptional(params.sessionKey);
+    const peerId = normalizePeerId(params.peerId);
+    if (!accountId) {
+        return;
+    }
+    if (sessionKey) {
+        activeBotWsReplyHandlesBySession.set(buildSessionHandleKey(accountId, sessionKey), params.handle);
+    }
+    if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
+        activeBotWsReplyHandlesByPeer.set(buildPeerHandleKey(accountId, params.peerKind, peerId), params.handle);
+    }
+}
+export function getActiveBotWsReplyHandle(params) {
+    const accountId = normalizeOptional(params.accountId);
+    const sessionKey = normalizeOptional(params.sessionKey);
+    const peerId = normalizePeerId(params.peerId);
+    if (!accountId) {
+        return undefined;
+    }
+    if (sessionKey) {
+        const handle = activeBotWsReplyHandlesBySession.get(buildSessionHandleKey(accountId, sessionKey));
+        if (handle) {
+            return handle;
+        }
+    }
+    if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
+        return activeBotWsReplyHandlesByPeer.get(buildPeerHandleKey(accountId, params.peerKind, peerId));
+    }
+    return undefined;
+}
+export function unregisterActiveBotWsReplyHandle(params) {
+    const accountId = normalizeOptional(params.accountId);
+    const sessionKey = normalizeOptional(params.sessionKey);
+    const peerId = normalizePeerId(params.peerId);
+    if (!accountId) {
+        return;
+    }
+    if (sessionKey) {
+        const key = buildSessionHandleKey(accountId, sessionKey);
+        const current = activeBotWsReplyHandlesBySession.get(key);
+        if (!params.handle || current === params.handle) {
+            activeBotWsReplyHandlesBySession.delete(key);
+        }
+    }
+    if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
+        const key = buildPeerHandleKey(accountId, params.peerKind, peerId);
+        const current = activeBotWsReplyHandlesByPeer.get(key);
+        if (!params.handle || current === params.handle) {
+            activeBotWsReplyHandlesByPeer.delete(key);
+        }
+    }
+}
+export function unregisterBotWsPushHandle(accountId) {
+    botWsPushHandles.delete(accountId);
+}
+export function unregisterAccountRuntime(accountId) {
+    runtimes.delete(accountId);
+    botWsPushHandles.delete(accountId);
+    for (const key of activeBotWsReplyHandlesBySession.keys()) {
+        if (key.startsWith(`${accountId}::`)) {
+            activeBotWsReplyHandlesBySession.delete(key);
+        }
+    }
+    for (const key of activeBotWsReplyHandlesByPeer.keys()) {
+        if (key.startsWith(`${accountId}::`)) {
+            activeBotWsReplyHandlesByPeer.delete(key);
+        }
+    }
+    clearWecomSourceAccount(accountId);
+    console.log(`[wecom-runtime] unregister account=${accountId}`);
+}

package/dist/src/capability/agent/delivery-service.js

@@ -0,0 +1,63 @@
+import { resolveScopedWecomTarget } from "../../target.js";
+import { deliverAgentApiMedia, deliverAgentApiText } from "../../transport/agent-api/delivery.js";
+import { canUseAgentApiDelivery } from "./fallback-policy.js";
+import { getWecomRuntime } from "../../runtime.js";
+export class WecomAgentDeliveryService {
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    assertAvailable() {
+        if (!canUseAgentApiDelivery(this.agent)) {
+            throw new Error(`WeCom outbound requires channels.wecom.accounts.<accountId>.agent.agentId (or legacy channels.wecom.agent.agentId) for account=${this.agent.accountId}.`);
+        }
+    }
+    resolveTargetOrThrow(to) {
+        const scoped = resolveScopedWecomTarget(to, this.agent.accountId);
+        if (!scoped) {
+            console.error(`[wecom-agent-delivery] missing target account=${this.agent.accountId}`);
+            throw new Error("WeCom outbound requires a target (userid, partyid, tagid or chatid).");
+        }
+        if (scoped.accountId && scoped.accountId !== this.agent.accountId) {
+            console.error(`[wecom-agent-delivery] account mismatch current=${this.agent.accountId} targetAccount=${scoped.accountId} raw=${String(to ?? "")}`);
+            throw new Error(`WeCom outbound account mismatch: target belongs to account=${scoped.accountId}, current account=${this.agent.accountId}.`);
+        }
+        const target = scoped.target;
+        if (target.chatid) {
+            console.warn(`[wecom-agent-delivery] blocked chat target account=${this.agent.accountId} chatId=${target.chatid}`);
+            throw new Error(`企业微信（WeCom）Agent 主动发送不支持向群 chatId 发送（chatId=${target.chatid}）。` +
+                `该路径在实际环境中经常失败（例如 86008：无权限访问该会话/会话由其他应用创建）。` +
+                `请改为发送给用户（userid / user:xxx），或由 Bot 模式在群内交付。`);
+        }
+        return target;
+    }
+    async sendText(params) {
+        this.assertAvailable();
+        const target = this.resolveTargetOrThrow(params.to);
+        console.log(`[wecom-agent-delivery] sendText account=${this.agent.accountId} to=${String(params.to ?? "")} len=${params.text.length}`);
+        const runtime = getWecomRuntime();
+        const chunks = runtime.channel.text.chunkText(params.text, 2048);
+        for (const chunk of chunks) {
+            if (!chunk.trim())
+                continue;
+            await deliverAgentApiText({
+                agent: this.agent,
+                target,
+                text: chunk,
+            });
+        }
+    }
+    async sendMedia(params) {
+        this.assertAvailable();
+        const target = this.resolveTargetOrThrow(params.to);
+        console.log(`[wecom-agent-delivery] sendMedia account=${this.agent.accountId} to=${String(params.to ?? "")} filename=${params.filename} contentType=${params.contentType}`);
+        await deliverAgentApiMedia({
+            agent: this.agent,
+            target,
+            buffer: params.buffer,
+            filename: params.filename,
+            contentType: params.contentType,
+            text: params.text,
+        });
+    }
+}

package/dist/src/capability/agent/fallback-policy.js

@@ -0,0 +1,6 @@
+export function canUseAgentApiDelivery(agent) {
+    return Boolean(agent?.apiConfigured && typeof agent.agentId === "number");
+}
+export function shouldFallbackToAgentApi(params) {
+    return canUseAgentApiDelivery(params.agent) && Boolean(params.hasText || params.hasMedia);
+}

package/dist/src/capability/agent/ingress-service.js

@@ -0,0 +1,33 @@
+import { startAgentCallbackTransport } from "../../transport/agent-callback/http-handler.js";
+export class WecomAgentIngressService {
+    runtime;
+    cfg;
+    runtimeEnv;
+    stopTransport;
+    constructor(runtime, cfg, runtimeEnv) {
+        this.runtime = runtime;
+        this.cfg = cfg;
+        this.runtimeEnv = runtimeEnv;
+    }
+    start() {
+        const agent = this.runtime.account.agent;
+        if (!agent?.callbackConfigured) {
+            return undefined;
+        }
+        const callback = startAgentCallbackTransport({
+            account: agent,
+            cfg: this.cfg,
+            runtime: this.runtime,
+            runtimeEnv: this.runtimeEnv,
+        });
+        this.stopTransport = callback.stop;
+        return {
+            transport: "agent-callback",
+            descriptors: callback.paths,
+        };
+    }
+    stop() {
+        this.stopTransport?.();
+        this.stopTransport = undefined;
+    }
+}

package/dist/src/capability/agent/upstream-delivery-service.js

@@ -0,0 +1,71 @@
+import { resolveScopedWecomTarget } from "../../target.js";
+import { deliverUpstreamAgentApiMedia, deliverUpstreamAgentApiText } from "../../transport/agent-api/upstream-delivery.js";
+import { canUseAgentApiDelivery } from "./fallback-policy.js";
+import { getWecomRuntime } from "../../runtime.js";
+/**
+ * 上下游企业消息发送服务
+ *
+ * 使用下游企业的 access_token 和 agentId 发送消息
+ */
+export class WecomUpstreamAgentDeliveryService {
+    upstreamAgent;
+    primaryAgent;
+    constructor(upstreamAgent, primaryAgent) {
+        this.upstreamAgent = upstreamAgent;
+        this.primaryAgent = primaryAgent;
+    }
+    assertAvailable() {
+        if (!canUseAgentApiDelivery(this.upstreamAgent)) {
+            throw new Error(`WeCom upstream outbound requires channels.wecom.accounts.<accountId>.agent.agentId for upstream corp=${this.upstreamAgent.corpId}.`);
+        }
+    }
+    resolveTargetOrThrow(to) {
+        const scoped = resolveScopedWecomTarget(to, this.upstreamAgent.accountId);
+        if (!scoped) {
+            console.error(`[wecom-upstream-delivery] missing target account=${this.upstreamAgent.accountId}`);
+            throw new Error("WeCom upstream outbound requires a target (userid, partyid, tagid or chatid).");
+        }
+        if (scoped.accountId && scoped.accountId !== this.upstreamAgent.accountId) {
+            console.error(`[wecom-upstream-delivery] account mismatch current=${this.upstreamAgent.accountId} targetAccount=${scoped.accountId} raw=${String(to ?? "")}`);
+            throw new Error(`WeCom upstream outbound account mismatch: target belongs to account=${scoped.accountId}, current account=${this.upstreamAgent.accountId}.`);
+        }
+        const target = scoped.target;
+        if (target.chatid) {
+            console.warn(`[wecom-upstream-delivery] blocked chat target account=${this.upstreamAgent.accountId} chatId=${target.chatid}`);
+            throw new Error(`企业微信（WeCom）上下游 Agent 主动发送不支持向群 chatId 发送（chatId=${target.chatid}）。` +
+                `请改为发送给用户（userid / user:xxx）。`);
+        }
+        return target;
+    }
+    async sendText(params) {
+        this.assertAvailable();
+        const target = this.resolveTargetOrThrow(params.to);
+        console.log(`[wecom-upstream-delivery] sendText account=${this.upstreamAgent.accountId} corpId=${this.upstreamAgent.corpId} to=${String(params.to ?? "")} len=${params.text.length}`);
+        const runtime = getWecomRuntime();
+        const chunks = runtime.channel.text.chunkText(params.text, 2048);
+        for (const chunk of chunks) {
+            if (!chunk.trim())
+                continue;
+            await deliverUpstreamAgentApiText({
+                upstreamAgent: this.upstreamAgent,
+                primaryAgent: this.primaryAgent,
+                target,
+                text: chunk,
+            });
+        }
+    }
+    async sendMedia(params) {
+        this.assertAvailable();
+        const target = this.resolveTargetOrThrow(params.to);
+        console.log(`[wecom-upstream-delivery] sendMedia account=${this.upstreamAgent.accountId} corpId=${this.upstreamAgent.corpId} to=${String(params.to ?? "")} filename=${params.filename} contentType=${params.contentType}`);
+        await deliverUpstreamAgentApiMedia({
+            upstreamAgent: this.upstreamAgent,
+            primaryAgent: this.primaryAgent,
+            target,
+            buffer: params.buffer,
+            filename: params.filename,
+            contentType: params.contentType,
+            text: params.text,
+        });
+    }
+}

package/dist/src/capability/bot/dispatch-config.js

@@ -0,0 +1,45 @@
+export function buildWecomBotDispatchConfig(config) {
+    const baseAgents = config?.agents ?? {};
+    const baseAgentDefaults = baseAgents?.defaults ?? {};
+    const baseBlockChunk = baseAgentDefaults?.blockStreamingChunk ?? {};
+    const baseBlockCoalesce = baseAgentDefaults?.blockStreamingCoalesce ?? {};
+    const baseTools = config?.tools ?? {};
+    const baseSandbox = baseTools?.sandbox ?? {};
+    const baseSandboxTools = baseSandbox?.tools ?? {};
+    const existingTopLevelDeny = Array.isArray(baseTools.deny) ? baseTools.deny : [];
+    const existingSandboxDeny = Array.isArray(baseSandboxTools.deny) ? baseSandboxTools.deny : [];
+    const topLevelDeny = Array.from(new Set([...existingTopLevelDeny, "message"]));
+    const sandboxDeny = Array.from(new Set([...existingSandboxDeny, "message"]));
+    return {
+        ...config,
+        agents: {
+            ...baseAgents,
+            defaults: {
+                ...baseAgentDefaults,
+                blockStreamingChunk: {
+                    ...baseBlockChunk,
+                    minChars: baseBlockChunk.minChars ?? 120,
+                    maxChars: baseBlockChunk.maxChars ?? 360,
+                    breakPreference: baseBlockChunk.breakPreference ?? "sentence",
+                },
+                blockStreamingCoalesce: {
+                    ...baseBlockCoalesce,
+                    minChars: baseBlockCoalesce.minChars ?? 120,
+                    maxChars: baseBlockCoalesce.maxChars ?? 360,
+                    idleMs: baseBlockCoalesce.idleMs ?? 250,
+                },
+            },
+        },
+        tools: {
+            ...baseTools,
+            deny: topLevelDeny,
+            sandbox: {
+                ...baseSandbox,
+                tools: {
+                    ...baseSandboxTools,
+                    deny: sandboxDeny,
+                },
+            },
+        },
+    };
+}