@yanhaidao/wecom 2.4.160 → 2.5.110

package/src/runtime/dispatcher.ts

@@ -1,71 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
-import { prepareInboundSession } from "./session-manager.js";
-import { dispatchRuntimeReply } from "./reply-orchestrator.js";
-import type { RuntimeStore } from "../store/interfaces.js";
-import type { WecomAuditLog } from "../observability/audit-log.js";
-import { buildRawEnvelopeSummary } from "../observability/raw-envelope-log.js";
-import type { ReplyHandle, UnifiedInboundEvent } from "../types/index.js";
-import type { WecomMediaService } from "../shared/media-service.js";
-import { registerActiveBotWsReplyHandle, unregisterActiveBotWsReplyHandle } from "../runtime.js";
-
-export async function dispatchInboundEvent(params: {
-  core: PluginRuntime;
-  cfg: OpenClawConfig;
-  store: RuntimeStore;
-  auditLog: WecomAuditLog;
-  mediaService: WecomMediaService;
-  event: UnifiedInboundEvent;
-  replyHandle: ReplyHandle;
-}): Promise<void> {
-  const { core, cfg, store, auditLog, mediaService, event, replyHandle } = params;
-  if (!store.markInboundSeen(event)) {
-    auditLog.appendOperational({
-      accountId: event.accountId,
-      transport: event.transport,
-      category: "duplicate-inbound",
-      messageId: event.messageId,
-      summary: buildRawEnvelopeSummary(event),
-      raw: event.raw,
-    });
-    return;
-  }
-  auditLog.appendInbound({
-    accountId: event.accountId,
-    transport: event.transport,
-    messageId: event.messageId,
-    summary: buildRawEnvelopeSummary(event),
-    raw: event.raw,
-  });
-  store.writeReplyContext(event.messageId, event.replyContext);
-  const session = await prepareInboundSession({
-    core,
-    cfg,
-    event,
-    mediaService,
-  });
-  const sessionKey = session.ctx.SessionKey ?? session.route.sessionKey;
-  registerActiveBotWsReplyHandle({
-    accountId: event.accountId,
-    sessionKey,
-    peerKind: event.conversation.peerKind,
-    peerId: event.conversation.peerId,
-    handle: replyHandle,
-  });
-  try {
-    await dispatchRuntimeReply({
-      core,
-      cfg,
-      session,
-      replyHandle,
-    });
-  } finally {
-    unregisterActiveBotWsReplyHandle({
-      accountId: event.accountId,
-      sessionKey,
-      peerKind: event.conversation.peerKind,
-      peerId: event.conversation.peerId,
-      handle: replyHandle,
-    });
-  }
-}

package/src/runtime/outbound-intent.ts

@@ -1,4 +0,0 @@
-export type OutboundIntent =
-  | { kind: "text"; text: string }
-  | { kind: "media"; mediaUrl: string; text?: string }
-  | { kind: "card"; card: Record<string, unknown> };

package/src/runtime/reply-orchestrator.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { dispatchRuntimeReply } from "./reply-orchestrator.js";
-
-describe("dispatchRuntimeReply", () => {
-  it("enables block streaming for bot-ws replies", async () => {
-    const dispatchReplyWithBufferedBlockDispatcher = vi
-      .fn()
-      .mockResolvedValue({ queuedFinal: false, counts: { block: 0, final: 0, tool: 0 } });
-    const core = {
-      channel: {
-        reply: {
-          dispatchReplyWithBufferedBlockDispatcher,
-        },
-      },
-    } as any;
-
-    await dispatchRuntimeReply({
-      core,
-      cfg: {} as any,
-      session: { ctx: { SessionKey: "session-a" } } as any,
-      replyHandle: {
-        context: {
-          transport: "bot-ws",
-          accountId: "default",
-          raw: { transport: "bot-ws", envelopeType: "ws", body: {} },
-        },
-        deliver: vi.fn(),
-      } as any,
-    });
-
-    expect(dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledWith(
-      expect.objectContaining({
-        replyOptions: expect.objectContaining({
-          disableBlockStreaming: false,
-        }),
-      }),
-    );
-  });
-
-  it("synthesizes a final close for bot-ws when only block replies were queued", async () => {
-    const dispatchReplyWithBufferedBlockDispatcher = vi.fn().mockResolvedValue({
-      queuedFinal: false,
-      counts: { block: 1, final: 0, tool: 0 },
-    });
-    const deliver = vi.fn().mockResolvedValue(undefined);
-    const core = {
-      channel: {
-        reply: {
-          dispatchReplyWithBufferedBlockDispatcher,
-        },
-      },
-    } as any;
-
-    await dispatchRuntimeReply({
-      core,
-      cfg: {} as any,
-      session: { ctx: { SessionKey: "session-a" } } as any,
-      replyHandle: {
-        context: {
-          transport: "bot-ws",
-          accountId: "default",
-          raw: { transport: "bot-ws", envelopeType: "ws", body: {} },
-        },
-        deliver,
-      } as any,
-    });
-
-    expect(deliver).toHaveBeenCalledTimes(1);
-    expect(deliver).toHaveBeenCalledWith({ text: "" }, { kind: "final" });
-  });
-});

package/src/runtime/reply-orchestrator.ts

@@ -1,67 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-import type { ReplyHandle } from "../types/index.js";
-import type { PreparedSession } from "./session-manager.js";
-
-export async function dispatchReplyPayload(params: {
-  replyHandle: ReplyHandle;
-  payload: {
-    text?: string;
-    mediaUrl?: string;
-    mediaUrls?: string[];
-    replyToId?: string;
-    replyToTag?: boolean;
-    replyToCurrent?: boolean;
-    audioAsVoice?: boolean;
-    isError?: boolean;
-    isReasoning?: boolean;
-    channelData?: Record<string, unknown>;
-  };
-  kind: "block" | "final";
-}): Promise<void> {
-  await params.replyHandle.deliver(params.payload, { kind: params.kind });
-}
-
-export async function dispatchRuntimeReply(params: {
-  core: PluginRuntime;
-  cfg: OpenClawConfig;
-  session: PreparedSession;
-  replyHandle: ReplyHandle;
-}): Promise<void> {
-  const { core, cfg, session, replyHandle } = params;
-  const result = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx: session.ctx,
-    cfg,
-    replyOptions:
-      replyHandle.context.transport === "bot-ws"
-        ? {
-            // WS bot replies should emit block updates instead of waiting for a final-only flush.
-            disableBlockStreaming: false,
-          }
-        : undefined,
-    dispatcherOptions: {
-      deliver: async (payload, info) => {
-        await dispatchReplyPayload({
-          replyHandle,
-          payload,
-          kind: info?.kind === "final" ? "final" : "block",
-        });
-      },
-      onError: async (error) => {
-        await replyHandle.fail?.(error);
-      },
-    },
-  });
-
-  if (
-    replyHandle.context.transport === "bot-ws" &&
-    result &&
-    result.queuedFinal !== true &&
-    (result.counts?.block ?? 0) > 0
-  ) {
-    await dispatchReplyPayload({
-      replyHandle,
-      payload: { text: "" },
-      kind: "final",
-    });
-  }
-}

package/src/runtime/routing-bridge.test.ts

@@ -1,115 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { resolveRuntimeRoute } from "./routing-bridge.js";
-import { ensureDynamicAgentListed } from "../dynamic-agent.js";
-import type { UnifiedInboundEvent } from "../types/index.js";
-
-vi.mock("../dynamic-agent.js", async () => {
-  const actual = await vi.importActual<typeof import("../dynamic-agent.js")>(
-    "../dynamic-agent.js",
-  );
-  return {
-    ...actual,
-    ensureDynamicAgentListed: vi.fn().mockResolvedValue(undefined),
-  };
-});
-
-describe("resolveRuntimeRoute", () => {
-  beforeEach(() => {
-    vi.mocked(ensureDynamicAgentListed).mockClear();
-  });
-
-  it("overrides WS runtime routes with dynamic agent routing for direct chats", () => {
-    const baseRoute = {
-      agentId: "main",
-      channel: "wecom",
-      accountId: "acct-ws",
-      sessionKey: "agent:main",
-      mainSessionKey: "agent:main:main",
-      lastRoutePolicy: "session" as const,
-      matchedBy: "default" as const,
-    };
-    const resolveAgentRoute = vi.fn().mockReturnValue({ ...baseRoute });
-    const core = {
-      channel: {
-        routing: {
-          resolveAgentRoute,
-        },
-      },
-    } as unknown as PluginRuntime;
-    const cfg = {
-      channels: {
-        wecom: {
-          dynamicAgents: {
-            enabled: true,
-          },
-        },
-      },
-    } as OpenClawConfig;
-    const event = {
-      accountId: "acct-ws",
-      conversation: {
-        accountId: "acct-ws",
-        peerKind: "direct",
-        peerId: "HiDaoMax",
-        senderId: "HiDaoMax",
-      },
-    } as UnifiedInboundEvent;
-
-    const route = resolveRuntimeRoute({ core, cfg, event });
-
-    expect(resolveAgentRoute).toHaveBeenCalledOnce();
-    expect(route.agentId).toBe("wecom-acct-ws-dm-hidaomax");
-    expect(route.sessionKey).toBe(
-      "agent:wecom-acct-ws-dm-hidaomax:wecom:acct-ws:dm:HiDaoMax",
-    );
-    expect(vi.mocked(ensureDynamicAgentListed)).toHaveBeenCalledWith(
-      "wecom-acct-ws-dm-hidaomax",
-      core,
-    );
-  });
-
-  it("keeps the resolved core route when dynamic agent routing is disabled for the sender", () => {
-    const baseRoute = {
-      agentId: "main",
-      channel: "wecom",
-      accountId: "acct-ws",
-      sessionKey: "agent:main",
-      mainSessionKey: "agent:main:main",
-      lastRoutePolicy: "session" as const,
-      matchedBy: "binding.account" as const,
-    };
-    const core = {
-      channel: {
-        routing: {
-          resolveAgentRoute: vi.fn().mockReturnValue({ ...baseRoute }),
-        },
-      },
-    } as unknown as PluginRuntime;
-    const cfg = {
-      channels: {
-        wecom: {
-          dynamicAgents: {
-            enabled: true,
-            adminUsers: ["HiDaoMax"],
-          },
-        },
-      },
-    } as OpenClawConfig;
-    const event = {
-      accountId: "acct-ws",
-      conversation: {
-        accountId: "acct-ws",
-        peerKind: "direct",
-        peerId: "HiDaoMax",
-        senderId: "HiDaoMax",
-      },
-    } as UnifiedInboundEvent;
-
-    const route = resolveRuntimeRoute({ core, cfg, event });
-
-    expect(route).toEqual(baseRoute);
-    expect(vi.mocked(ensureDynamicAgentListed)).not.toHaveBeenCalled();
-  });
-});

package/src/runtime/routing-bridge.ts

@@ -1,44 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
-import {
-  ensureDynamicAgentListed,
-  generateAgentId,
-  shouldUseDynamicAgent,
-} from "../dynamic-agent.js";
-import type { UnifiedInboundEvent } from "../types/index.js";
-
-export function resolveRuntimeRoute(params: {
-  core: PluginRuntime;
-  cfg: OpenClawConfig;
-  event: UnifiedInboundEvent;
-}) {
-  const route = params.core.channel.routing.resolveAgentRoute({
-    cfg: params.cfg,
-    channel: "wecom",
-    accountId: params.event.accountId,
-    peer: {
-      kind: params.event.conversation.peerKind,
-      id: params.event.conversation.peerId,
-    },
-  });
-
-  const chatType = params.event.conversation.peerKind === "group" ? "group" : "dm";
-  const useDynamicAgent = shouldUseDynamicAgent({
-    chatType,
-    senderId: params.event.conversation.senderId,
-    config: params.cfg,
-  });
-  if (!useDynamicAgent) {
-    return route;
-  }
-
-  const targetAgentId = generateAgentId(
-    chatType,
-    params.event.conversation.peerId,
-    params.event.accountId,
-  );
-  route.agentId = targetAgentId;
-  route.sessionKey = `agent:${targetAgentId}:wecom:${params.event.accountId}:${chatType}:${params.event.conversation.peerId}`;
-  ensureDynamicAgentListed(targetAgentId, params.core).catch(() => {});
-  return route;
-}

package/src/runtime/session-manager.test.ts

@@ -1,174 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { prepareInboundSession } from "./session-manager.js";
-
-const {
-  resolveRuntimeRoute,
-  getPeerContextToken,
-  registerWecomSourceSnapshot,
-} = vi.hoisted(() => ({
-  resolveRuntimeRoute: vi.fn(),
-  getPeerContextToken: vi.fn(),
-  registerWecomSourceSnapshot: vi.fn(),
-}));
-
-vi.mock("./routing-bridge.js", () => ({
-  resolveRuntimeRoute,
-}));
-
-vi.mock("../context-store.js", () => ({
-  getPeerContextToken,
-}));
-
-vi.mock("./source-registry.js", () => ({
-  registerWecomSourceSnapshot,
-}));
-
-function createCore() {
-  const finalizeInboundContext = vi.fn((ctx) => ctx);
-  const recordInboundSession = vi.fn(async () => {});
-
-  return {
-    core: {
-      channel: {
-        session: {
-          resolveStorePath: vi.fn(() => "/tmp/wecom-session-store"),
-          readSessionUpdatedAt: vi.fn(() => 1234567890),
-          recordInboundSession,
-        },
-        reply: {
-          resolveEnvelopeFormatOptions: vi.fn(() => ({ envelope: "default" })),
-          formatAgentEnvelope: vi.fn(() => "formatted-body"),
-          finalizeInboundContext,
-        },
-      },
-    } as any,
-    finalizeInboundContext,
-    recordInboundSession,
-  };
-}
-
-function createMediaService() {
-  return {
-    normalizeFirstAttachment: vi.fn(async () => undefined),
-    saveInboundAttachment: vi.fn(async () => undefined),
-  } as any;
-}
-
-describe("prepareInboundSession", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    resolveRuntimeRoute.mockReturnValue({
-      sessionKey: "agent:ops_bot:wecom:direct:hidaomax",
-      agentId: "ops_bot",
-      accountId: "default",
-    });
-  });
-
-  it("marks bot-ws turns as the current wecom surface", async () => {
-    getPeerContextToken.mockReturnValue("ctx-bot");
-    const { core, finalizeInboundContext, recordInboundSession } = createCore();
-
-    const result = await prepareInboundSession({
-      core,
-      cfg: {} as any,
-      event: {
-        accountId: "default",
-        transport: "bot-ws",
-        messageId: "msg-bot-1",
-        conversation: {
-          peerKind: "direct",
-          peerId: "HiDaoMax",
-          senderId: "HiDaoMax",
-        },
-        senderName: "HiDaoMax",
-        text: "hello",
-      } as any,
-      mediaService: createMediaService(),
-    });
-
-    expect(finalizeInboundContext).toHaveBeenCalledWith(
-      expect.objectContaining({
-        Provider: "wecom",
-        Surface: "wecom",
-        OriginatingChannel: "wecom",
-        OriginatingTo: "wecom:context:ctx-bot",
-        To: "wecom:user:HiDaoMax",
-      }),
-    );
-    expect(recordInboundSession).toHaveBeenCalledTimes(1);
-    expect(result.ctx.Provider).toBe("wecom");
-    expect(result.ctx.Surface).toBe("wecom");
-  });
-
-  it("keeps agent-callback turns on provider-only context", async () => {
-    getPeerContextToken.mockReturnValue(undefined);
-    const { core, finalizeInboundContext } = createCore();
-
-    const result = await prepareInboundSession({
-      core,
-      cfg: {} as any,
-      event: {
-        accountId: "default",
-        transport: "agent-callback",
-        messageId: "msg-agent-1",
-        conversation: {
-          peerKind: "direct",
-          peerId: "HiDaoMax",
-          senderId: "HiDaoMax",
-        },
-        senderName: "HiDaoMax",
-        text: "hello",
-      } as any,
-      mediaService: createMediaService(),
-    });
-
-    expect(finalizeInboundContext).toHaveBeenCalledWith(
-      expect.objectContaining({
-        Provider: "wecom",
-        OriginatingChannel: "wecom",
-        OriginatingTo: "wecom:user:HiDaoMax",
-      }),
-    );
-    expect(result.ctx.Provider).toBe("wecom");
-    expect(result.ctx).not.toHaveProperty("Surface");
-  });
-
-  it("registers SessionId for source lookups after context finalization", async () => {
-    getPeerContextToken.mockReturnValue(undefined);
-    const { core } = createCore();
-    core.channel.reply.finalizeInboundContext = vi.fn((ctx) => ({
-      ...ctx,
-      SessionId: "sess-agent-1",
-    }));
-
-    await prepareInboundSession({
-      core,
-      cfg: {} as any,
-      event: {
-        accountId: "default",
-        transport: "agent-callback",
-        messageId: "msg-agent-2",
-        conversation: {
-          peerKind: "direct",
-          peerId: "HiDaoMax",
-          senderId: "HiDaoMax",
-        },
-        senderName: "HiDaoMax",
-        text: "hello",
-      } as any,
-      mediaService: createMediaService(),
-    });
-
-    expect(registerWecomSourceSnapshot).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        accountId: "default",
-        source: "agent-callback",
-        messageId: "msg-agent-2",
-        sessionKey: "agent:ops_bot:wecom:direct:hidaomax",
-        sessionId: "sess-agent-1",
-        peerKind: "direct",
-        peerId: "HiDaoMax",
-      }),
-    );
-  });
-});

package/src/runtime/session-manager.ts

@@ -1,139 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-import type { WecomMediaService } from "../shared/media-service.js";
-import type { UnifiedInboundEvent } from "../types/index.js";
-import { getPeerContextToken } from "../context-store.js";
-import { buildWecomContextTarget } from "../target.js";
-import { resolveRuntimeRoute } from "./routing-bridge.js";
-import { registerWecomSourceSnapshot } from "./source-registry.js";
-
-export type PreparedSession = {
-  route: ReturnType<typeof resolveRuntimeRoute>;
-  ctx: ReturnType<PluginRuntime["channel"]["reply"]["finalizeInboundContext"]>;
-  storePath: string;
-};
-
-function readContextSessionId(ctx: { SessionId?: string } | Record<string, unknown>): string | undefined {
-  const sessionId = "SessionId" in ctx ? ctx.SessionId : undefined;
-  return typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : undefined;
-}
-
-export async function prepareInboundSession(params: {
-  core: PluginRuntime;
-  cfg: OpenClawConfig;
-  event: UnifiedInboundEvent;
-  mediaService: WecomMediaService;
-}): Promise<PreparedSession> {
-  const { core, cfg, event, mediaService } = params;
-  const route = resolveRuntimeRoute({ core, cfg, event });
-  const source =
-    event.transport === "bot-ws"
-      ? "bot-ws"
-      : event.transport === "agent-callback"
-        ? "agent-callback"
-        : undefined;
-  if (source) {
-    registerWecomSourceSnapshot({
-      accountId: event.accountId,
-      source,
-      messageId: event.messageId,
-      sessionKey: route.sessionKey,
-      peerKind: event.conversation.peerKind,
-      peerId: event.conversation.peerId,
-    });
-  }
-  const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
-    agentId: route.agentId,
-  });
-  const previousTimestamp = core.channel.session.readSessionUpdatedAt({
-    storePath,
-    sessionKey: route.sessionKey,
-  });
-  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
-  const body = core.channel.reply.formatAgentEnvelope({
-    channel: "WeCom",
-    from: `${event.conversation.peerKind}:${event.conversation.peerId}`,
-    previousTimestamp,
-    envelope: envelopeOptions,
-    body: event.text,
-  });
-
-  const firstAttachment = await mediaService.normalizeFirstAttachment(event);
-  const mediaPath = firstAttachment
-    ? await mediaService.saveInboundAttachment(event, firstAttachment)
-    : undefined;
-  const defaultOriginatingTo =
-    event.conversation.peerKind === "group"
-      ? `wecom:group:${event.conversation.peerId}`
-      : `wecom:user:${event.conversation.peerId}`;
-  const contextToken =
-    event.transport === "bot-ws"
-      ? getPeerContextToken(event.accountId, event.conversation.peerId)
-      : undefined;
-  const originatingTo = contextToken
-    ? buildWecomContextTarget(contextToken)
-    : defaultOriginatingTo;
-  const providerContext =
-    event.transport === "bot-ws"
-      ? {
-          // Bot WS inbound turns already have a live reply handle bound to the
-          // current req_id. Mark the current surface as WeCom so core final text
-          // stays on that handle and replaces the placeholder instead of being
-          // re-routed as a second active-push message.
-          Provider: "wecom" as const,
-          Surface: "wecom" as const,
-        }
-      : {
-          Provider: "wecom" as const,
-        };
-
-  const ctx = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    RawBody: event.text,
-    CommandBody: event.text,
-    From:
-      event.conversation.peerKind === "group"
-        ? `wecom:group:${event.conversation.peerId}`
-        : `wecom:user:${event.conversation.senderId}`,
-    To:
-      event.conversation.peerKind === "group"
-        ? `wecom:group:${event.conversation.peerId}`
-        : `wecom:user:${event.conversation.peerId}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: event.conversation.peerKind,
-    ConversationLabel: `${event.conversation.peerKind}:${event.conversation.peerId}`,
-    SenderName: event.senderName ?? event.conversation.senderId,
-    SenderId: event.conversation.senderId,
-    // Keep Originating* populated so explicit route-to-origin flows and message
-    // tools can still resolve the active peer context when needed.
-    ...providerContext,
-    OriginatingChannel: "wecom",
-    OriginatingTo: originatingTo,
-    MessageSid: event.messageId,
-    CommandAuthorized: true,
-    MediaPath: mediaPath,
-    MediaUrl: mediaPath,
-    MediaType: firstAttachment?.contentType,
-  });
-
-  if (source) {
-    registerWecomSourceSnapshot({
-      accountId: event.accountId,
-      source,
-      messageId: event.messageId,
-      sessionKey: ctx.SessionKey ?? route.sessionKey,
-      sessionId: readContextSessionId(ctx),
-      peerKind: event.conversation.peerKind,
-      peerId: event.conversation.peerId,
-    });
-  }
-
-  await core.channel.session.recordInboundSession({
-    storePath,
-    sessionKey: ctx.SessionKey ?? route.sessionKey,
-    ctx,
-    onRecordError: () => {},
-  });
-
-  return { route, ctx, storePath };
-}